Chapter 3 ■ Java Class Design

This code will give a compiler error of "Type mismatch: cannot convert from Shape to Circle". This is because of the lack of an explicit downcast from Shape to Circle in the assignment "Circle c2 =

c1.copy();".

Since you know clearly that you are going to assign a Circle object returned from Circle’s copy method, you can give an explicit cast to fix the compiler error:

Circle c2 = (Circle) c1.copy();

Since it is tedious to provide such downcasts (which are more or less meaningless), Java provides covariant return types where you can give the derived class of the return type in the overriding method. In other words, you can change the definition of copy method as follows:

public Circle copy() { /* return a copy of this object */ }

Now the assignment in the main method Circle c2 = c1.copy(); is valid and no explicit downcast is needed (which is good).

Overriding: Deeper Dive

It is important to understand method overriding in depth, so let’s explore it in more detail. Let’s use the override equals method in the Point class. Before that, here is the signature of the equals() method in the Object class:

public boolean equals(Object obj)

The equals() method in the Object class is an overridable method that takes the Object type as an argument. It checks if the contents of the current object and the passed obj argument are equal. If so, the equals() returns true; otherwise it returns false.

Now, let’s see whether the Point class is overriding the equals() method correctly in Listing 3-16.

Listing 3-16.  Point.java

public class Point {

private int xPos, yPos;

public Point(int x, int y) { xPos = x;

yPos = y;

}

//override the equals method to perform

//"deep" comparison of two Point objects public boolean equals(Point other){

if(other == null) return false;

//two points are equal only if their x and y positions are equal

if( (xPos == other.xPos) && (yPos == other.yPos) ) return true;

else

return false;

}

70

Chapter 3 ■ Java Class Design

public static void main(String []args) { Point p1 = new Point(10, 20); Point p2 = new Point(50, 100); Point p3 = new Point(10, 20);

System.out.println("p1 equals p2 is " + p1.equals(p2)); System.out.println("p1 equals p3 is " + p1.equals(p3));

}

}

This prints

p1 equals p2 is false

p1 equals p3 is true

The output is as expected, so is this equals() implementation correct? No! Let’s make the following slight modification in the main() method:

public static void main(String []args) { Object p1 = new Point(10, 20); Object p2 = new Point(50, 100); Object p3 = new Point(10, 20);

System.out.println("p1 equals p2 is " + p1.equals(p2)); System.out.println("p1 equals p3 is " + p1.equals(p3));

}

Now it prints

p1 equals p2 is false

p1 equals p3 is false

Why? Both main() methods are equivalent. However, this newer main() method uses the Object type for declaring p1, p2, and p3. The dynamic type of these three variables is Point, so it should call the overridden equals() method. However, the overriding is wrong, so the main() method calls the base version, which is the default implementation of Point in Object class!

If the name or signature of the base class method and the overriding method don’t match, you will cause subtle bugs. So ensure that they are exactly the same.

The equals() method should have Object as the argument instead of the Point argument! The current implementation of the equals() method in the Point class hides (not overrides) the equals() method of the

Object class.

In order to overcome the subtle problems of overloading, you can use @Override annotation, which was introduced in Java 5. This annotation explicitly expresses to the Java compiler the intention of the programmer to use method overriding. In case the compiler is not satisfied with your overridden method, it will issue a complaint, which is a useful alarm for you. Also, the annotation makes the program more understandable, since the @Override annotation just before a method definition helps you understand that you are overriding a method.

71

Chapter 3 ■ Java Class Design

Now this program prints

p1 equals p2 is false

p1 equals p3 is true

This is the expected output and with the correct implementation of the equals method implementation.

Invoking Superclass Methods

It is often useful to call the base class method inside the overridden method. To do that, you can use the super keyword. In derived class constructors, you can call the base class constructor using the super keyword. Such a call should be the first statement in a constructor if it is used. You can use the super keyword for referring to the base class members also. In those cases, it need not be the first statement in the method body. Let’s look at an example.

You implemented a Point class that is a 2D-point: it had x and y positions. You can also implement a 3D-point class with x, y, and z positions. For that you do not need to start implementing it from scratch: you can extend the 2D-point and add the z position in the 3D-point class. First, you’ll rename the simple implementation of Point class to Point2D. Then you’ll create the Point3D class by extending this Point2D (see Listing 3-18).

Listing 3-18.  Point3D.java

//Point2D.java class Point2D {

private int xPos, yPos; public Point2D(int x, int y) {

xPos = x; yPos = y;

}

public String toString() {

return "x = " + xPos + ", y = " + yPos;

}

public static void main(String []args) { System.out.println(new Point2D(10, 20));

}

}

//Point3D.java

//Here is how we can create Point3D class by extending Point2D class public class Point3D extends Point2D {

private int zPos;

//provide a public constructors that takes three arguments (x, y, and z values) public Point3D(int x, int y, int z) {

//call the superclass constructor with two arguments

//i.e., call Point2D(int, int) from Point2D(int, int, int) constructor) super(10, 20); // note that super is the first statement in the method zPos = z;

}

73