1 / 71

COP 3503 FALL 2012

SHAYAN JAVED
LECTURE 4

Programming Fundamentals using Java

 2 / 71

Inheritance
 Derive new classes (subclass) from existing ones
(superclass).

 Only the Object class (java.lang) has no superclass

 Every class = subclass of Object.

 3 / 71

Inheritance
 Code reuse – methods and properties.

 Use classes to model objects of the same type

 Define general class

 Then define specialized classes.
 4 / 71

Inheritance
 Can only inherit from one class.

 Can inherit from multiple classes in other

languages (C++)
 5 / 71

Example
 Let’s say you create the following classes:
 Circle
 Rectangle
 Triangle
 etc.

 Share certain properties, but also specialized

properties
 6 / 71

Example
public class GeometricObject {
private String Color;
private String name;
private float area;

// constructors...
public GeometricObject(String color, String name) {
…
}

// get/set methods, etc.

}
 7 / 71

Example
public class Circle extends GeometricObject {
private double radius; // specific property

public Circle(double radius, String color, String name) {

this.radius = radius;
this.color = color;
this.name = name;
}

// get/set methods, etc.

public double getArea() {

return radius * radius * Math.PI;
}
}
 8 / 71

Example
 An error in the constructor!
public Circle(double radius, String color, String name) {
this.radius = radius;
this.color = color;
this.name = name;
}

 Why can’t we use “this.color” and “this.name”?

 9 / 71

Example
 They are private properties.

 NOT accessible by subclasses.

 Should use setColor() instead.

 public methods/properties inherited.

 10 / 71

Example
public class Rectangle extends GeometricObject {
private double width, height; // specific properties

public Rectangle(double w, double h, String color, String name) {

this.height = h;
this.width = w;
setColor(color);
setName(name);
}

// get/set methods, etc.

public double getArea() {

return width * height;
}
}
 11 / 71

The super keyword

 Are constructors inherited?

 Yes. super used for:

 calling a super class constructor
 calling a super class method
 12 / 71

The super keyword

 Constructors:

 super() calls the default constructor

 super(arguments) calls the constructors according

to the arguments
 13 / 71

The super keyword

 Constructors:
public Circle(double radius, String color, String name)
{
super(color, name);
this.radius = radius;
}
 14 / 71

The super keyword

 Constructors:
public Circle(double radius, String color, String name)
{
super(color, name);
this.radius = radius;
}

public GeometricObject(String color, String name) {

this.color = color;
this.name = name;
}
 15 / 71

The super keyword

What if we don’t add the super(..) constructor call?

 16 / 71

The super keyword

public Circle(double radius, String color, String name)
{
this.radius = radius;
}
 17 / 71

The super keyword

public Circle(double radius, String color, String name)
{
this.radius = radius;
}

Is the same as:

public Circle(double radius, String color, String name)

{
super();
this.radius = radius;
}
 18 / 71

The super keyword

Called Constructor Chaining

 19 / 71

The super keyword

 Calling the super class methods

 super.method(parameters)...

 Optional
 20 / 71

 Using get/set methods to access properties of the

superclass is cumbersome…
 21 / 71

The protected keyword

 Often want subclasses to directly access
properties/methods

 Use protected instead of private/public

 Subclasses can now directly access

 22 / 71

Private
public class GeometricObject {
private String Color;
private String name;
private float area;

// constructors...

// get/set methods, etc.

}
 23 / 71

The protected keyword

public class GeometricObject {
protected String Color;
protected String name;
protected float area;

// constructors...

// get/set methods, etc.

}
 24 / 71

The protected keyword

public class Circle extends GeometricObject {
private double radius; // specific property

public Circle(double radius, String color, String name) {

this.radius = radius;
this.color = color;
this.name = name;
}
Now works!
}
 25 / 71

Polymorphism
 Important aspect of OOP
 26 / 71

Polymorphism
 Important aspect of OOP

 “capability of an action or method to do different

things based on the object that it is acting upon. ”
 27 / 71

Polymorphism
 Important aspect of OOP

 “capability of an action or method to do different

things based on the object that it is acting upon. ”

 “characteristic of being able to assign a different

meaning or usage to something in different contexts
- specifically, to allow an entity such as a variable, a
function, or an object to have more than one form.”
 28 / 71

Polymorphism
1. Overriding Methods

2. Overloaded methods

3. Dynamic (late) method binding

 29 / 71

Overriding Methods
 Sometimes need to overwrite methods written in
the superclass

 Re-define the method in the subclass.

 30 / 71

Overriding Methods
 The Object class and toString()

 toString() = String output when you print the

object
 31 / 71

Overriding Methods
 The Object class and toString()

 toString() = String output when you print the

object

 Object class has default toString() method

 32 / 71

The toString() method

public String toString() {
String str;
...
return str;
}
 33 / 71

The toString() method

Circle circle1 = new Circle(“Circle1”, “Red”, 3.5);

System.out.println(circle1);

Output:

?
 34 / 71

The toString() method

Circle circle1 = new Circle(“Circle1”, “Red”, 3.5);

System.out.println(circle1);

Output:

Circle@19821f
 35 / 71

The toString() method

 So override the method

public String toString() {

String str = “”;
str += “Circle: ” + getName() + “,”;
str += “Color: ” + getColor() + “,”;
str += “Radius: ” + getRadius();
return str;
}
 36 / 71

The toString() method

Circle circle1 = new Circle(“Circle1”, “Red”, 3.5);

System.out.println(circle1);

Output:

Circle: Circle1,Color: Red,Radius: 3.5

 37 / 71

The equals() method

 The Object class and equals()

 equals (Object obj) = returns whether the object

passed in and this one are the same
 38 / 71

The equals() method

 Default implementation:

public boolean equals(Object obj) {

return (this == obj);
}

Compares references
 39 / 71

The equals() method

Circle circle1 = new Circle(3.5);
Circle circle2 = new Circle(3.5);
 40 / 71

The equals() method

Circle circle1 = new Circle(3.5);
Circle circle2 = new Circle(3.5);

circle1.equals(circle2); // ?
 41 / 71

The equals() method

Circle circle1 = new Circle(3.5);
Circle circle2 = new Circle(3.5);

circle1.equals(circle2); // returns false!

 42 / 71

The equals() method

Circle circle1 = new Circle(3.5);
Circle circle2 = new Circle(3.5);

circle1.equals(circle2); // returns false!

Circle circle3 = circle1;

circle1.equals(circle3); // ?
 43 / 71

The equals() method

Circle circle1 = new Circle(3.5);
Circle circle2 = new Circle(3.5);

circle1.equals(circle2); // returns false!

Circle circle3 = circle1;

circle1.equals(circle3); // returns true!

 44 / 71

The equals() method

 Override it

public boolean equals(Object obj) {

if (obj instanceof Circle)
return this.radius == ((Circle)obj).getRadius();
else
return false;
}
 45 / 71

The instanceof operator

 Test if object is of a specified type

if (object instanceof Class)

 46 / 71

The instanceof operator

 Test if object is of a specified type

if (object instanceof Class)

 Example:

Circle circle1 = new Circle(3.4);

if (circle1 instanceof Circle) {
…
}
 47 / 71

The instanceof operator

 Testing with the SuperClass:

if (subclassObj instanceof SuperClass) {

…
}

?
 48 / 71

The instanceof operator

 Testing with the SuperClass:

if (Circle instanceof GeometricObject) {

…
}

?
 49 / 71

The instanceof operator

 Testing with the SuperClass:

if (subclassObj instanceof SuperClass) {

…
}

returns true!
 50 / 71

The instanceof operator

 Example:

Circle circle1 = new Circle(3.4);

if (circle1 instanceof GeometricObject) {
…
}

returns true!
 51 / 71

The instanceof operator

What if we write:

if (SuperClassObj instanceof subclass) {

…
}
 52 / 71

The instanceof operator

if (SuperClassObj instanceof subclass) {
…
}

 returns true as long as the object is an instance of

the subclass
 53 / 71

The instanceof operator

 Example:

Object is a superclass of Circle

public boolean equals(Object obj) {

if (obj instanceof Circle)
return this.radius == ((Circle)obj).getRadius();
else
return false;
}
 54 / 71

The instanceof operator

 Be careful with null objects

String s = null;

s instanceof String = false

 55 / 71

Object casting
 So we can determine
if (SuperClassObj instanceof subclass)

 Convert it to subclass by casting

 56 / 71

Object casting
 So we can determine
if (SuperClassObj instanceof subclass)

 Convert it to subclass by casting

 Can now access members/properties

 57 / 71

Object casting
Once again...

public boolean equals(Object obj) {

if (obj instanceof Circle) {
return this.radius == ((Circle)obj).getRadius();
}
else
return false;
}
 58 / 71

Object casting
Once again...

public boolean equals(Object obj) {

if (obj instanceof Circle) {
Circle circle = (Circle)obj; // casting
return this.radius == circle.getRadius();
}
else
return false;
}
 59 / 71

Overloading Methods
 Looked at it before.

 Can have multiple methods with the same name.

 But different parameters, return type

 60 / 71

Dynamic binding
 Object type is determined at run-time

 ability of a program to resolve references to

subclass methods at runtime. 
 61 / 71

Dynamic binding
public class GeometricObject {
protected String Color;
protected String name;
protected float area;

public float getArea() {

return -1;
}

}
 62 / 71

Dynamic binding
// Circle
public class Circle {
public float getArea() {
return Math.PI * radius * radius;
}
}

// Rectangle
public class Rectangle {

public float getArea() {

return width * height;
}
}
 63 / 71

Dynamic binding
GeometricObject[] objs = new GeometricObject[2];
 64 / 71

Dynamic binding
GeometricObject[] objs = new GeometricObject[2];
objs[0] = new Circle(3);
objs[1] = new Rectangle(1, 2);
 65 / 71

Dynamic binding
GeometricObject[] objs = new GeometricObject[2];
objs[0] = new Circle(3);
objs[1] = new Rectangle(1, 2);

for (GeometricObject i : objs) {

System.out.println(i.getArea());
}
 66 / 71

Dynamic binding
GeometricObject[] objs = new GeometricObject[2];
objs[0] = new Circle(3);
objs[1] = new Rectangle(1, 2);

for (GeometricObject i : objs) {

System.out.println(i.getArea());
}

What’s the output?

 67 / 71

Dynamic binding
Output:
9.0
2.0

The subclass getArea() methods are called.

At run-time, Java dynamically determines the class.

 68 / 71

final Classes
 Sometimes classes shouldn’t be allowed to be
extended.

 The String class for example. Use the keyword

“final”

final class String {

...
}
 69 / 71

final Methods
 Methods which can’t be overridden in the
subclasses.
 70 / 71

Summary...
 Inheritance
 super
 protected
 Polymorphism
 Overloading
 Overwriting
 Dynamic binding
 instanceof
 Object casting
 final classes and methods
 71 / 71

Next lecture...
 Abstract Classes

 Interfaces