Outline

Review of the last class class variables and methods method overloading and overriding

Inheritance and polymorphism polymorphism abstract classes and interface

class Circle {• public static final double PI = 3.14159;• public double x, y, r;

} public class example{

• public static void main(String[] args){• Circle.PI = 4;• }

}

Is this correct?

class variable class Circle {

• public static final double PI = 3.14159;• public double x, y, r;

} public class example{

• public static void main(String[] args){• Circle.PI = 4; //Error• }

}The final keyword means that this variable can never be

changed.

public class Circle {

public double x, y, r;

// an class method. Returns the bigger of two circles.public static Circle bigger(Circle c){

if(c.r > r) return c;

else return this;

}//other methods omitted here.

}

Is this correct?

class method

public class Circle {

public double x, y, r;

// an class method. Returns the bigger of two circles.public static Circle bigger(Circle c){

if(c.r > r) //Errorreturn c;

else return this; //Error

}}

static methods may not manipulate any instance variables!

Method Overloading and Overriding

What is the difference?

Overloading and Overriding

What is the difference?Overloading

several methods of the same name can be defined, as long as the methods have different sets of parameters

Overriding a subclass can redefine a superclass method by

using the same signature

Overloadingpublic class Overload {

// first definition of method squarepublic int square(double x){

return x * x;}// second definition of method squarepublic double square(double y){

return y * y;}

} //end class Overload

Is this correct?

Overloadingpublic class Overload {

// first definition of method square with double argumentpublic int square(double x){

return x * x;}// second definition of method square with double argument// causes syntax errorpublic double square(double y){

return y * y;}

} //end class Overload

The compiler would not know how to distinguish between the two square methods.

Overloading

Overloading methods are distinguished by their signature -- a combination of the method’s name and its parameter types

Methods can not be distinguished by return type

Creating overloaded methods with identical parameters lists and different return types is a syntax error

Overloading and overriding

A redefinition of a superclass method in a subclass need not have the same signature as the superclass method. Such a redefinition is not method overriding; rather it is an example of overloading.

It is syntax error if a method in a superclass and a method in a subclass have the same signature but a different return type.

Shape Classes

We have a class called Shape assume all shapes have x and y coordinates override Object's version of toString

Two subclasses of Shape Rectangle add a new method changeWidth Circle

A Shape classpublic class Shape { private double dMyX, dMyY;

public Shape() { this(0,0);}

public Shape (double x, double y) { dMyX = x; dMyY = y; }

public String toString() { return "x: " + dMyX + " y: " + dMyY; }

public double getArea() {return 0;

}}

A Rectangle Classpublic class Rect extends Shape{ private double dMyWidth, dMyHeight; public Rect(double width, double height) { dMyWidth = width; dMyHeight = height; } public String toString() { return

" width " + dMyWidth + " height " + dMyHeight;

} public double getArea() {

return dMyWidth * dMyHeight; } public void changeWidth(double width){

dMyWidth = width; }}

class Circle extends Shape { private double radius; private static final double PI = 3.14159;

public Circle(double rad){ radius = rad; }

public double getArea() { return PI * radius * radius; }

public String toString() {return " radius " + radius;

}}

A Circle Class

PolymorphismIf class Rect is derived from class Shape, an

operation that can be performed on an object of class Shape can also be performed on an object of class Rect

When a request is made through a superclass reference to use a method, Java choose the correct overridden method polymorphically in the appropriate subclass associated with the object

Polymorphism means “different forms”

Object Variables

Assume class Rect is a subclass of class Shape, and it overrides the method getArea().

Does this work?

Rect r = new Rect(10, 20);

Shape s = r;

System.out.println("Area is " + s.getArea());

Object Variables

The above code works if Rect extends ShapeAn object variable may point to an object of its

base type or a descendant in the inheritance chain The is-a relationship is met. A Rect is-a shape so s may

point to it

This is a form of polymorphism and is used extensively in the Java Collection classes

Vector, ArrayList are lists of Objects

Rect r = new Rect(10, 20);

Shape s = r;

System.out.println("Area is " + s.getArea());

More Polymorphism

Assuming Circle and Rect are subclasses of Shape, and have both overridden toString(), which version gets called?

Circle c = new Circle(5);Rect r = new Rect(5, 3);Shape s = null;if( Math.random(100) % 2 == 0 )

s = c;else

s = r;System.out.println( "Shape is "

+ s.toString() );

More Polymorphism

Assuming Circle and Rect have both overridden toString which version gets called?

code works because s is polymorphic method call determined at run time by dynamic binding

Circle c = new Circle(5);Rect r = new Rect(5, 3);Shape s = null;if( Math.random(100) % 2 == 0 )

s = c;else

s = r;System.out.println( "Shape is "

+ s.toString() );

Assume class Rect is a subclass of class Shape, and it has a new method changeWidth(double width), which its super class does not have.

Does this work?

Type Compatibility

Rect r = new Rect(5, 10);Shape s = r;s.changeWidth(20);

polymorphism allows s to point at a Rect object but there are limitations

The above code does not workHow can you modify it a little to make it work

without changing the classes definitions?

Type CompatibilityRect r = new Rect(5, 10);Shape s = r;s.changeWidth(20); // syntax error

polymorphism allows s to point at a Rect object but there are limitations

The above code does not workStatically s is declared to be a shape

no changeWidth method in Shape class must cast s to a rectangle;

Type CompatibilityRect r = new Rect(5, 10);Shape s = r;s.changeWidth(20); // syntax error

Rect r = new Rect(5, 10);Shape s = r;((Rect)s).changeWidth(20); //Okay

Problems with Casting

Does this work?

Rect r = new Rect(5, 10);Circle c = new Circle(5);Shape s = c;((Rect)s).changeWidth(4);

Problems with CastingThe following code compiles but an exception

is thrown at runtime

Casting must be done carefully and correctlyIf unsure of what type object will be then use

the instanceof operator

Rect r = new Rect(5, 10);Circle c = new Circle(5);Shape s = c;((Rect)s).changeWidth(4);

instanceof

syntax: expression instanceof ClassName

Rect r = new Rect(5, 10);Circle c = new Circle(5);Shape s = c;

if(s instanceof Rect)((Rect)s).changeWidth(4);

Assume Manual is a Book, and Book is a Publication. Output?public class InstanceofDemo { public static void main(String args[]) { Publication pub1 = new Publication(); Book book1 = new Book(); Manual manual1 = new Manual(); if (pub1 instanceof Book) System.out.println(“pub1 is a Book”); if (book1 instanceof Book) System.out.println(“book1 is a Book”); if (manual1 instanceof Book) System.out.println(“manual1 is a Book”); }}

instanceof example(syntax: expression instanceof ClassName)

Casting

It is always possible to convert a subclass to a superclass. For this reason, explicit casting can be omitted. For example, Circle c1 = new Circle(5); Shape s = c1;

is equivalent to Shape s = (Shape)c1;

Explicit casting must be used when casting an object from a superclass to a subclass. This type of casting may not always succeed. Circle c2 = (Circle) s;

Implicit Subclass-Object-to-Superclass-Object Conversion

Four possible ways to mix and match superclass references and subclass references with superclass objects and subclass objects

refer to a superclass object with a superclass reference refer to a subclass object with a subclass reference referring to a subclass object with a superclass

reference is safe, but such code can only refer to superclass members

referring to a superclass object with a subclass reference is a syntax error

The role of final in InheritanceA class may be declared as final

that class may not be extended

A method in a class may be declared as final that method may not be overridden guarantees behavior in all descendants can speed up a program by allowing static binding

(binding or determination at compile time what code will actually be executed)

All static methods and private methods are implicitly final, as are all methods of a final class.

Abstract Classes and MethodsAn abstract class defines a common interface

for the various members of a class hierarchy. an object of that type never exists and can never be

instantiated. a Shape or a Mammal

a method may be declared abstract in its header, after visibility modifier no body to the method all derived classes must eventually implement this

method (or they must be abstract as well) any class with 1 or more abstract methods must be

an abstract class

abstract class Shape {

public Shape() { id = ++count; }

public int getId() { return id; }

public abstract double getArea();

private static int count = 0; private int id;}

class Rectangle extends Shape {

public Rectangle(int ul_x, int ul_y, int lr_x, int lr_y) { upperLeft = new Point(ul_x, ul_y); lowerRight = new Point(lr_x, lr_y); }

public double getArea() { double result = Math.abs(upperLeft.x - lowerRight.x)

* Math.abs(upperLeft.y - lowerRight.y); return result; }

private Point upperLeft; private Point lowerRight;}

import java.awt.Point;

class Circle extends Shape {

public Circle(int x, int y, int rad) { center = new Point(x, y); radius = rad; }

public double getArea() { return 4 * Math.atan(1.0) * radius * radius;

// pi == 4 * atan(1.0) }

private int radius; private Point center;}

Genericity

One of the goals of OOP is the support of code reuse to allow more efficient program development

If an algorithm is essentially the same, but the code would vary based on the data type genericity allows only a single version of that code to exist some languages support genericity via

templates in Java, polymorphism and the inheritance

requirement along with interfaces are used

Multiple InheritanceInheritance models the "is-a" relationship

between real world thingsone of the benefits is code reuse, completing

programs faster, with less effortin the real world a thing can have "is-a"

relationships with several other things a Graduate Teaching Assistant is-a Graduate

Student. Graduate Teaching Assistant is-a Employee

a Student is-a Person. a Student is a SortableObject

InterfacesA Java interface is a "pure abstract

class". Design only, no implementation.

Interfaces are declared in a way similar to classes but consist only of public abstract methods public final fields

A Java class extends exactly one other class, but can implement as many interfaces as desired

Common Interfaces in JavaOne of the most interesting interfaces is: Comparable

compareTo should return an int <0 if the calling object is less than the parameter, 0 if they are equal, and an int >0 if the calling object is greater than the parameter

package java.lang

public interface Comparable{

public int compareTo( Object other );}

If a class declares that it will implement an interface, but does not provide an implementation of all the methods in that interface, that class must be abstract

Implementing an Interface

public class Card implements Comparable{public int compareTo(Object otherObject){

Card other = (Card)otherObject;int result = mySuit - other.mySuit;if(result == 0) result = myValue - other.myValue;return result;

}// other methods not shown

}

Polymorphism Againpublic static sort(Comparable[] list){ Comparable temp; int smallest; for(int i = 0; i < list.length - 1; i++) { small = i; for(int j = i + 1; j < list.length; j++)

{ if( list[j].compareTo(list[small]) < 0)

small = j; } // end of j loop temp = list[i];

list[i] = list[small]; list[small] = temp; } // end of i loop}