yet another insignificant programming notes...

| HOME

TABLE OF CONTENTS HIDE

1.Composition

Java Programming
1.1Composition EG. 1: The Author
1.2Composition EG. 2: The Point
1.3Composition EG. 3: The Point
Tutorial 1.4Exercises
2.Inheritance

OOP Composition,
2.1Inheritance EG. 1: The Circle and
2.2Method Overriding & Variable Hiding

Inheritance &
2.3Annotation @Override JDK 1.5
2.4Keyword "super"

Polymorphism
2.5More on Constructors
2.6Default noarg Constructor
2.7Single Inheritance
2.8Common Root Class java.lang.Object
2.9Inheritance EG. 2: The Point2D
2.10Inheritance EG. 3: Superclass
1.Composition 2.11Exercises
3.Composition vs. Inheritance
There are two ways to reuse existing classes, namely, composition and inheritance.
3.1"A line is composed of 2 points" vs. "A line is
With composition aka aggregation, you define a new class, which is composed of
3.2Exercises
existing classes. With inheritance, you derive a new class based on an existing
4.Polymorphism
class, with modifications or extensions.
4.1Substitutability
We shall begin with reusing classes via composition through examples. 4.2Polymorphism EG. 1 Shape and its Subclas
4.3Polymorphism EG. 2 Monster

1.1Composition EG. 1: The Author and Book Classes 4.4Upcasting & Downcasting
4.5The "instanceof" Operator
Let's start with the Author class 4.6Summary of Polymorphism
4.7Exercises
5.Abstract Classes & Interfaces
5.1The abstract Method and abstract
5.2Abstract Class EG. 1: Shape and its Subclasse
5.3Abstract Class EG. 2: Monster
5.4The Java's interface
5.5Interface EG. 1: Shape Interface and its Imple
5.6Interface EG. 2: Movable Interface and its Im
5.7Implementing Multiple Interfaces
5.8interface Formal Syntax
5.9Why interfaces?
5.10Interface vs. Abstract Superclass
5.11Exercises
5.12Advanced Dynamic Binding or Late Bindin
5.13Exercises
6.Advanced ObjectOriented Design Issues
6.1Encapsulation, Coupling & Cohesion
6.2"Isa" vs. "hasa" relationships
6.3Program at the interface, not the implement
A class called Author is designed as shown in the class diagram. It contains:
Three private member variables: name String, email String, and gender char of either 'm' or 'f' you might
also use a boolean variable called isMale having value of true or false.
A constructor to initialize the name, email and gender with the given values.
There is no default constructor, as there is no default value for name, email and gender.
Public getters/setters: getName(), getEmail(), setEmail(), and getGender().
There are no setters for name and gender, as these properties are not designed to be changed.

A toString() method that returns "name (gender) at email", e.g., "Tan Ah Teck (m) at
ahTeck@somewhere.com".

The Author Class Author.java

1 /*
2 *TheAuthorclassmodelabook'sauthor.
3 */
4 publicclassAuthor{
5 //Theprivateinstancevariables
6 privateStringname;
7 privateStringemail;
8 privatechargender;//'m'or'f'
9
10 //Theconstructor
11 publicAuthor(Stringname,Stringemail,chargender){
12 this.name=name;
13 this.email=email;
14 this.gender=gender;
15 }
16
17 //Thepublicgettersandsettersfortheprivateinstancevariables.
18 //Nosetterfornameandgenderastheyarenotdesignedtobechanged.
19 publicStringgetName(){
20 returnname;
21 }
22 publicchargetGender(){
23 returngender;
24 }
25 publicStringgetEmail(){
26 returnemail;
27 }
28 publicvoidsetEmail(Stringemail){
29 this.email=email;
30 }
31
32 //ThetoString()describesitself
33 publicStringtoString(){
34 returnname+"("+gender+")at"+email;
35 }
36 }
A Test Driver for the Author Class TestAuthor.java
1 /*
2 *AtestdriverfortheAuthorclass.
3 */
4 publicclassTestAuthor{
5 publicstaticvoidmain(String[]args){
6 //TestconstructorandtoString()
7 AuthorahTeck=newAuthor("TanAhTeck","teck@nowhere.com",'m');
8 System.out.println(ahTeck);//toString()
9
10 //TestSettersandGetters
11 ahTeck.setEmail("teck@somewhere.com");
12 System.out.println(ahTeck);//toString()
13 System.out.println("nameis:"+ahTeck.getName());
14 System.out.println("genderis:"+ahTeck.getGender());
15 System.out.println("emailis:"+ahTeck.getEmail());
16 }
17 }

A Book is written by one Author Using an "Object" Member Variable

Let's design a Book class. Assume that a book is written by one and exactly one author. The Book class as shown in the
class diagram contains the following members:
Four private member variables: name String, author an instance of the Author class we have just created,
assuming that each book has exactly one author, price double, and qty int.

The public getters and setters: getName(), getAuthor(), getPrice(), setPrice(), getQty(), setQty().
A toString() that returns "'bookname' by authorname (gender) at email". You could reuse the Author's
toString() method, which returns "authorname(gender)atemail".

The Book Class Book.java

1 /*
2 *TheBookclassmodelsabookwithone(andonlyone)author.
3 */
4 publicclassBook{
5 //Theprivateinstancevariables
6 privateStringname;
7 privateAuthorauthor;
8 privatedoubleprice;
9 privateintqty;
10
 11 //Constructor
12 publicBook(Stringname,Authorauthor,doubleprice,intqty){
13 this.name=name;
14 this.author=author;
15 this.price=price;
16 this.qty=qty;
17 }
18
19 //GettersandSetters
20 publicStringgetName(){
21 returnname;
22 }
23 publicAuthorgetAuthor(){
24 returnauthor;//returnmemberauthor,whichisaninstanceoftheclassAuthor
25 }
26 publicdoublegetPrice(){
27 returnprice;
28 }
29 publicvoidsetPrice(doubleprice){
30 this.price=price;
31 }
32 publicintgetQty(){
33 returnqty;
34 }
35 publicvoidsetQty(intqty){
36 this.qty=qty;
37 }
38
39 //ThetoString()describesitself
40 publicStringtoString(){
41 return"'"+name+"'by"+author;//author.toString()
42 }
43 }

A Test Driver Program for the Book Class TestBook.java

1 /*
2 *AtestdriverprogramfortheBookclass.
3 */
4 publicclassTestBook{
5 publicstaticvoidmain(String[]args){
6 //WeneedanAuthorinstancetocreateaBookinstance
7 AuthorahTeck=newAuthor("TanAhTeck","ahTeck@somewhere.com",'m');
8 System.out.println(ahTeck);//Author'stoString()
9
10 //TestBook'sconstructorandtoString()
11 BookdummyBook=newBook("Javafordummies",ahTeck,9.99,99);
12 System.out.println(dummyBook);//Book'stoString()
13
14 //TestSettersandGetters
15 dummyBook.setPrice(8.88);
16 dummyBook.setQty(88);
17 System.out.println(dummyBook);//Book'stoString()
18 System.out.println("nameis:"+dummyBook.getName());
19 System.out.println("priceis:"+dummyBook.getPrice());
20 System.out.println("qtyis:"+dummyBook.getQty());
21 System.out.println("authoris:"+dummyBook.getAuthor());//invokeAuthor'stoString()
22 System.out.println("author'snameis:"+dummyBook.getAuthor().getName());
23 System.out.println("author'semailis:"+dummyBook.getAuthor().getEmail());
24 System.out.println("author'sgenderis:"+dummyBook.getAuthor().getGender());
25
26 //UsingananonymousAuthorinstancetocreateaBookinstance
27 BookmoreDummyBook=newBook("Javaformoredummies",
28 newAuthor("PeterLee","peter@nowhere.com",'m'),//ananonymousAuthor'sinstance
29 19.99,8);
30 System.out.println(moreDummyBook);//Book'stoString()
31 }
 32 }

1.2Composition EG. 2: The Point and Line Classes

As an example of reusing a class via composition, suppose that we have an existing class called Point, defined as shown in
the above class diagram. The source code is HERE.

Suppose that we need a new class called Line, we can design the Line class by reusing the Point class via composition.
We say that "A line is composed of two points", or "A line has two points". Composition exhibits a "hasa" relationship.

UML Notation: In UML notations, composition is represented as a diamondhead line pointing to its constituents.

The Line Class via Composition Line.java

1 /*
2 *ALinecomposesoftwoPointsabeginpointandanendpoint.
3 */
4 publicclassLine{
5 //Theprivateinstancevariables
6 Pointbegin,end;//ObjectmembersinstancesofthePointclass
7
 8 //Constructors
9 publicLine(intx1,inty1,intx2,inty2){
10 begin=newPoint(x1,y1);//Constructtheinstancesdeclared
11 end=newPoint(x2,y2);
12 }
13 publicLine(Pointbegin,Pointend){
14 this.begin=begin;//Thecallerconstructedtheinstances
15 this.end=end;
16 }
17
18 //Thepublicgetterandsetterfortheprivateinstancevariables
19 publicPointgetBegin(){
20 returnbegin;
21 }
22 publicPointgetEnd(){
23 returnend;
24 }
25 publicvoidsetBegin(Pointbegin){
26 this.begin=begin;
27 }
28 publicvoidsetEnd(Pointend){
29 this.end=end;
30 }
31
32 publicintgetBeginX(){
33 returnbegin.getX();//Point'sgetX()
34 }
35 publicvoidsetBeginX(intx){
36 begin.setX(x);//Point'ssetX()
37 }
38 publicintgetBeginY(){
39 returnbegin.getY();//Point'sgetY()
40 }
41 publicvoidsetBeginY(inty){
42 begin.setY(y);//Point'ssetY()
43 }
44 publicint[]getBeginXY(){
45 returnbegin.getXY();//Point'sgetXY()
46 }
47 publicvoidsetBeginXY(intx,inty){
48 begin.setXY(x,y);//Point'ssetXY()
49 }
50 publicintgetEndX(){
51 returnend.getX();//Point'sgetX()
52 }
53 publicvoidsetEndX(intx){
54 end.setX(x);//Point'ssetX()
55 }
56 publicintgetEndY(){
57 returnend.getY();//Point'sgetY()
58 }
59 publicvoidsetEndY(inty){
60 end.setY(y);//Point'ssetY()
61 }
62 publicint[]getEndXY(){
63 returnend.getXY();//Point'sgetXY()
64 }
65 publicvoidsetEndXY(intx,inty){
66 end.setXY(x,y);//Point'ssetXY()
67 }
68
69 //ThetoString()describeitself
70 publicStringtoString(){
71 return"Line[begin="+begin+",end="+end+"]";
72 //Invokebegin.toString()andend.toString()
73 }
74
 75 publicdoublegetLength(){
76 returnbegin.distance(end);//Point'sdistance()
77 }
78 }

A Test Driver for Line Class TestLine.java

1 /*
2 *ATestDriverfortheLineclass.
3 */
4 publicclassTestLine{
5 publicstaticvoidmain(String[]args){
6 //TestconstructorandtoString()
7 Linel1=newLine(1,2,3,4);
8 System.out.println(l1);//Line'stoString()
9 Linel2=newLine(newPoint(5,6),newPoint(7,8));//anonymousPoint'sinstances
10 System.out.println(l2);//Line'stoString()
11
12 //TestSettersandGetters
13 l1.setBegin(newPoint(11,12));
14 l1.setEnd(newPoint(13,14));
15 System.out.println(l1);//Line'stoString()
16 System.out.println("beginis:"+l1.getBegin());//Point'stoString()
17 System.out.println("endis:"+l1.getEnd());//Point'stoString()
18
19 l1.setBeginX(21);
20 l1.setBeginY(22);
21 l1.setEndX(23);
22 l1.setEndY(24);
23 System.out.println(l1);//Line'stoString()
24 System.out.println("begin'sxis:"+l1.getBeginX());
25 System.out.println("begin'syis:"+l1.getBeginY());
26 System.out.println("end'sxis:"+l1.getEndX());
27 System.out.println("end'syis:"+l1.getEndY());
28
29 l1.setBeginXY(31,32);
30 l1.setEndXY(33,34);
31 System.out.println(l1);//Line'stoString()
32 System.out.println("begin'sxis:"+l1.getBeginXY()[0]);
33 System.out.println("begin'syis:"+l1.getBeginXY()[1]);
34 System.out.println("end'sxis:"+l1.getEndXY()[0]);
35 System.out.println("end'syis:"+l1.getEndXY()[1]);
36
37 //TestgetLength()
38 System.out.printf("lengthis:%.2f%n",l1.getLength());
39 }
40 }

TRY
Try writing these more complex methods for the Line class:

//Returnthegradientofthislineinradian(useMath.atan2(y,x)).
publicdoublegetGradient();

//Returnthedistancefromthislinetothegivenpoint.
publicdoubledistance(intx,inty);
publicdoubledistance(Pointp);

//Returntrueifthislineintersectsthegivenline.
publicboolenintersects(Lineanother);

1.3Composition EG. 3: The Point and Circle Classes

Suppose that we have an existing class called Point, defined as shown in the class diagram. The source code is HERE.
A class called Circle is designed as shown in the class diagram.

It contains:
Two private member variables: a radius double and a center an instance of Point class, which we created earlier.
The constructors, public getters and setters.
Methods getCenterX(), setCenterX(), getCenterY(), setCenterY(), getCenterXY(), setCenterXY(), etc.
A toString() method that returns a string description of this instance in the format of "Circle[center=
(x,y),radius=r]". You should reuse the Point's toString() to print "(x,y)".
A distance(Circleanother) method that returns the distance from the center of this instance to the center of the
given Circle instance called another.

The Circle class Circle.java

1 /*
2 *TheCircleclasscomposesaPoint(asitscenter)andaradius.
3 */
4 publicclassCircle{
5 //Theprivatemembervariables
6 privatePointcenter;//DeclareaninstanceofthePointclass
 7 privatedoubleradius;
8
9 //Constructors
10 publicCircle(){
11 this.center=newPoint();//ConstructaPointat(0,0)
12 this.radius=1.0;
13 }
14 publicCircle(intxCenter,intyCenter,doubleradius){
15 center=newPoint(xCenter,yCenter);//ConstructaPointat(xCenter,yCenter)
16 this.radius=radius;
17 }
18 publicCircle(Pointcenter,doubleradius){
19 this.center=center;//ThecallerconstructedanPointinstance
20 this.radius=radius;
21 }
22
23 //GettersandSetters
24 publicdoublegetRadius(){
25 returnthis.radius;
26 }
27 publicvoidsetRadius(doubleradius){
28 this.radius=radius;
29 }
30 publicPointgetCenter(){
31 returnthis.center;//returnaPointinstance
32 }
33 publicvoidsetCenter(Pointcenter){
34 this.center=center;
35 }
36
37 publicintgetCenterX(){
38 returncenter.getX();//Point'sgetX()
39 }
40 publicvoidsetCenterX(intx){
41 center.setX(x);//Point'ssetX()
42 }
43 publicintgetCenterY(){
44 returncenter.getY();//Point'sgetY()
45 }
46 publicvoidsetCenterY(inty){
47 center.setY(y);//Point'ssetY()
48 }
49 publicint[]getCenterXY(){
50 returncenter.getXY();//Point'sgetXY()
51 }
52 publicvoidsetCenterXY(intx,inty){
53 center.setXY(x,y);//Point'ssetXY()
54 }
55
56 publicStringtoString(){
57 return"Circle[center="+center+",radius="+radius+"]";//invokecenter.toString()
58 }
59
60 publicdoublegetArea(){
61 returnMath.PI*radius*radius;
62 }
63
64 publicdoublegetCircumference(){
65 return2.0*Math.PI*radius;
66 }
67
68 //Returnthedistancefromthecenterofthisinstancetothecenterof
69 //thegivenCircleinstancecalledanother.
70 publicdoubledistance(Circleanother){
71 returncenter.distance(another.center);//Invokedistance()ofthePointclass
72 }
73 }
A Test Driver for the Circle Class TestCircle.java
1 /*
2 *AtestdriverfortheCircleclass.
3 */
4 publicclassTestCircle{
5 publicstaticvoidmain(String[]args){
6 //TestConstructorsandtoString()
7 Circlec1=newCircle();
8 System.out.println(c1);//Circle'stoString()
9 Circlec2=newCircle(1,2,3.3);
10 System.out.println(c2);//Circle'stoString()
11 Circlec3=newCircle(newPoint(4,5),6.6);//ananonymousPointinstance
12 System.out.println(c3);//Circle'stoString()
13
14 //TestSettersandGetters
15 c1.setCenter(newPoint(11,12));
16 c1.setRadius(13.3);
17 System.out.println(c1);//Circle'stoString()
18 System.out.println("centeris:"+c1.getCenter());//Point'stoString()
19 System.out.println("radiusis:"+c1.getRadius());
20
21 c1.setCenterX(21);
22 c1.setCenterY(22);
23 System.out.println(c1);//Circle'stoString()
24 System.out.println("center'sxis:"+c1.getCenterX());
25 System.out.println("center'syis:"+c1.getCenterY());
26 c1.setCenterXY(31,32);
27 System.out.println(c1);//Circle'stoString()
28 System.out.println("center'sxis:"+c1.getCenterXY()[0]);
29 System.out.println("center'syis:"+c1.getCenterXY()[1]);
30
31 //TestgetArea()andgetCircumference()
32 System.out.printf("areais:%.2f%n",c1.getArea());
33 System.out.printf("circumferenceis:%.2f%n",c1.getCircumference());
34
35 //Testdistance()
36 System.out.printf("distanceis:%.2f%n",c1.distance(c2));
37 System.out.printf("distanceis:%.2f%n",c2.distance(c1));
38 }
39 }

1.4Exercises
LINK TO EXERCISES

2.Inheritance
In OOP, we often organize classes in hierarchy to avoid duplication and reduce redundancy. The classes in the lower hierarchy
inherit all the variables static attributes and methods dynamic behaviors from the higher hierarchies. A class in the lower
hierarchy is called a subclass or derived, child, extended class. A class in the upper hierarchy is called a superclass or base,
parent class. By pulling out all the common variables and methods into the superclasses, and leave the specialized variables
and methods in the subclasses, redundancy can be greatly reduced or eliminated as these common variables and methods
do not need to be repeated in all the subclasses. For example,
A subclass inherits all the variables and methods from its superclasses, including its immediate parent as well as all the
ancestors. It is important to note that a subclass is not a "subset" of a superclass. In contrast, subclass is a "superset" of a
superclass. It is because a subclass inherits all the variables and methods of the superclass; in addition, it extends the
superclass by providing more variables and methods.

In Java, you define a subclass using the keyword "extends", e.g.,

classGoalkeeperextendsSoccerPlayer{......}
classMyAppletextendsjava.applet.Applet{.....}
classCylinderextendsCircle{......}

UML Notation: The UML notation for inheritance is a solid line with a hollow
arrowhead leading from the subclass to its superclass. By convention, superclass is
drawn on top of its subclasses as shown.

2.1Inheritance EG. 1: The Circle and Cylinder Classes

In this example, we derive a subclass called Cylinder from the superclass Circle, which we have created in the previous
chapter. It is important to note that we reuse the class Circle. Reusability is one of the most important properties of OOP.
Why reinvent the wheels? The class Cylinder inherits all the member variables radius and color and methods
getRadius(), getArea(), among others from its superclass Circle. It further defines a variable called height, two public
methods getHeight() and getVolume() and its own constructors, as shown:

Circle.java Reproduced
publicclassCircle{
//privateinstancevariables
privatedoubleradius;
privateStringcolor;

//Constructors
publicCircle(){
this.radius=1.0;
this.color="red";
}
publicCircle(doubleradius){
this.radius=radius;
this.color="red";
}
publicCircle(doubleradius,Stringcolor){
this.radius=radius;
this.color=color;
}

//GettersandSetters
publicdoublegetRadius(){
returnthis.radius;
}
publicStringgetColor(){
returnthis.color;
}
publicvoidsetRadius(doubleradius){
this.radius=radius;
 }
publicvoidsetColor(Stringcolor){
this.color=color;
}

//Describleitself
publicStringtoString(){
return"Circle[radius="+radius+",color="+color+"]";
}

//ReturntheareaofthisCircle
publicdoublegetArea(){
returnradius*radius*Math.PI;
}
}

Cylinder.java
1 /*
2 *ACylinderisaCircleplusaheight.
3 */
4 publicclassCylinderextendsCircle{
5 //privateinstancevariable
6 privatedoubleheight;
7
8 //Constructors
9 publicCylinder(){
10 super();//invokesuperclass'constructorCircle()
11 this.height=1.0;
12 }
13 publicCylinder(doubleheight){
14 super();//invokesuperclass'constructorCircle()
15 this.height=height;
16 }
17 publicCylinder(doubleheight,doubleradius){
18 super(radius);//invokesuperclass'constructorCircle(radius)
19 this.height=height;
20 }
21 publicCylinder(doubleheight,doubleradius,Stringcolor){
22 super(radius,color);//invokesuperclass'constructorCircle(radius,color)
23 this.height=height;
24 }
25
26 //GetterandSetter
27 publicdoublegetHeight(){
28 returnthis.height;
29 }
30 publicvoidsetHeight(doubleheight){
31 this.height=height;
32 }
33
34 //ReturnthevolumeofthisCylinder
35 publicdoublegetVolume(){
36 returngetArea()*height;//UseCircle'sgetArea()
37 }
38
39 //Describleitself
40 publicStringtoString(){
41 return"ThisisaCylinder";//toberefinedlater
42 }
43 }

A Test Drive for the Cylinder Class TestCylinder.java

1 /*
2 *AtestdriverfortheCylinderclass.
3 */
4 publicclassTestCylinder{
 5 publicstaticvoidmain(String[]args){
6 Cylindercy1=newCylinder();
7 System.out.println("Radiusis"+cy1.getRadius()
8 +"Heightis"+cy1.getHeight()
9 +"Coloris"+cy1.getColor()
10 +"Baseareais"+cy1.getArea()
11 +"Volumeis"+cy1.getVolume());
12
13 Cylindercy2=newCylinder(5.0,2.0);
14 System.out.println("Radiusis"+cy2.getRadius()
15 +"Heightis"+cy2.getHeight()
16 +"Coloris"+cy2.getColor()
17 +"Baseareais"+cy2.getArea()
18 +"Volumeis"+cy2.getVolume());
19 }
20 }

Keep the "Cylinder.java" and "TestCylinder.java" in the same directory as "Circle.class" because we are reusing
the class Circle. Compile and run the program. The expected output is as follows:

Radiusis1.0Heightis1.0ColorisredBaseareais3.141592653589793Volumeis3.141592653589793
Radiusis5.0Heightis2.0ColorisredBaseareais78.53981633974483Volumeis157.07963267948966

2.2Method Overriding & Variable Hiding

A subclass inherits all the member variables and methods from its superclasses the immediate parent and all its ancestors.
It can use the inherited methods and variables as they are. It may also override an inherited method by providing its own
version, or hide an inherited variable by defining a variable of the same name.

For example, the inherited method getArea() in a Cylinder object computes the base area of the cylinder. Suppose that
we decide to override the getArea() to compute the surface area of the cylinder in the subclass Cylinder. Below are the
changes:

1 publicclassCylinderextendsCircle{
2 ......
3 //OverridethegetArea()methodinheritedfromsuperclassCircle
4 @Override
5 publicdoublegetArea(){
6 return2*Math.PI*getRadius()*height+2*super.getArea();
7 }
8 //NeedtochangethegetVolume()aswell
9 publicdoublegetVolume(){
10 returnsuper.getArea()*height;//usesuperclass'getArea()
11 }
12 //OverridetheinheritedtoString()
13 @Override
14 publicStringtoString(){
15 return"Cylinder["+super.toString()+",height="+height+"]";
16 }
17 }

If getArea() is called from a Circle object, it computes the area of the circle. If getArea() is called from a Cylinder
object, it computes the surface area of the cylinder using the overridden implementation. Note that you have to use public
accessor method getRadius() to retrieve the radius of the Circle, because radius is declared private and therefore
not accessible to other classes, including the subclass Cylinder.

But if you override the getArea() in the Cylinder, the getVolume() =getArea()*height no longer works. It is because
the overridden getArea() will be used in Cylinder, which does not compute the base area. You can fix this problem by
using super.getArea() to use the superclass' version of getArea(). Note that super.getArea() can only be issued from
the subclass definition, but no from an instance created, e.g. c1.super.getArea(), as it break the information hiding and
encapsulation principle.

2.3Annotation @Override JDK 1.5

The "@Override" is known as annotation introduced in JDK 1.5, which asks compiler to check whether there is such a
method in the superclass to be overridden. This helps greatly if you misspell the name of the method to be overridden. For
example, suppose that you wish to override method toString() in a subclass. If @Override is not used and toString() is
misspelled as TOString(), it will be treated as a new method in the subclass, instead of overriding the superclass. If
@Override is used, the compiler will signal an error.

@Override annotation is optional, but certainly nice to have.

Annotations are not programming constructs. They have no effect on the program output. It is only used by the compiler,
discarded after compilation, and not used by the runtime.

2.4Keyword "super"
Recall that inside a class definition, you can use the keyword this to refer to this instance. Similarly, the keyword super
refers to the superclass, which could be the immediate parent or its ancestor.

The keyword super allows the subclass to access superclass' methods and variables within the subclass' definition. For
example, super() and super(argumentList) can be used invoke the superclass constructor. If the subclass overrides a
method inherited from its superclass, says getArea(), you can use super.getArea() to invoke the superclass' version
within the subclass definition. Similarly, if your subclass hides one of the superclass' variable, you can use
super.variableName to refer to the hidden variable within the subclass definition.

2.5More on Constructors
Recall that the subclass inherits all the variables and methods from its superclasses. Nonetheless, the subclass does not
inherit the constructors of its superclasses. Each class in Java defines its own constructors.

In the body of a constructor, you can use super(args) to invoke a constructor of its immediate superclass. Note that
super(args), if it is used, must be the first statement in the subclass' constructor. If it is not used in the constructor, Java
compiler automatically insert a super() statement to invoke the noarg constructor of its immediate superclass. This
follows the fact that the parent must be born before the child can be born. You need to properly construct the superclasses
before you can construct the subclass.

2.6Default noarg Constructor

If no constructor is defined in a class, Java compiler automatically create a noargument (noarg) constructor, that simply
issues a super() call, as follows:

//Ifnoconstructorisdefinedinaclass,compilerinsertsthisnoargconstructor
publicClassName(){
super();//callthesuperclass'noargconstructor
}

Take note that:

The default noarg constructor will not be automatically generated, if one or more constructor was defined. In other
words, you need to define noarg constructor explicitly if other constructors were defined.
If the immediate superclass does not have the default constructor it defines some constructors but does not define a
noarg constructor, you will get a compilation error in doing a super() call. Note that Java compiler inserts a super()
as the first statement in a constructor if there is no super(args).

2.7Single Inheritance
Java does not support multiple inheritance C++ does. Multiple inheritance permits a subclass to have more than one direct
superclasses. This has a serious drawback if the superclasses have conflicting implementation for the same method. In Java,
each subclass can have one and only one direct superclass, i.e., single inheritance. On the other hand, a superclass can have
many subclasses.

2.8Common Root Class java.lang.Object

Java adopts a socalled commonroot approach. All Java classes are derived from a common root class called
java.lang.Object. This Object class defines and implements the common behaviors that are required of all the Java
objects running under the JRE. These common behaviors enable the implementation of features such as multithreading and
garbage collector.

2.9Inheritance EG. 2: The Point2D and Point3D Classes

The Superclass Point2D.java

/*
*ThePoint2Dclassmodelsa2Dpointat(x,y).
*/
publicclassPoint2D{
//Privateinstancevariables
privateintx,y;

//Constructors
publicPoint2D(){//defaultconstructor
this.x=0;
this.y=0;
}
publicPoint2D(intx,inty){
this.x=x;
this.y=y;
}

//GettersandSetters
publicintgetX(){
returnthis.x;
}
publicvoidsetX(intx){
this.x=x;
}
publicintgetY(){
returnthis.y;
}
publicvoidsetY(inty){
this.y=y;
}

//Return"(x,y)"
publicStringtoString(){
 return"("+this.x+","+this.y+")";
}
}

The Subclass Point3D.java

1 /*
2 *ThePoint3Dclassmodelsa3Dpointat(x,y,z),
3 *whichisasubclassofPoint2D.
4 */
5 publicclassPoint3DextendsPoint2D{
6 //Privateinstancevariables
7 privateintz;
8
9 //Constructors
10 publicPoint3D(){//defaultconstructor
11 super();//x=y=0
12 this.z=0;
13 }
14 publicPoint3D(intx,inty,intz){
15 super(x,y);
16 this.z=z;
17 }
18
19 //GettersandSetters
20 publicintgetZ(){
21 returnthis.z;
22 }
23 publicvoidsetZ(intz){
24 this.z=z;
25 }
26
27 //Return"(x,y,z)"
28 @Override
29 publicStringtoString(){
30 return"("+super.getX()+","+super.getY()+","+this.z+")";
31 }
32 }

A Test Driver for Point2D and Point3D Classes TestPoint2DPoint3D.java

1 /*
2 *AtestdriverforthePoint2DandPoint3Dclasses
3 */
4 publicclassTestPoint2DPoint3D{
5 publicstaticvoidmain(String[]args){
6 /*TestPoint2D*/
7 //TestconstructorsandtoString()
8 Point2Dp2a=newPoint2D(1,2);
9 System.out.println(p2a);//toString()
10 Point2Dp2b=newPoint2D();//defaultconstructor
11 System.out.println(p2b);
12 //TestSettersandGetters
13 p2a.setX(3);//Testsetters
14 p2a.setY(4);
15 System.out.println(p2a);//toString()
16 System.out.println("xis:"+p2a.getX());
17 System.out.println("xis:"+p2a.getY());
18
19 /*TestPoint3D*/
20 //TestconstructorsandtoString()
21 Point3Dp3a=newPoint3D(11,12,13);
22 System.out.println(p3a);//toString()
23 Point2Dp3b=newPoint3D();//defaultconstructor
24 System.out.println(p3b);
25 //TestSettersandGetters
26 p3a.setX(21);//insuperclass
 27 p3a.setY(22);//insuperclass
28 p3a.setZ(23);//inthisclass
29 System.out.println(p3a);//toString()
30 System.out.println("xis:"+p3a.getX());//insuperclass
31 System.out.println("yis:"+p3a.getY());//insuperclass
32 System.out.println("zis:"+p3a.getZ());//inthisclass
33 }
34 }

2.10Inheritance EG. 3: Superclass Person and its Subclasses

Suppose that we are required to model students and teachers in our application. We can define a superclass called Person
to store common properties such as name and address, and subclasses Student and Teacher for their specific properties.
For students, we need to maintain the courses taken and their respective grades; add a course with grade, print all courses
taken and the average grade. Assume that a student takes no more than 30 courses for the entire program. For teachers, we
need to maintain the courses taught currently, and able to add or remove a course taught. Assume that a teacher teaches
not more than 5 courses concurrently.

We design the classes as follows.

The Superclass Person.java

/*
*SuperclassPersonhasnameandaddress.
*/
publicclassPerson{
//privateinstancevariables
privateStringname,address;

//Constructor
publicPerson(Stringname,Stringaddress){
 this.name=name;
this.address=address;
}

//GettersandSetters
publicStringgetName(){
returnname;
}
publicStringgetAddress(){
returnaddress;
}
publicvoidsetAddress(Stringaddress){
this.address=address;
}

//Describleitself
publicStringtoString(){
returnname+"("+address+")";
}
}

The Subclass Student.java

/*
*TheStudentclass,subclassofPerson.
*/
publicclassStudentextendsPerson{
//privateinstancevariables
privateintnumCourses;//numberofcoursestakensofar
privateString[]courses;//coursecodes
privateint[]grades;//gradeforthecorrespondingcoursecodes
privatestaticfinalintMAX_COURSES=30;//maximumnumberofcourses

//Constructor
publicStudent(Stringname,Stringaddress){
super(name,address);
numCourses=0;
courses=newString[MAX_COURSES];
grades=newint[MAX_COURSES];
}

//Describeitself
@Override
publicStringtoString(){
return"Student:"+super.toString();
}

//AddacourseanditsgradeNovalidationinthismethod
publicvoidaddCourseGrade(Stringcourse,intgrade){
courses[numCourses]=course;
grades[numCourses]=grade;
++numCourses;
}

//Printallcoursestakenandtheirgrade
publicvoidprintGrades(){
System.out.print(this);
for(inti=0;i<numCourses;++i){
System.out.print(""+courses[i]+":"+grades[i]);
}
System.out.println();
}

//Computetheaveragegrade
publicdoublegetAverageGrade(){
intsum=0;
for(inti=0;i<numCourses;i++){
sum+=grades[i];
}
return(double)sum/numCourses;
}
 }

The Subclass Teacher.java

/*
*TheTeacherclass,subclassofPerson.
*/
publicclassTeacherextendsPerson{
//privateinstancevariables
privateintnumCourses;//numberofcoursestaughtcurrently
privateString[]courses;//coursecodes
privatestaticfinalintMAX_COURSES=5;//maximumcourses

//Constructor
publicTeacher(Stringname,Stringaddress){
super(name,address);
numCourses=0;
courses=newString[MAX_COURSES];
}

//Describeitself
@Override
publicStringtoString(){
return"Teacher:"+super.toString();
}

//Returnfalseifthecoursealreadyexisted
publicbooleanaddCourse(Stringcourse){
//Checkifthecoursealreadyinthecourselist
for(inti=0;i<numCourses;i++){
if(courses[i].equals(course))returnfalse;
}
courses[numCourses]=course;
numCourses++;
returntrue;
}

//Returnfalseifthecoursecannotbefoundinthecourselist
publicbooleanremoveCourse(Stringcourse){
booleanfound=false;
//Lookforthecourseindex
intcourseIndex=1;//needtoinitialize
for(inti=0;i<numCourses;i++){
if(courses[i].equals(course)){
courseIndex=i;
found=true;
break;
}
}
if(found){
//Removethecourseandrearrangeforcoursesarray
for(inti=courseIndex;i<numCourses1;i++){
courses[i]=courses[i+1];
}
numCourses;
returntrue;
}else{
returnfalse;
}
}
}

A Test Driver TestPerson.java

/*
*AtestdriverforPersonanditssubclasses.
*/
publicclassTestPerson{
publicstaticvoidmain(String[]args){
/*TestStudentclass*/
 Students1=newStudent("TanAhTeck","1HappyAve");
s1.addCourseGrade("IM101",97);
s1.addCourseGrade("IM102",68);
s1.printGrades();
System.out.println("Averageis"+s1.getAverageGrade());

/*TestTeacherclass*/
Teachert1=newTeacher("PaulTan","8sunsetway");
System.out.println(t1);
String[]courses={"IM101","IM102","IM101"};
for(Stringcourse:courses){
if(t1.addCourse(course)){
System.out.println(course+"added.");
}else{
System.out.println(course+"cannotbeadded.");
}
}
for(Stringcourse:courses){
if(t1.removeCourse(course)){
System.out.println(course+"removed.");
}else{
System.out.println(course+"cannotberemoved.");
}
}
}
}

TanAhTeck(1HappyAve)
TanAhTeck
8SunrisePlace
Student:MohdAli(8KgJava)
MohdAli
9KgSatu
Student:MohdAli(9KgSatu)IM101:97IM102:68
Averageis:82.5
Teacher:PaulTan(8sunsetway)
IM101added.
IM102added.
IM101cannotbeadded.
IM101removed.
IM102removed.
IM101cannotberemoved.

2.11Exercises
LINK TO EXERCISES

3.Composition vs. Inheritance

3.1"A line is composed of 2 points" vs. "A line is a point extended by another
point"
Recall that there are two ways of reusing existing classes: composition and inheritance. We have seen that a Line class can
be implemented using composition of Point class "A line is composed of two points", in the previous section.

A Line can also be implemented, using inheritance from the Point class "A line is a point extended by another point".
Let's call this subclass LineSub to differentiate from the Line class using composition.
The Superclass Point.java
As above.

The Subclass LineSub.java

1 /*
2 *TheLineSubclass,subclassofPoint.
3 *Itinheritsthebeginpointfromthesuperclass,andaddsanendpoint.
4 */
5 publicclassLineSubextendsPoint{//Inheritedthebeginpoint
6 //Privateinstancevariables
7 Pointend;//DeclareendasinstanceofPoint
8
9 //Constructors
10 publicLineSub(intx1,inty1,intx2,inty2){
11 super(x1,y1);
12 this.end=newPoint(x2,y2);//ConstructPointinstances
13 }
14 publicLineSub(Pointbegin,Pointend){
15 super(begin.getX(),begin.getY());//Needtoconstructsuper
16 this.end=end;
17 }
18
19 //GettersandSetters
20 publicPointgetBegin(){
21 returnthis;//upcasttoPoint(polymorphism)
22 }
 23 publicPointgetEnd(){
24 returnend;
25 }
26 publicvoidsetBegin(Pointbegin){
27 super.setX(begin.getX());
28 super.setY(begin.getY());
29 }
30 publicvoidsetEnd(Pointend){
31 this.end=end;
32 }
33
34 //OtherGetandSetmethods
35 publicintgetBeginX(){
36 returnsuper.getX();//inherited,superisoptional
37 }
38 publicvoidsetBeginX(intx){
39 super.setX(x);//inherited,superisoptional
40 }
41 publicintgetBeginY(){
42 returnsuper.getY();
43 }
44 publicvoidsetBeginY(inty){
45 super.setY(y);
46 }
47 publicint[]getBeginXY(){
48 returnsuper.getXY();
49 }
50 publicvoidsetBeginXY(intx,inty){
51 super.setXY(x,y);
52 }
53 publicintgetEndX(){
54 returnend.getX();
55 }
56 publicvoidsetEndX(intx){
57 end.setX(x);
58 }
59 publicintgetEndY(){
60 returnend.getY();
61 }
62 publicvoidsetEndY(inty){
63 end.setY(y);
64 }
65 publicint[]getEndXY(){
66 returnend.getXY();
67 }
68 publicvoidsetEndXY(intx,inty){
69 end.setXY(x,y);
70 }
71
72 //Describeitself
73 publicStringtoString(){
74 return"LineSub[begin="+super.toString()+",end="+end+"]";
75 }
76
77 //ReturnthelengthofthisLine
78 publicdoublegetLength(){
79 returnsuper.distance(end);
80 }
81 }

A Test Driver TestLineSub.java

1 /*
2 *TestDriverfortheLineSubclass
3 */
4 publicclassTestLineSub{
5 publicstaticvoidmain(String[]args){
 6 //TestconstructorsandtoString()
7 LineSubl1=newLineSub(1,2,3,4);
8 System.out.println(l1);//toString()
9 LineSubl2=newLineSub(newPoint(5,6),newPoint(7,8));
10 System.out.println(l2);
11
12 //TestSettersandGetters
13 l1.setBegin(newPoint(11,12));
14 l1.setEnd(newPoint(13,14));
15 System.out.println(l1);//toString()
16 System.out.println("beginis:"+l1.getBegin());
17 System.out.println("endis:"+l1.getEnd());
18
19 l1.setBeginX(21);
20 l1.setBeginY(22);
21 l1.setEndX(23);
22 l1.setEndY(24);
23 System.out.println(l1);
24 System.out.println(l1);//toString()
25 System.out.println("begin'sxis:"+l1.getBeginX());
26 System.out.println("begin'syis:"+l1.getBeginY());
27 System.out.println("end'sxis:"+l1.getEndX());
28 System.out.println("end'syis:"+l1.getEndY());
29
30 l1.setBeginXY(31,32);
31 l1.setEndXY(33,34);
32 System.out.println(l1);//toString()
33 System.out.println("begin'sxis:"+l1.getBeginXY()[0]);
34 System.out.println("begin'syis:"+l1.getBeginXY()[1]);
35 System.out.println("end'sxis:"+l1.getEndXY()[0]);
36 System.out.println("end'syis:"+l1.getEndXY()[1]);
37
38 //TestgetLength()
39 System.out.printf("lengthis:%.2f%n",l1.getLength());
40 }
41 }

Notes: This is the same test driver used in the earlier example on composition, except change in classname.

Study both versions of the Line class Line and LineSub. I suppose that it is easier to say that "A line is composed of two
points" than that "A line is a point extended by another point".

Rule of Thumb: Use composition if possible, before considering inheritance. Use inheritance only if there is a clear
hierarchical relationship between classes.

3.2Exercises
LINK TO EXERCISES ON COMPOSITION VS INHERITANCE

4.Polymorphism
The word "polymorphism" means "many forms". It comes from Greek word "poly" means many and "morphos" means
form. For examples, in chemistry, carbon exhibits polymorphism because it can be found in more than one form: graphite
and diamond. But, each of the form has it own distinct properties and price.

4.1Substitutability
A subclass possesses all the attributes and operations of its superclass because a subclass inherited all attributes and
operations from its superclass. This means that a subclass object can do whatever its superclass can do. As a result, we can
substitute a subclass instance when a superclass instance is expected, and everything shall work fine. This is called
substitutability.
In our earlier example of Circle and Cylinder: Cylinder is a subclass of Circle. We can say that Cylinder "isa" Circle
actually, it "ismorethana" Circle. Subclasssuperclass exhibits a so called "isa" relationship.

Circle.java
//ThesuperclassCircle
publicclassCircle{
//privateinstancevariable
privatedoubleradius;
//Constructor
publicCircle(doubleradius){
this.radius=radius;
}
//Getter
publicdoublegetRadius(){
returnthis.radius;
}
//Returntheareaofthiscircle
publicdoublegetArea(){
returnradius*radius*Math.PI;
}
//Describeitself
publicStringtoString(){
return"Circle[radius="+radius+"]";
}
}

Cylinder.java
//ThesubclassCylinder
publicclassCylinderextendsCircle{
//privateinstancevariable
privatedoubleheight;
//Constructor
publicCylinder(doubleheight,doubleradius){
super(radius);
this.height=height;
}
//Getter
publicdoublegetHeight(){
returnthis.height;
}
//Returnthevolumeofthiscylinder
publicdoublegetVolumne(){
returnsuper.getArea()*height;
}
 //Overridetheinheritedmethodtoreturnthesurfacearea
@Override
publicdoublegetArea(){
return2.0*Math.PI*getRadius()*height;
}
//Overridetheinheritedmethodtodescribeitself
@Override
publicStringtoString(){
return"Cylinder[height="+height+","+super.toString()+"]";
}
}

Via substitutability, we can create an instance of Cylinder, and assign it to a Circle its superclass reference, as follows:

//Substituteasubclassinstancetoasuperclassreference
Circlec1=newCylinder(1.1,2.2);

You can invoke all the methods defined in the Circle class for the reference c1, which is actually holding a Cylinder
object, e.g.

//InvokesuperclassCircle'smethods
c1.getRadius();

This is because a subclass instance possesses all the properties of its superclass.

However, you CANNOT invoke methods defined in the Cylinder class for the reference c1, e.g.

//CANNOTinvokemethodinCylinderasitisaCirclereference!
c1.getHeight();//compilationerror
c1.getVolume();//compilationerror

This is because c1 is a reference to the Circle class, which does not know about methods defined in the subclass
Cylinder.

c1 is a reference to the Circle class, but holds an object of its subclass Cylinder. The reference c1, however, retains its
internal identity. In our example, the subclass Cylinder overrides methods getArea() and toString(). c1.getArea() or
c1.toString() invokes the overridden version defined in the subclass Cylinder, instead of the version defined in Circle.
This is because c1 is in fact holding a Cylinder object internally.

c1.toString();//Runtheoverriddenversion!
c1.getArea();//Runtheoverriddenversion!

Summar y
1. A subclass instance can be assigned substituted to a superclass' reference.
2. Once substituted, we can invoke methods defined in the superclass; we cannot invoke methods defined in the
subclass.
3. However, if the subclass overrides inherited methods from the superclass, the subclass overridden versions will be
invoked.

4.2Polymorphism EG. 1 Shape and its Subclasses

Polymorphism is very powerful in OOP to separate the interface and implementation so as to allow the programmer to
program at the interface in the design of a complex system.

Consider the following example. Suppose that our program uses many kinds of shapes, such as triangle, rectangle and so
on. We should design a superclass called Shape, which defines the public interfaces or behaviors of all the shapes. For
example, we would like all the shapes to have a method called getArea(), which returns the area of that particular shape.
The Shape class can be written as follow.
The Superclass Shape.java
/*
*SuperclassShapemaintainthecommonpropertiesofallshapes
*/
publicclassShape{
//Privatemembervariable
privateStringcolor;

//Constructor
publicShape(Stringcolor){
this.color=color;
}

@Override
publicStringtoString(){
return"Shape[color="+color+"]";
}

//AllshapesmusthaveamethodcalledgetArea().
publicdoublegetArea(){
//Wehaveaproblemhere!
//Weneedtoreturnsomevaluetocompiletheprogram.
System.err.println("Shapeunknown!Cannotcomputearea!");
return0;
}
}

Take note that we have a problem writing the getArea() method in the Shape class, because the area cannot be computed
unless the actual shape is known. We shall print an error message for the time being. In the later section, I shall show you
how to resolve this problem.

We can then derive subclasses, such as Triangle and Rectangle, from the superclass Shape.

The Subclass Rectangle.java

/*
*TheRectangleclass,subclassofShape
*/
publicclassRectangleextendsShape{
//Privatemembervariables
privateintlength;
privateintwidth;

//Constructor
publicRectangle(Stringcolor,intlength,intwidth){
super(color);
this.length=length;
this.width=width;
}

 @Override
publicStringtoString(){
return"Rectangle[length="+length+",width="+width+","+super.toString()+"]";
}

//OverridetheinheritedgetArea()toprovidetheproperimplementation
@Override
publicdoublegetArea(){
returnlength*width;
}
}

The Subclass Triangle.java

/*
*TheTriangleclass,subclassofShape
*/
publicclassTriangleextendsShape{
//Privatemembervariables
privateintbase;
privateintheight;

//Constructor
publicTriangle(Stringcolor,intbase,intheight){
super(color);
this.base=base;
this.height=height;
}

@Override
publicStringtoString(){
return"Triangle[base="+base+",height="+height+","+super.toString()+"]";
}

//OverridetheinheritedgetArea()toprovidetheproperimplementation
@Override
publicdoublegetArea(){
return0.5*base*height;
}
}

The subclasses override the getArea()method inherited from the superclass, and provide the proper implementations for
getArea().

A Test Driver TestShape.java

In our application, we could create references of Shape, and assigned them instances of subclasses, as follows:

/*
*AtestdriverforShapeanditssubclasses
*/
publicclassTestShape{
publicstaticvoidmain(String[]args){
Shapes1=newRectangle("red",4,5);//Upcast
System.out.println(s1);//RunRectangle'stoString()
System.out.println("Areais"+s1.getArea());//RunRectangle'sgetArea()

Shapes2=newTriangle("blue",4,5);//Upcast
System.out.println(s2);//RunTriangle'stoString()
System.out.println("Areais"+s2.getArea());//RunTriangle'sgetArea()
}
}

The expected outputs are:

Rectangle[length=4,width=5,Shape[color=red]]
Areais20.0
Triangle[base=4,height=5,Shape[color=blue]]
Areais10.0
The beauty of this code is that all the references are from the superclass i.e., programming at the interface level. You could
instantiate different subclass instance, and the code still works. You could extend your program easily by adding in more
subclasses, such as Circle, Square, etc, with ease.

Nonetheless, the above definition of Shape class poses a problem, if someone instantiate a Shape object and invoke the
getArea() from the Shape object, the program breaks.

publicclassTestShape{
publicstaticvoidmain(String[]args){
//ConstructingaShapeinstanceposesproblem!
Shapes3=newShape("green");
System.out.println(s3);
System.out.println("Areais"+s3.getArea());//Invalidoutput
}
}

This is because the Shape class is meant to provide a common interface to all its subclasses, which are supposed to provide
the actual implementation. We do not want anyone to instantiate a Shape instance. This problem can be resolved by using
the socalled abstract class.

4.3Polymorphism EG. 2 Monster and its Subclasses

Polymorphism is a powerful mechanism in OOP to separate the interface and implementation so as to allow the programmer
to program at the interface in the design of a complex system. For example, in our game app, we have many types of
monsters that can attack. We shall design a superclass called Monster and define the method attack() in the superclass.
The subclasses shall then provides their actual implementation. In the main program, we declare instances of superclass,
substituted with actual subclass; and invoke method defined in the superclass.

Superclass Monster.java
/*
*ThesuperclassMonsterdefinestheexpectedcommonbehaviorsforitssubclasses.
*/
publicclassMonster{
//privateinstancevariable
privateStringname;

//Constructor
publicMonster(Stringname){
this.name=name;
}

//Definecommonbehaviorforallitssubclasses
publicStringattack(){
return"!^_&^$@+%$*Idon'tknowhowtoattack!";
//Wehaveaproblemhere!
//WeneedtoreturnaString;else,compilationerror!
}
}

Subclass FireMonster.java
 publicclassFireMonsterextendsMonster{
//Constructor
publicFireMonster(Stringname){
super(name);
}
//Subclassprovidesactualimplementation
@OverridepublicStringattack(){
return"Attackwithfire!";
}
}

Subclass WaterMonster.java
publicclassWaterMonsterextendsMonster{
//Constructor
publicWaterMonster(Stringname){
super(name);
}
//Subclassprovidesactualimplementation
@OverridepublicStringattack(){
return"Attackwithwater!";
}
}

Subclass StoneMonster.java
publicclassStoneMonsterextendsMonster{
//Constructor
publicStoneMonster(Stringname){
super(name);
}
//Subclassprovidesactualimplementation
@OverridepublicStringattack(){
return"Attackwithstones!";
}
}

A Test Driver TestMonster.java

publicclassTestMonster{
publicstaticvoidmain(String[]args){
//Programatthe"interface"definedinthesuperclass.
//Declareinstancesofthesuperclass,substitutedbysubclasses.
Monsterm1=newFireMonster("r2u2");//upcast
Monsterm2=newWaterMonster("u2r2");//upcast
Monsterm3=newStoneMonster("r2r2");//upcast

//Invoketheactualimplementation
System.out.println(m1.attack());//RunFireMonster'sattack()
System.out.println(m2.attack());//RunWaterMonster'sattack()
System.out.println(m3.attack());//RunStoneMonster'sattack()

//m1dies,generateanewinstanceandreassigntom1.
m1=newStoneMonster("a2b2");//upcast
System.out.println(m1.attack());//RunStoneMonster'sattack()

//Wehaveaproblemhere!!!
Monsterm4=newMonster("u2u2");
System.out.println(m4.attack());//garbage!!!
}
}

4.4Upcasting & Downcasting

Upcasting a Subclass Instance to a Superclass Reference

Substituting a subclass instance for its superclass is called "upcasting". This is because, in a UML class diagram, subclass is
often drawn below its superclass. Upcasting is always safe because a subclass instance possesses all the properties of its
superclass and can do whatever its superclass can do. The compiler checks for valid upcasting and issues error
"incompatible types" otherwise. For example,

Circlec1=newCylinder(1.1,2.2);//CompilercheckstoensurethatRvalueisasubclassofLvalue.
Circlec2=newString();//Compilationerror:incompatibletypes

Downcasting a Substituted Reference to Its Original Class

You can revert a substituted instance back to a subclass reference. This is called "downcasting". For example,

Circlec1=newCylinder(1.1,2.2);//upcastissafe
Cylindercy1=(Cylinder)c1;//downcastneedsthecastingoperator

Downcasting requires explicit type casting operator in the form of prefix operator (newtype). Downcasting is not always
safe, and throws a runtime ClassCastException if the instance to be downcasted does not belong to the correct subclass.
A subclass object can be substituted for its superclass, but the reverse is not true.

Another Example on Upcasting and Downcasting

publicclassA{
publicA(){//Constructor
System.out.println("ConstructedA");
}
publicStringtoString(){
return"ThisisA";
}
}

publicclassBextendsA{
publicB(){//Constructor
super();
System.out.println("ConstructedB");
}
@Override
publicStringtoString(){
return"ThisisB";
}
}

publicclassCextendsB{
publicC(){//Constructor
super();
System.out.println("ConstructedC");
}
@Override
publicStringtoString(){
return"ThisisC";
}
 }

The following program tests the upcasting an downcasting refer to the above instance diagram:

publicclassTestCasting{
publicstaticvoidmain(String[]args){
Aa1=newC();//upcast
System.out.println(a1);//runC'stoString()
Bb1=(B)a1;//downcastokay
Cc1=(C)b1;//downcastokay

Aa2=newB();//upcast
System.out.println(a2);//runB'stoString()
Bb2=(B)a2;//downcastokay
Cc2=(C)a2;//compilationokay,butruntimeerrorClassCastException
}
}

Casting Operator
Compiler may not be able to detect error in explicit cast, which will be detected only at runtime. For example,

Circlec1=newCircle(5);
Pointp1=newPoint();

c1=p1;//compilationerror:incompatibletypes(PointisnotasubclassofCircle)
c1=(Circle)p1;//runtimeerror:java.lang.ClassCastException:PointcannotbecastedtoCircle

4.5The "instanceof" Operator

Java provides a binary operator called instanceofwhich returns true if an object is an instance of a particular class. The
syntax is as follows:

anObjectinstanceofaClass

Circlec1=newCircle();
System.out.println(c1instanceofCircle);//true

if(c1instanceofCircle){......}

An instance of subclass is also an instance of its superclass. For example,

Circlec1=newCircle(1.1);
Cylindercy1=newCylinder(2.2,3.3);
System.out.println(c1instanceofCircle);//true
System.out.println(c1instanceofCylinder);//false
System.out.println(cy1instanceofCylinder);//true
System.out.println(cy1instanceofCircle);//true

Circlec2=newCylinder(4.4,5.5);
System.out.println(c2instanceofCircle);//true
System.out.println(c2instanceofCylinder);//true

4.6Summary of Polymorphism
1. A subclass instance processes all the attributes operations of its superclass. When a superclass instance is expected, it
can be substituted by a subclass instance. In other words, a reference to a class may hold an instance of that class or
an instance of one of its subclasses it is called substitutability.
2. If a subclass instance is assign to a superclass reference, you can invoke the methods defined in the superclass only.
You cannot invoke methods defined in the subclass.
3. However, the substituted instance retains its own identity in terms of overridden methods and hiding variables. If the
subclass overrides methods in the superclass, the subclass's version will be executed, instead of the superclass's
version.

4.7Exercises
LINK TO EXERCISES

5.Abstract Classes & Interfaces

5.1The abstract Method and abstract class

In the above examples of Shape and Monster, we encountered a problem when we create instances of Shape and Monster
and run the getArea() or attack(). This can be resolved via abstract method and abstract class.

An abstract method is a method with only signature i.e., the method name, the list of arguments and the return type
without implementation i.e., the methods body. You use the keyword abstract to declare an abstract method.

For example, in the Shape class, we can declare abstract methods getArea(), draw(), etc, as follows:

abstractpublicclassShape{
......
......
abstractpublicdoublegetArea();
abstractpublicdoublegetPerimeter();
abstractpublicvoiddraw();
}

Implementation of these methods is NOT possible in the Shape class, as the actual shape is not yet known. How to
compute the area if the shape is not known? Implementation of these abstract methods will be provided later once the
actual shape is known. These abstract methods cannot be invoked because they have no implementation.

A class containing one or more abstract methods is called an abstract class. An abstract class must be declared with a
classmodifier abstract. An abstract class CANNOT be instantiated, as its definition is not complete.

UML Notation: abstract class and method are shown in italic.

5.2Abstract Class EG. 1: Shape and its Subclasses

Let us rewrite our Shape class as an abstract class, containing an abstract method getArea() as follows:

The abstract Superclass Shape.java

/*
*ThisabstractsuperclassShapecontainsanabstractmethod
*getArea(),tobeimplementedbyitssubclasses.
*/
abstractpublicclassShape{
//Privatemembervariable
privateStringcolor;

 //Constructor
publicShape(Stringcolor){
this.color=color;
}

@Override
publicStringtoString(){
return"Shapeofcolor=\""+color+"\"";
}

//AllShapesubclassesmustimplementamethodcalledgetArea()
abstractpublicdoublegetArea();
}

An abstract class is incomplete in its definition, since the implementation of its abstract methods is missing. Therefore,
an abstract class cannot be instantiated. In other words, you cannot create instances from an abstract class otherwise,
you will have an incomplete instance with missing method's body.

To use an abstract class, you have to derive a subclass from the abstract class. In the derived subclass, you have to
override the abstract methods and provide implementation to all the abstract methods. The subclass derived is now
complete, and can be instantiated. If a subclass does not provide implementation to all the abstract methods of the
superclass, the subclass remains abstract.

This property of the abstract class solves our earlier problem. In other words, you can create instances of the subclasses
such as Triangle and Rectangle, and upcast them to Shape so as to program and operate at the interface level, but you
cannot create instance of Shape, which avoid the pitfall that we have faced. For example,

publicclassTestShape{
publicstaticvoidmain(String[]args){
Shapes1=newRectangle("red",4,5);
System.out.println(s1);
System.out.println("Areais"+s1.getArea());

Shapes2=newTriangle("blue",4,5);
System.out.println(s2);
System.out.println("Areais"+s2.getArea());

//Cannotcreateinstanceofanabstractclass
Shapes3=newShape("green");//CompilationError!!
}
}

In summary, an abstract class provides a template for further development. The purpose of an abstract class is to provide a
common interface or protocol, or contract, or understanding, or naming convention to all its subclasses. For example, in
the abstract class Shape, you can define abstract methods such as getArea() and draw(). No implementation is possible
because the actual shape is not known. However, by specifying the signature of the abstract methods, all the subclasses
are forced to use these methods' signature. The subclasses could provide the proper implementations.

Coupled with polymorphism, you can upcast subclass instances to Shape, and program at the Shape level, i,e., program at
the interface. The separation of interface and implementation enables better software design, and ease in expansion. For
example, Shape defines a method called getArea(), which all the subclasses must provide the correct implementation. You
can ask for a getArea() from any subclasses of Shape, the correct area will be computed. Furthermore, you application can
be extended easily to accommodate new shapes such as Circle or Square by deriving more subclasses.

Rule of Thumb: Program at the interface, not at the implementation. That is, make references at the superclass;
substitute with subclass instances; and invoke methods defined in the superclass only.

Notes:
An abstract method cannot be declared final, as final method cannot be overridden. An abstract method, on the
other hand, must be overridden in a descendant before it can be used.
An abstract method cannot be private which generates a compilation error. This is because private method are
not visible to the subclass and thus cannot be overridden.

5.3Abstract Class EG. 2: Monster

We shall define the superclass Monster as an abstract class, containing an abstract method attack(). The abstract
class cannot be instantiated i.e., creating instances.

/*
*TheabstractsuperclassMonsterdefinestheexpectedcommonbehaviors,
*viaabstractmethods.
*/
abstractpublicclassMonster{
privateStringname;//privateinstancevariable

publicMonster(Stringname){//constructor
this.name=name;
}

//Definecommonbehaviorforallitssubclasses
abstractpublicStringattack();
}

5.4The Java's interface

A Java interface is a 100% abstract superclass which define a set of methods its subclasses must support. An interface
contains only public abstract methods methods with signature and no implementation and possibly constants public
static final variables. You have to use the keyword "interface" to define an interface instead of keyword "class"
for normal classes. The keyword public and abstract are not needed for its abstract methods as they are mandatory.

Similar to an abstract superclass, an interface cannot be instantiated. You have to create a "subclass" that implements
an interface, and provide the actual implementation of all the abstract methods.

Unlike a normal class, where you use the keyword "extends" to derive a subclass. For interface, we use the keyword
"implements" to derive a subclass.

An interface is a contract for what the classes can do. It, however, does not specify how the classes should do it.

An interface provides a form, a protocol, a standard, a contract, a specification, a set of rules, an interface, for all objects that
implement it. It is a specification and rules that any object implementing it agrees to follow.

In Java, abstract class and interface are used to separate the public interface of a class from its implementation so as to
allow the programmer to program at the interface instead of the various implementation.

Interface Naming Convention: Use an adjective typically ends with "able" consisting of one or more words. Each
word shall be initial capitalized camelcase. For example, Serializable, Extenalizable, Movable, Clonable, Runnable,
etc.

5.5Interface EG. 1: Shape Interface and its Implementations

We can rewrite the abstract superclass Shape into an interface, containing only abstract methods, as follows:

UML Notations: Abstract classes, Interfaces and abstract methods are shown in italics. Implementation of interface is
marked by a dasharrow leading from the subclasses to the interface.

/*
*TheinterfaceShapespecifiesthebehaviors
*ofthisimplementationssubclasses.
*/
publicinterfaceShape{//Usekeyword"interface"insteadof"class"
//Listofpublicabstractmethodstobeimplementedbyitssubclasses
doublegetArea();
}

//ThesubclassRectangleneedstoimplementalltheabstractmethodsinShape
publicclassRectangleimplementsShape{//usingkeyword"implements"insteadof"extends"
//Privatemembervariables
privateintlength;
privateintwidth;

//Constructor
publicRectangle(intlength,intwidth){
this.length=length;
this.width=width;
}

@Override
publicStringtoString(){
return"Rectangle[length="+length+",width="+width+"]";
}

//Needtoimplementalltheabstractmethodsdefinedintheinterface
@Override
publicdoublegetArea(){
returnlength*width;
}
}

//ThesubclassTriangleneedtoimplementalltheabstractmethodsinShape
publicclassTriangleimplementsShape{
//Privatemembervariables
privateintbase;
privateintheight;

//Constructor
publicTriangle(intbase,intheight){
this.base=base;
this.height=height;
}

@Override
publicStringtoString(){
return"Triangle[base="+base+",height="+height+"]";
}

//Needtoimplementalltheabstractmethodsdefinedintheinterface
@Override
publicdoublegetArea(){
return0.5*base*height;
}
}

A test driver is as follows:

publicclassTestShape{
publicstaticvoidmain(String[]args){
Shapes1=newRectangle(1,2);//upcast
System.out.println(s1);
System.out.println("Areais"+s1.getArea());

Shapes2=newTriangle(3,4);//upcast
System.out.println(s2);
System.out.println("Areais"+s2.getArea());
 //Cannotcreateinstanceofaninterface
//Shapes3=newShape("green");//CompilationError!!
}
}

5.6Interface EG. 2: Movable Interface and its Implementations

Suppose that our application involves many objects that can move. We could define an interface called movable, containing
the signatures of the various movement methods.

Interface Moveable.java
/*
*TheMovableinterfacedefinesalistofpublicabstractmethods
*tobeimplementedbyitssubclasses
*/
publicinterfaceMovable{//usekeyword"interface"(insteadof"class")todefineaninterface
//Aninterfacedefinesalistofabstractmethodstobeimplementedbythesubclasses
publicvoidmoveUp();
publicvoidmoveDown();
publicvoidmoveLeft();
publicvoidmoveRight();
}

Similar to an abstract class, an interface cannot be instantiated; because it is incomplete the abstract methods' body is
missing. To use an interface, again, you must derive subclasses and provide implementation to all the abstract methods
declared in the interface. The subclasses are now complete and can be instantiated.

MovablePoint.java
To derive subclasses from an interface, a new keyboard "implements" is to be used instead of "extends" for deriving
subclasses from an ordinary class or an abstract class. It is important to note that the subclass implementing an interface
need to override ALL the abstract methods defined in the interface; otherwise, the subclass cannot be compiled. For
example,

//ThesubclassMovablePointneedstoimplementalltheabstractmethods
//definedintheinterfaceMovable
publicclassMovablePointimplementsMovable{
//Privatemembervariables
privateintx,y;//(x,y)coordinatesofthepoint

//Constructor
 publicMovablePoint(intx,inty){
this.x=x;
this.y=y;
}

@Override
publicStringtoString(){
return"("+x+","+y+")";
}

//NeedtoimplementalltheabstractmethodsdefinedintheinterfaceMovable
@Override
publicvoidmoveUp(){
y;
}
@Override
publicvoidmoveDown(){
y++;
}
@Override
publicvoidmoveLeft(){
x;
}
@Override
publicvoidmoveRight(){
x++;
}
}

Other classes in the application can similarly implement the Movable interface and provide their own implementation to the
abstract methods defined in the interface Movable.

TestMovable.java
We can also upcast subclass instances to the Movable interface, via polymorphism, similar to an abstract class.

publicclassTestMovable{
publicstaticvoidmain(String[]args){
MovablePointp1=newMovablePoint(1,2);//upcast
System.out.println(p1);
p1.moveDown();
System.out.println(p1);
p1.moveRight();
System.out.println(p1);

//TestPolymorphism
Movablep2=newMovablePoint(3,4);//upcast
p2.moveUp();
System.out.println(p2);
MovablePointp3=(MovablePoint)p2;//downcast
System.out.println(p3);
}
}

5.7Implementing Multiple Interfaces

As mentioned, Java supports only single inheritance. That is, a subclass can be derived from one and only one superclass.
Java does not support multiple inheritance to avoid inheriting conflicting properties from multiple superclasses. Multiple
inheritance, however, does have its place in programming.

A subclass, however, can implement more than one interfaces. This is permitted in Java as an interface merely defines the
abstract methods without the actual implementations and less likely leads to inheriting conflicting properties from multiple
interfaces. In other words, Java indirectly supports multiple inheritances via implementing multiple interfaces. For example,

publicclassCircleextendsShapeimplementsMovable,Adjustable{
//extendsonesuperclassbutimplementsmultipleinterfaces
.......
}
5.8interface Formal Syntax
The formal syntax for declaring interface is:

[public|protected|package]interfaceinterfaceName
[extendssuperInterfaceName]{
//constants
staticfinal...;

//abstractmethods'signature
...
}

All methods in an interface shall be public and abstract default. You cannot use other access modifier such as private,
protected and default, or modifiers such as static, final.

All fields shall be public, static and final default.

An interface may "extends" from a superinterface.

UML Notation: The UML notation uses a solidline arrow linking the subclass to a concrete or abstract superclass, and
dashedline arrow to an interface as illustrated. Abstract class and abstract method are shown in italics.

5.9Why interfaces?
An interface is a contract or a protocol, or a common understanding of what the classes can do. When a class implements a
certain interface, it promises to provide implementation to all the abstract methods declared in the interface. Interface
defines a set of common behaviors. The classes implement the interface agree to these behaviors and provide their own
implementation to the behaviors. This allows you to program at the interface, instead of the actual implementation. One of
the main usage of interface is provide a communication contract between two objects. If you know a class implements an
interface, then you know that class contains concrete implementations of the methods declared in that interface, and you
are guaranteed to be able to invoke these methods safely. In other words, two objects can communicate based on the
contract defined in the interface, instead of their specific implementation.

Secondly, Java does not support multiple inheritance whereas C++ does. Multiple inheritance permits you to derive a
subclass from more than one direct superclass. This poses a problem if two direct superclasses have conflicting
implementations. Which one to follow in the subclass?. However, multiple inheritance does have its place. Java does this by
permitting you to "implements" more than one interfaces but you can only "extends" from a single superclass. Since
interfaces contain only abstract methods without actual implementation, no conflict can arise among the multiple interfaces.
Interface can hold constants but is not recommended. If a subclass implements two interfaces with conflicting constants,
the compiler will flag out a compilation error.

5.10Interface vs. Abstract Superclass

Which is a better design: interface or abstract superclass? There is no clear answer.

Use abstract superclass if there is a clear class hierarchy. Abstract class can contain partial implementation such as instance
variables and methods. Interface cannot contain any implementation, but merely defines the behaviors.

As an example, Java's thread can be built using interface Runnable or superclass Thread.

5.11Exercises
LINK TO EXERCISES ON POLYMORPHISM, ABSTRACT CLASSES AND INTERFACES

5.12Advanced Dynamic Binding or Late Binding

We often treat an object not as its own type, but as its base type superclass or interface. This allows you to write codes that
do not depends on a specific implementation type. In the Shape example, we can always use getArea() and do not have to
worry whether they are triangles or circles.

This, however, poses a new problem. The compiler cannot know at compile time precisely which piece of codes is going to
be executed at runtime e.g., getArea() has different implementation for Rectangle and Triangle.

In the procedural language like C, the compiler generates a call to a specific function name, and the linkage editor resolves
this call to the absolute address of the code to be executed at runtime. This mechanism is called static binding or early
binding.

To support polymorphism, objectoriented language uses a different mechanism called dynamic binding or latebinding or
runtime binding. When a method is invoked, the code to be executed is only determined at runtime. During the
compilation, the compiler checks whether the method exists and performs type check on the arguments and return type,
but does not know which piece of codes to execute at runtime. When a message is sent to an object to invoke a method,
the object figures out which piece of codes to execute at runtime.

Although dynamic binding resolves the problem in supporting polymorphism, it poses another new problem. The compiler
is unable to check whether the type casting operator is safe. It can only be checked during runtime which throws a
ClassCastException if the type check fails.

JDK 1.5 introduces a new feature called generics to tackle this issue. We shall discuss this problem and generics in details in
the later chapter.

5.13Exercises
LINK TO EXERCISES

6.(Advanced) ObjectOriented Design Issues

6.1Encapsulation, Coupling & Cohesion

In OO Design, it is desirable to design classes that are tightly encapsulated, loosely coupled and highly cohesive, so that the
classes are easy to maintain and suitable for reuse.

Encapsulation refers to keeping the data and method inside a class such users do not access the data directly but via the
public methods. Tight encapsulation is desired, which can be achieved by declaring all the variable private, and providing
public getter and setter to the variables. The benefit is you have complete control on how the data is to be read e.g., in
how format and how to the data is to be changed e.g., validation.

[TODO] Example: Time class with private variables hour 023, minute 059 and second 059; getters and setters throws
IllegalArgumentException. The internal time could also be stored as the number of seconds since midnight for ease of
operation information hiding.

Information Hiding: Another key benefit of tight encapsulation is information hiding, which means that the users are not
aware and do not need to be aware of how the data is stored internally.

The benefit of tight encapsulation outweights the overhead needed in additional method calls.

Coupling refers to the degree to which one class relies on knowledge of the internals of another class. Tight coupling is
undesirable because if one class changes its internal representations, all the other tightlycoupled classes need to be
rewritten.
[TODO] Example: A class uses Time and relies on the variables hour, minute and second.

Clearly, Loose Coupling is often associated with tight encapsulation. For example, welldefined public method for accessing
the data, instead of directly access the data.

Cohesion refers to the degree to which a class or method resists being broken down into smaller pieces. High degree of
cohesion is desirable. Each class shall be designed to model a single entity with its focused set of responsibilities and
perform a collection of closely related tasks; and each method shall accomplish a single task. Low cohesion classes are hard
to maintain and reuse.

[TODO] Example of low cohesion: Book and Author in one class, or Car and Driver in one class.

Again, high cohesion is associated with loose coupling. This is because a highly cohesive class has fewer or minimal
interactions with other classes.

6.2"Isa" vs. "hasa" relationships

"Isa" relationship: A subclass object processes all the data and methods from its superclass and it could have more. We
can say that a subclass object isa superclass object is more than a superclass object. Refer to "polymorphism".

"hasa" relationship: In composition, a class contains references to other classes, which is known as "hasa" relationship.

You can use "isa" and 'hasa" to test whether to design the classes using inheritance or composition.

6.3Program at the interface, not the implementation

Refer to polymorphism

LINK TO JAVA REFERENCES & RESOURCES

Latest version tested: JDK 1.8.0

Last modified: April, 2016

Feedback, comments, corrections, and errata can be sent to Chua HockChuan (ehchua@ntu.edu.sg) | HOME