mi0032 java and web design fall 2010

22
MI0032  Java and Web Designing  Assignment Set- 1 Q.1 what are various parameters of an applet tag. Answer: The Applet tag is used to embed an applet in an HTML document; the Applet tag takes zero or more parameters. The Applet Tag The Applet tag is written the Body tag of an HTML document. Syntax <APPLET CODE = “name of the class file that extends java.applet.Applet” CODEBASE = “path of the class file “ HEIGHT = “maximum height of the applet, in pixels “  WIDTH = “maximum width of the applet, in pixels “  VSPACE = “vertical space between the applet and the rest of the HTML “  HSPACE = “horizontal space between the applet and the rest of the HTML “  ALIGN = “alignment of the applet with respect to the rest of the web page “  ALT = “alternate text to be displayed if the browser does not support applets “ > <PARAM NAME=”parameter_name” value=”value_of_parameter”> …….. </APPLET> The most commonly used attributes of the Applet tag are CODE, HEIGHT, WIDTH, CODEBASE and ALT. You can send parameters to the applet using the PARAM tag. The PARAM tag must be written between <APPLET> and </APPLET> Example: <Applet Code = “clock. class” Height = 200 Width = 200 > </applet> Life Cycle of an Applet You can describe the life cycle of an applet through four methods. These methods are:  The init () method.  The start () method.  The stop () method.  The destroy () method.

Upload: ajmal1330

Post on 07-Apr-2018

219 views

Category:

Documents


0 download

TRANSCRIPT

Page 1: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 1/22

MI0032  –Java and Web Designing Assignment Set- 1

Q.1 what are various parameters of an applet tag.

Answer: The Applet tag is used to embed an applet in an HTML document; the Applet tag takes zeroor more parameters.

The Applet Tag 

The Applet tag is written the Body tag of an HTML document.

Syntax

<APPLET

CODE = “name of the class file that extends java.applet.Applet” 

CODEBASE = “path of the class file “ 

HEIGHT = “maximum height of the applet, in pixels “  

WIDTH = “maximum width of the applet, in pixels “ 

VSPACE = “vertical space between the applet and the rest of the HTML “  

HSPACE = “horizontal space between the applet and the rest of the HTML “  

ALIGN = “alignment of the applet with respect to the rest of the web page “  

ALT = “alternate text to be displayed if the browser does not support applets “ 

>

<PARAM NAME=”parameter_name” value=”value_of_parameter”> 

…….. 

</APPLET>

The most commonly used attributes of the Applet tag are CODE, HEIGHT, WIDTH, CODEBASE and

ALT. You can send parameters to the applet using the PARAM tag. The PARAM tag must be writtenbetween <APPLET> and </APPLET>

Example:

<Applet

Code = “clock. class” 

Height = 200

Width = 200 >

</applet>

Life Cycle of an Applet 

You can describe the life cycle of an applet through four methods. These methods are:

  The init () method.

  The start () method.

  The stop () method.

  The destroy () method.

Page 2: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 2/22

The init ( ) method 

The init () method is called the first time an applet is loaded into the memory of a computer. You can

initialize variables, and add components like buttons and check boxes to the applet in the init ()

method.

The start ( ) method 

The start () method is called immediately after the init () method and every time the applet receives

focus as a result of scrolling in the active window. You can use this method when you want to restart

a process, such as thread animation, every time the applet receives the focus.

The stop ( ) method 

The stop () method is called every time the applet loses the focus. You can use this method to reset

variables and stop the threads that are running.

The destroy ( ) method 

The destroy () method is called by the browser when the user moves to another page. You can use

this method to perform clean-up operations like closing a file.

The following diagram depicts the life cycle of an applet.

It is not mandatory to use any or all the methods of the applet. These methods are called

automatically by the Java environment, and hence, must be declared public. None of the methods

accept parameters. For example,

public void init ()

{

}

All but the most trivial applets override a set of methods that provides the basic mechanism by

which the browser or applet viewer interfaces to the applet and controls its execution. Four of these

methods –init( ), start( ), stop( ), and destroy( ) – are defined by Applet. Another, paint( ), is defined

by the AWT Component class. Default implementations for all of these methods are provided.

Page 3: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 3/22

Applets do not need to override those methods they do not use. However, only very simple applets

will not need to define all of them. These five methods can be assembled into the skeleton shown

here:

// An Applet skeleton.

import java.awt.*;

import java.applet.*;

/*

<applet code="AppletSkel" width=300 height=100>

</applet>

*/

public class AppletSkel extends Applet {

// Called first.

public void init() {

// initialization}

/* Called second, after init(). Also called whenever

the applet is restarted. */

public void start() {

// start or resume execution

}

// Called when the applet is stopped.

public void stop() {// suspends execution

}

/* Called when applet is terminated. This is the last

method executed. */

public void destroy() {

// perform shutdown activities

Page 4: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 4/22

Q.2 Write a short note on following topic:

a. Knock Knock Protocol

b. Datagram

Answer: A

The KnockKnockProtocol  class implements the protocol that the client and server use to

communicate. This class keeps track of where the client and the server are in their conversation and

serves up the server's response to the client's statements. The KnockKnockServer object contains

the text of all the jokes and makes sure that the client gives the proper response to the server's

statements. It wouldn't do to have the client say "Dexter who?" when the server says "Knock!

Knock!"

All client/server pairs must have some protocol by which they speak to each other; otherwise, thedata that passes back and forth would be meaningless. The protocol that your own clients and

servers use depends entirely on the communication required by them to accomplish the task.

Answer: B

Clients and servers that communicate via a reliable channel, such as a TCP socket, have a dedicated

point-to-point channel between themselves, or at least the illusion of one. To communicate, they

establish a connection, transmit the data, and then close the connection. All data sent over the

channel is received in the same order in which it was sent. This is guaranteed by the channel.

In contrast, applications that communicate via datagrams send and receive completely independent

packets of information. These clients and servers do not have and do not need a dedicated point-to-

point channel. The delivery of datagrams to their destinations is not guaranteed. Nor is the order of 

their arrival.

Definition: A datagram is an independent, self-contained message sent over the network whose

arrival, arrival time, and content are not guaranteed.

The java.net package contains three classes to help you write Java programs that use datagrams to

send and receive packets over the network: DatagramSocket, DatagramPacket, andMulticastSocketAn application can send and receive DatagramPackets through a DatagramSocket. In

addition, DatagramPackets can be broadcast to multiple recipients all listening to a MulticastSocket.

Writing a Datagram Client and Server 

The example featured in this section consists of two applications: a client and a server. The server

continuously receives datagram packets over a datagram socket. Each datagram packet received by

the server indicates a client request for a quotation. When the server receives a datagram, it replies

by sending a datagram packet that contains a one-line "quote of the moment" back to the client.

Page 5: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 5/22

The client application in this example is fairly simple. It sends a single datagram packet to the server

indicating that the client would like to receive a quote of the moment. The client then waits for the

server to send a datagram packet in response.

Two classes implement the server application: QuoteServer and QuoteServerThread. A single class

implements the client application: QuoteClient.

Let’s investigate these classes, starting with the class that contains the main method for the server

application. Working with a Server-Side Application contains an applet version of the QuoteClient

class.

The QuoteServer Class

The QuoteServer class, shown here in its entirety, contains a single method: the main method for

the quote server application. The main method simply creates a new QuoteServerThread object and

starts it:

import java.io.*;

public class QuoteServer {

public static void main(String[] args) throws IOException {

new QuoteServerThread().start();

}

}

The QuoteServerThread class implements the main logic of the quote server.

The QuoteServerThread Class

When created, the QuoteServerThread creates a DatagramSocket on port 4445 (arbitrarily chosen).

This is the DatagramSocket through which the server communicates with all of its clients.

public QuoteServerThread() throws IOException {

this("QuoteServer");

}

public QuoteServerThread(String name) throws IOException {

super(name);

socket = new DatagramSocket(4445);

try {

in = new BufferedReader(

new FileReader("one-liners.txt"));

} catch (FileNotFoundException e)

System.err.println("Couldn't open quote file. " +

"Serving time instead.");

}

}

Remember that certain ports are dedicated to well-known services and you cannot use them. If youspecify a port that is in use, the creation of the DatagramSocket will fail.

Page 6: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 6/22

The constructor also opens a BufferedReader on a file named one-liners.txt which contains a list of 

quotes. Each quote in the file is on a line by itself.

Now for the interesting part of the QuoteServerThread: its run method. The run method overrides

run in the Thread class and provides the implementation for the thread. For information about

threads, see Defining and Starting a Thread.

The run method contains a while loop that continues as long as there are more quotes in the file.

During each iteration of the loop, the thread waits for a DatagramPacket to arrive over the

DatagramSocket. The packet indicates a request from a client. In response to the client’s request,

the QuoteServerThread gets a quote from the file, puts it in a DatagramPacket and sends it over the

DatagramSocket to the client that asked for it.

Let’s look first at the section that receives the requests from clients:

byte[] buf = new byte[256];

DatagramPacket packet = new DatagramPacket(buf, buf.length);socket.receive(packet);

The first statement creates an array of bytes which is then used to create a DatagramPacket. The

DatagramPacket will be used to receive a datagram from the socket because of the constructor used

to create it. This constructor requires only two arguments: a byte array that contains client-specific

data and the length of the byte array. When constructing a DatagramPacket to send over the

DatagramSocket, you also must supply the Internet address and port number of the packet’s

destination. You’ll see this later when we discuss how the server responds to a client request.

The last statement in the previous code snippet receives a datagram from the socket (the

information received from the client gets copied into the packet). The receive method waits foreveruntil a packet is received. If no packet is received, the server makes no further progress and just

waits.

Now assume that, the server has received a request from a client for a quote. Now the server must

respond. This section of code in the run method constructs the response:

String dString = null;

if (in == null)

dString = new Date().toString();

else

dString = getNextQuote();buf = dString.getBytes();

If the quote file did not get opened for some reason, then in equals null. If this is the case, the quote

server serves up the time of day instead. Otherwise, the quote server gets the next quote from the

already opened file. Finally, the code converts the string to an array of bytes.

Now, the run method sends the response to the client over the DatagramSocket with this code:

InetAddress address = packet.getAddress();

int port = packet.getPort();

packet = new DatagramPacket(buf, buf.length, address, port);socket.send(packet);

Page 7: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 7/22

The first two statements in this code segment get the Internet address and the port number,

respectively, from the datagram packet received from the client. The Internet address and port

number indicate where the datagram packet came from. This is where the server must send its

response. In this example, the byte array of the datagram packet contains no relevant information.

The arrival of the packet itself indicates a request from a client that can be found at the Internet

address and port number indicated in the datagram packet.

The third statement creates a new Datagram Packet object intended for sending a datagram

message over the datagram socket. You can tell that the new Datagram Packet is intended to send

data over the socket because of the constructor used to create it. This constructor requires four

arguments. The first two arguments are the same required by the constructor used to create

receiving datagrams: a byte array containing the message from the sender to the receiver and the

length of this array. The next two arguments are different: an Internet address and a port number.

These two arguments are the complete address of the destination of the datagram packet and must

be supplied by the sender of the datagram. The last line of code sends the DatagramPacket on its

way.

When the server has read all the quotes from the quote file, the while loop terminates and the run

method cleans up:

socket.close();

The QuoteClient Class

The QuoteClient class implements a client application for the QuoteServer. This application sends a

request to the QuoteServer, waits for the response, and, when the response is received, displays it

to the standard output. Let’s look at the code in detail.

The QuoteClient class contains one method, the main method for the client application. The top of 

the main method declares several local variables for its use:

int port;

InetAddress address;

DatagramSocket socket = null;

DatagramPacket packet;byte[] sendBuf = new byte[256];

First, the main method processes the command-line arguments used to invoke the QuoteClient

application:

if (args.length != 1) {

System.out.println("Usage: java QuoteClient <hostname>");

return;

}

The QuoteClient application requires one command-line arguments: the name of the machine onwhich the QuoteServer is running.

Page 8: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 8/22

Next, the main method creates a DatagramSocket:

DatagramSocket socket = new DatagramSocket();

The client uses a constructor that does not require a port number. This constructor just binds the

DatagramSocket to any available local port. It doesn’t matter what port the client is bound tobecause the DatagramPackets contain the addressing information. The server gets the port number

from the DatagramPackets and send its response to that port.

Next, the QuoteClient program sends a request to the server:

byte[ ] buf = new byte[256];

InetAddress address = InetAddress.getByName(args[0]);

DatagramPacket packet = new DatagramPacket(buf, buf.length,

address, 4445);

socket.send(packet);

The code segment gets the Internet address for the host named on the command line (presumably

the name of the machine on which the server is running). This InetAddress and the port number

4445 (the port number that the server used to create its DatagramSocket) are then used to create

DatagramPacket destined for that Internet address and port number. Therefore the DatagramPacket

will be delivered to the quote server.

Note that the code creates a DatagramPacket with an empty byte array. The byte array is empty

because this datagram packet is simply a request to the server for information. All the server needs

to know to send a response –the address and port number to which reply –is automatically part of 

the packet.

Next, the client gets a response from the server and displays it:

packet = new DatagramPacket(buf, buf.length);

socket.receive(packet);

String received = new String(packet.getData(), 0, packet.getLength());

System.out.println("Quote of the Moment: " + received);

To get a response from the server, the client creates a "receive" packet and uses the

DatagramSocket receive method to receive the reply from the server. The receive method waits until

a datagram packet destined for the client comes through the socket. Note that if the server’s reply is

somehow lost, the client will wait forever because of the no-guarantee policy of the datagrammodel. Normally, a client sets a timer so that it doesn’t wait forever for a reply; if no reply arrives,

the timer goes off and the client retransmits.

When the client receives a reply from the server, the client uses the getData method to retrieve that

data from the packet. The client then converts the data to a string and displays it.

Running the Server and Client

After you’ve successfully compiled the server and the client programs, you run them. You have to

run the server program first. Just use the Java interpreter and specify the QuoteServer class name.

Page 9: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 9/22

Once the server has started, you can run the client program. Remember to run the client program

with one command-line argument: the name of the host on which the QuoteServer is running.

After the client sends a request and receives a response from the server, you should see output

similar to this:

Quote of the Moment:

Good programming is 99% sweat and 1% coffee.

Page 10: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 10/22

Q.3 what are the different access specifiers in Java? How can we call a superclass constructor?

Explain with a suitable example.

Answer: An access specifier determines which features of a class (the class itself, the data members,

and the methods) may be used by other classes. Java supports three access specifiers. 

  public

  private

  protected

The public Access Specifiers 

All classes except inner class (class within classes) can have the public access specifier. You can use a

public class, a data member, or a method from any object in any Java program.

Example

public class publicclass

{

public int publicvaraible;

public void publicmethod ()

{

}

}

The private Access Specifier 

Only objects of the same class can access a private variable or method. You can declare only

variables, methods, and inner classes as private.

Example

private int privatevariable;

The protected Access Specifier 

The variables, methods, and inner classes that are declared protected are accessible to the

subclasses of the class in which they are declared.

Example

protected int protectedvariable;

Page 11: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 11/22

Default Access 

If you do not specify any of the above access specifiers, the scope is friendly. A class, variable, or

method that has friendly access is accessible to all the classes of a package.

Consider the following set of classes. Class Y and Z inherit from class X. Class Z belongs to a packagedifferent than that of classes X and Y

A method accessMe () has been declared in class X. The following table shows you the accessibility of 

the method accessMe () from classes Y and Z

Access Specifier Class Y Class Z

accessME ( ) is declared as

protected

Accessible, as Y is a subclass Accessible, as Z is a subclass

(event if it is in another package)

accessMe ( ) is declared

without an access

specifier (friendly)

Accessible, as it is in the

same package

Not accessible, as it is not in the

same package

You can access a non-private variable or method using an object of the class as shown below:

Someclass classobject = new someclass ();

classobject.publicvariable;

classobject.protectedmethod ();

Although a subclass includes all of the members of its superclass, it cannot access those members of 

the superclass that have been declared as private. For example, consider the following simple class

hierarchy:

/* In a class hierarchy, private members remain

private to their class.

This program contains an error and will not

compile.

*/

// Create a superclass.

Page 12: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 12/22

class A {

int i; // public by default

private int j; // private to A

void setij(int x, int y) {

i = x;

 j = y;

}

}

// A’s j is not accessible here. 

class B extends A {

int total;

void sum() {

total = i + j; // ERROR, j is not accessible here

}

}

class Access {

public static void main(String args[]) {

B subOb = new B();

subOb.setij(10, 12);

subOb.sum();

System.out.println("Total is " + subOb.total);

}

}

This program will not compile because the reference to  j inside the sum( ) method of B causes an

access violation. Since j is declared as private, it is only accessible by other members of its own class.

Subclasses have no access to it.

Page 13: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 13/22

Note: A class member that has been declared as private will remain private to its class. It is not

accessibl e by any code outside its class, including subclasses.

A Superclass Variable Can Reference a Subclass Object 

A reference variable of a superclass can be assigned a reference to any subclass derived from thatsuperclass. You will find this aspect of inheritance quite useful in a variety of situations. For example,

consider the following:

class Ref Demo {

public static void main(String args[]) {

BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);

Box plainbox = new Box();

double vol;

vol = weightbox.volume();

System.out.println("Volume of weightbox is " + vol);

System.out.println("Weight of weightbox is " +

weightbox.weight);

System.out.println();

// assign BoxWeight reference to Box reference

plainbox = weightbox;

vol = plainbox.volume(); // OK, volume() defined in Box

System.out.println("Volume of plainbox is " + vol);

/* The following statement is invalid because plainbox

does not define a weight member. */

// System.out.println("Weight of plainbox is " +

plainbox.weight);

}

}

Page 14: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 14/22

Here, weightbox is a reference to BoxWeight objects, and plainbox is a reference to Box objects.

Since BoxWeight is a subclass of  Box, it is permissible to assign plainbox a reference to the

weightbox object.

It is important to understand that it is the type of the reference variable – not the type of the object

that it refers to  – that determines what members can be accessed. That is, when a reference to asubclass object is assigned to a superclass reference variable, you will have access only to those

parts of the object defined by the superclass. This is why plainbox can’t access weight even when it

refers to a BoxWeight object. If you think about it, this makes sense, because the superclass has no

knowledge of what a subclass adds to it. This is why the last line of code in the preceding fragment is

commented out. It is not possible for a Box reference to access the weight field, because it does not

define one.

Although the preceding may seem a bit esoteric, it has some important practical applications  – two

of which are discussed later in this chapter.

Using super 

In the preceding examples, classes derived from Box were not implemented as efficiently or as

robustly as they could have been. For example, the constructor for BoxWeight explicitly initializes

the width, height, and depth fields of  Box( ). Not only does this duplicate code found in its

superclass, which is inefficient, but it implies that a subclass must be granted access to these

members. However, there will be times when you will want to create a superclass that keeps the

details of its implementation to itself (that is, that keeps its data members private). In this case,

there would be no way for a subclass to directly access or initialize these variables on its own. Since

encapsulation is a primary attribute of OOP, it is not surprising that Java provides a solution to this

problem. Whenever a subclass needs to refer to its immediate superclass, it can do so by use of the

keyword super.

super has two general forms. The first calls the superclass’ constructor. The second is used to access

a member of the superclass that has been hidden by a member of a subclass. Each use is examined

here.

Using super to Call Superclass Constructors 

A subclass can call a constructor method defined by its superclass by use of the following form of 

super:

super( parameter -list );

Here, parameter -list specifies any parameters needed by the constructor in the superclass. super( )

must always be the first statement executed inside a subclass’ constructor. To see how super( ) is

used, consider this improved version of the BoxWeight( ) class:

// BoxWeight now uses super to initialize its Box attributes.

class BoxWeight extends Box {

double weight; // weight of box

// initialize width, height, and depth using super()

Page 15: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 15/22

BoxWeight(double w, double h, double d, double m) {

super(w, h, d); // call superclass constructor

weight = m;

}

}

Here, BoxWeight( ) calls super( ) with the parameters w, h, and d. This causes the Box( ) constructor

to be called, which initializes width, height, and depth using these values. BoxWeight no longer

initializes these values itself. It only needs to initialize the value unique to it: weight. This leaves Box

free to make these values private if desired.

In the preceding example, super( ) was called with three arguments. Since constructors can be

overloaded, super( ) can be called using any form defined by the superclass. The constructorexecuted will be the one that matches the arguments. For example, here is a complete

implementation of  BoxWeight that provides constructors for the various ways that a box can be

constructed. In each case, super( ) is called using the appropriate arguments. Notice that width,

height, and depth have been made private within Box.

// A complete implementation of BoxWeight.

class Box {

private double width;

private double height;

private double depth;

// construct clone of an object

Box(Box ob) { // pass object to constructor

width = ob.width;

height = ob.height;

depth = ob.depth;

}

// constructor used when all dimensions specified

Box(double w, double h, double d) {

width = w;

height = h;

Page 16: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 16/22

depth = d;

}

// constructor used when no dimensions specified

Box() {

width = -1; // use -1 to indicate

height = -1; // an uninitialized

depth = -1; // box

}

// constructor used when cube is created

Box(double len) {

width = height = depth = len;

}

// compute and return volume

double volume() {

return width * height * depth;

}

}

// BoxWeight now fully implements all constructors.

class BoxWeight extends Box {

double weight; // weight of box

// construct clone of an object

BoxWeight(BoxWeight ob) { // pass object to constructor

super(ob);

weight = ob.weight;

}

Page 17: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 17/22

// constructor when all parameters are specified

BoxWeight(double w, double h, double d, double m) {

super(w, h, d); // call superclass constructor

weight = m;

}

// default constructor

BoxWeight() {

super();

weight = -1;

}

// constructor used when cube is created

BoxWeight(double len, double m) {

super(len);

weight = m;

}

}

class DemoSuper {

public static void main(String args[]) {

BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);

BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);

BoxWeight mybox3 = new BoxWeight(); // default

BoxWeight mycube = new BoxWeight(3, 2);

BoxWeight myclone = new BoxWeight(mybox1);

double vol;

vol = mybox1.volume();

Page 18: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 18/22

System.out.println("Volume of mybox1 is " + vol);

System.out.println("Weight of mybox1 is " + mybox1.weight);

System.out.println();

vol = mybox2.volume();

System.out.println("Volume of mybox2 is " + vol);

System.out.println("Weight of mybox2 is " + mybox2.weight);

System.out.println();

vol = mybox3.volume();

System.out.println("Volume of mybox3 is " + vol);

System.out.println("Weight of mybox3 is " + mybox3.weight);

System.out.println();

vol = myclone.volume();

System.out.println("Volume of myclone is " + vol);

System.out.println("Weight of myclone is " + myclone.weight);

System.out.println();

vol = mycube.volume();

System.out.println("Volume of mycube is " + vol);

System.out.println("Weight of mycube is " + mycube.weight);

System.out.println();

}

}

This program generates the following output:

Volume of mybox1 is 3000.0

Weight of mybox1 is 34.3

Volume of mybox2 is 24.0

Page 19: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 19/22

Weight of mybox2 is 0.076

Volume of mybox3 is -1.0

Weight of mybox3 is -1.0

Volume of myclone is 3000.0

Weight of myclone is 34.3

Volume of mycube is 27.0

Weight of mycube is 2.0

Pay special attention to this constructor in BoxWeight( ):

// construct clone of an object

BoxWeight(BoxWeight ob) { // pass object to constructor

super(ob);

weight = ob.weight;

}

Notice that super( ) is called with an object of type BoxWeight – not of type Box. This still invokes

the constructor Box(Box ob). As mentioned earlier, a superclass variable can be used to referenceany object derived from that class. Thus, we are able to pass a BoxWeight object to the Box

constructor. Of course, Box only has knowledge of its own members.

Let’s review the key concepts behind super( ). When a subclass calls super( ), it is calling the

constructor of its immediate superclass. Thus, super( ) always refers to the superclass immediately

above the calling class. This is true even in a multileveled hierarchy. Also, super( ) must always be

the first statement executed inside a subclass constructor.

A Second Use for super 

The second form of super acts somewhat like this, except that it always refers to the superclass of 

the subclass in which it is used. This usage has the following general form:

super.member  

Here, member can be either a method or an instance variable.

This second form of super is most applicable to situations in which member names of a subclass hide

members by the same name in the superclass. Consider this simple class hierarchy:

// Using super to overcome name hiding.

class A {

Page 20: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 20/22

int i;

}

// Create a subclass by extending class A.

class B extends A {

int i; // this i hides the i in A

B(int a, int b) {

super.i = a; // i in A

i = b; // i in B

}

void show() {

System.out.println("i in superclass: " + super.i);

System.out.println("i in subclass: " + i);

}

}

class UseSuper {

public static void main(String args[]) {

B subOb = new B(1, 2);

subOb.show();

}

}

This program displays the following:

i in superclass: 1

i in subclass: 2

Although the instance variable i in B hides the i in A, super allows access to the i defined in the

superclass. As you will see, super can also be used to call methods that are hidden by a subclass.

(5) The abstract class 

Page 21: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 21/22

An abstract class defines common properties and behaviors of other classes. An abstract class is

used as a base class to derive specific classes of the same kind. It defines properties common to the

classes derived from it. The abstract keyword is used to declare such a class. The classes declared

using the abstract keyword cannot be instantiated.

Syntax

abstract class <class_name>

{

}

You can also declare abstract methods. Abstract methods have public scope. The code below

declares an abstract method for the class shape.

abstract class shape

{

public abstract float calculateArea ();

}

The abstract method calculateArea (), given above, is inherited by the subclasses of the shape class.

The subclasses Rectangle, Circle and Hexagon implement this method in different ways.

public class circle extends shape

{

float radius;

public float calculateArea ()

{

return radius*22/7;

}

}

In the above example, the calculateArea () method has been overridden in the circle class. If the

method is not overridden, the class will inherit the abstract method from the parent class. Any class

that has a abstract method is abstract. Hence, you would not be able to create an object of the circle

class. Therefore, it is necessary to override the calculateArea () method in the circle class.

The final Keyword 

Page 22: MI0032 Java and Web Design Fall 2010

8/4/2019 MI0032 Java and Web Design Fall 2010

http://slidepdf.com/reader/full/mi0032-java-and-web-design-fall-2010 22/22

A class called password authenticates user login. You do not want anybody to change the

functionality of the class by extending it. To prevent inheritance, use the final modifier.

Example

final class password

{

}

You will also find final classes in JDK package. For example, the java.lang.String class has been

declared final. This is done for security reasons. It ensures that any method that refers to the String

class gets the actual String class and not a modified one.