For use of IST410 students only Inheritance-1 Introduction to Inheritance and Polymorphism.

Inheritance-1 For use of IST410 students only

Introduction to Inheritance and Polymorphism


Objectives

Concepts of Inheritance Abstract Class Abstract Methods Polymorphism Interfaces


Inheritance

One of the major concepts of OOP is inheritance Through inheritance, code of one class can be reused in

another class The class, whose code is reused, is called base class; also

known as parent or super class The new class that inherits from a base class is known as a

derived class. A derived class may also be called child or subclass

The keyword extends is used to derive a child classclass Child extends Parent { // }


What is inherited?

Parent Methods Data members

Child methods ofParent class+Child classmethods

data members of Parentclass + Child class datamembers


Base class Example

public class Circle { protected double radius; public Circle() { this(1.0); } public Circle(double r) { radius = r; }

public double area() { return radius*radius*Math.PI; }

//other methods of Circle }

since radius has a protected modifier, it can be accessed in a subclass

Suclasses cannot directly access private members of a superclass


subclass Example

public class Cylinder extends Circle { private double length; public Cylinder() { super(); length = 1.0; }

public Cylinder(double r, double l) { super(r); length = l; }

public double volume() { return radius*radius* Math.PI*length; }

//other methods of Cylinder }

radius of the Circle class can be accessed directly in the Cylinder class since it has a protected modifier

Constructors are not inherited

Callsparent class constructor


Modifiers

Java supports 4 modifiers public private protected no modifier

We have examined public and private in earlier discussions protected is used with inheritance A member with a protected modifier is accessible only to

subclasses For example: radius of Circle class is protected and

therefore can be used in a subclass as in the volume method of Cylinder


Modifiers

What if a member is marked private? public class Circle { private double radius; // rest of the class } Direct access of radius in a subclass generates compiler

error public class Cylinder extends Circle {

public double volume() { return radius*radius*Math.PI*length;

}// rest of the class

}Compiler Error


Modifiers

What if a member has no modifier? public class Circle { double radius; // rest of the class } radius is considered to have package visibility What is a package?

A project is often divided into subgroups just like directory Each group may be given an optional package name Each class in the group is then a member of the package Java language itself is divided into a number of packages or

libraries


Inheritance and access level

The table below shows the relationship between the access levels and inheritance

default modifier means no modifierclass MyClass { .... // no modifier }

Base class Modifier Accessible from subclasspublic yesprivate noprotected yesdefault no unless in the same

package


Single Inheritance

Only single inheritance is supported in Java i.e. a subclass can extend only one superclass

Constructs such as class X extends Y, Z { ....} are illegal A protected or public method of the superclass can be

invoked in a subclass method using a super call super.methodName() We will see a partial example later


When do we extend?

Code reuse is not a ‘sufficient’ reason to extend a class A class can be extended when there exists an ‘IS-A’

relationship between two objects Consider two classes: (1) Shape that represents any

geometric shape, and (2) a class called Circle It makes sense to say Circle IS A Shape; therefore, it

would make sense to extend Circle from Shape Does it make sense to say an Automobile is a shape?

Perhaps not. We would not extend Automobile from a class called

Shape


When do we extend?

Automobiles do have shape We may specify an attribute of an automobile using the

Shape classclass AutomobileShape extends Shape { ...... }class Automobile {

AutomobileShape style; //Shape attribute// other implementation details

} There is a relationship between AutomobileShape and

Automobile and it is called HAS-A relationship


Inheritance Hierarchies

We can construct inheritance hierarchies by extending subclasses in succession

For examplepublic class Circle extends Shape { ....... }public class Cylinder extends Circle { ..... }

In the above hierarchy, Cylinder inherits members of Circle as well as those of Shape

More complex inheritance hierarchies can be constructed as shown in the next slide.


Inheritance Hierarchies

Shape

Circle Hexagon Square

Cylinder Cube

Circle inherits from Shape and Cylinder inherits from Circle

Hexagon inherits from Shape and is a sibling of Circle

Square is a sibling of Hexagon and Circle

Cube is a child of Square and has no relationship with Hexagon, Circle, or Cylinder except for common ancestry through Shape


Overriding

Sometimes a specific behavior of the subclass may be different from the corresponding behavior of its parent

For such cases, the method of the superclass can be overridden in the subclass

Consider the area calculation for a Cylinder We may want the area method of a Cylinder to return the

total surface area of the cylinder The area method of Circle, the parent class of Cylinder, is

no more able to do the job for Cylinder and needs to be overriden


Overriding

Area method of the Circle classpublic double area() {

return radius*radius*Math.PI; } The Cylinder class extends Circle

public class Cylinder extends Circle { ...... } The area of a Cylinder is different from that of Circle Choices:

Name the area method of Cylinder: CylinderArea? Name the area method of Cylinder: area? <---- Override


Overriding

area method of the Circle can be overriden by implementing an area method in the Cylinder classpublic double area() { // Cylinder method

double xSection = 2 * Math.PI*radius*radius;double cSurface = 2*Math.PI*radius*length;

return (xSection+ cSurface); } Rules for overriding

return type of both must be the same must have same access level must have same name and argument list


Including parent class method call in subclass methods

Consider the area() method of the Cylinder class again. A part of this method calculates the cross section area of

the cylinder that is nothing more than the area of a circle. We have an area method in the circle class and do not need

to recode this part in the cylinder’s area calculation

public double area() {

double xSection = 2 *super.area();double cSurface = 2*Math.PI*radius*length;

return (xSection+ cSurface); }

Calculation replaced by call to the super class method


Preventing Overriding

Sometimes we would like to prevent overriding A method can be prevented from being overridden by

making it final

public final double area() { // Cylinder method // implementation }


Preventing Inheritance

Sometimes we do not want a class to be subclassed Inheritance can be prevented by making the class final

public final class Cylinder {// implementation

}


Java Inheritance Hierarchy

All classes in Java derive from a class called Object Therefore we could have written

public class Circle extends Object ....public class Cylinder extends Circle ...

Cylinder class not only inherits from Circle, but also from Object

Since all Java classes derive from Object, it is possible to construct collection of Objects

Java language supports such collections through its collection API: Vector, Hashtable, Map, List etc.


Java Inheritance Hierarchy

Two useful methods of Object public String toString()

Returns a String representation of the object’s data If not overriden, method can still be called but would result in

garbage information protected Object clone()

Clones the object on which this method is called Need to override these methods in the class


Memory Allocation

The construction of an object that inherits from another can be conceptually shown as follows

Cylinder cy = new Cylinder();

Object

Circle

Cylinder


Memory Allocation

What happens when we construct an object that inherits from some superclass?

Memory is allocated for the entire object All instance variables are initialized to their default values Starting with the object being created, constructors are called

recursively all the way through Object using the following order Constructor parameters are bound to their values If this() call exists, execute recursively and finish by executing

the body of the current constructor If no this(), call explicit or implicit super() except for Object Execute explicit instance variable initializers Execute the body of the current constructor


Memory Allocation

What happens when we construct a Cylinder object using:Cylinder cy = new Cylinder();

Memory is allocated for the entire object: radius and length Both initialized to 0.0d No constructor parameter for cylinder No this() call for cylinder super() is called explicitly for Circle No parameter for circle Explicit this(1.0) call for circle Set parameter r = 1.0 for Circle(double r) No explicit this call for Circle(double r) call Super() for Object


Memory Allocation

No parameter setting necessary for Object No this() call for Object No super() call for Object No explicit initialization or constructor body for Object No explicit initialization for radius of Circle Execute body of Circle constructor: set radius = parameter r No explicit initialization for Cylinder instance variable length Execute constructor body for the Cylinder: set length = 1.0


Polymorphism

Polymorphism is the ability of an Object to have many forms

For example, consider the area method of Circle The Cylinder subclass has its own way of calculating the

area: the area operation is polymorphic since it has many forms

In a world of non-polymorphic programming, we would need to distinguish the area operation for each class and create artificial operation such as CircleArea and CylinderArea

This is inflexible since we may need a sphereArea and so on


Polymorphism

An alternative choice is to define an area for the base class and override the method in each of the subclasses

In this scenario, the object decides which area method to use at run-time

How does the JVM resolve which method to apply when we execute a statement of the form obj.method()?

JVM looks for the method in the current class first If not found, JVM looks for the method in the immediate super

class The process continues until Object is reached If not found, an error is reported


Polymorphism

One of the keys to using polymorphism is to declare objects of general superclass type but assign objects of subclasses

Circle c = new Cylinder(); The run-time environment is then made responsible to

determine which method to invoke i.e that of Circle or Cylinder

This enables a programmer to be flexible in designing methods that can handle any object in an inheritance hierarchy


Polymorphism

However, an object has only one form. Thus an assignment of the type

Circle c = new Cylinder();does create practical complications

For the compiler, c is still an object of type Circle Therefore, using c, only members of the Circle class can

be invoked, anything else would be considered illegal This problem can be overcome through type checking and

casting


Polymorphism

Assuming that volume() is a method of the Cylinder class and not of the Circle, the following code would not compile Circle c = new Cylinder(); // Is OK

double v = c.volume(); // will not compile What compiler thinks:

c is an object of type Circle A Circle object does not have a method called volume() Therefore, compilation of c.volume() cannot proceed

Solution: wrap the code within type checkingif ( c instanceof Cylinder) {

Cylinder cy = (Cylinder) c; ....


Polymorphism: which method is called?

Consider the Circle and Cylinder class and assume that Circle has a method to compute Circumferene

Cylinder c = new Cylinder(); double f = c.circumference(); At execution time, JVM checks for the circumference()

method in the Cylinder (subclass) class Since the method is not found, parent class becomes

responsible and the circumference() method of Circle is used


Polymorphism: which method is called?

Consider the Circle and Cylinder class again and assume that both Circle and Cylinder have a method to compute area

Circle c = new Cylinder(); double f = c.area(); Compilation is successful since Circle has an area method At execution time, JVM checks for the true type of c and it

is a Cylinder JVM applies the area() method of the Cylinder class An object’s ability to decide what method to apply to

itself, depending upon its position in the inheritance hierarchy is usually a polymorphic behavior


Polymorphism

Key to polymorphism is late binding Code for the method call is not generated until run time Every time a method is called in the inheritance hierarchy,

dynamic binding is applied at run time Normal binding technique is static


Casting objects

In Java, an object cannot be cast as another object Casting is allowed only when the compiler is satisfied that

such casting is possible Rules:

casting a subclass object to superclass is not necessary; you are promising less

assigning superclass to subclass - explicit cast is needed; you are promising more. Cast will be allowed only if the promise can be kept.


Casting objects

Circle c = new Cylinder(); // Is OK double d = c.area(); // what is executed? // do appropriate processing if ( c instanceof Cylinder) { Cylinder cy = (Cylinder) c; // cast to Cylinder // process for cy } Casting is allowed since c is truely a Cylinder


Abstract class

Abstract class is like any other class can contain methods and data members methods can be abstract and non-abstract data members can be static or non-static

A class is abstract if at least one method is abstract An abstract method dos not have an implementation A class can be declared abstract even if it has no abstract

method An abstract class cannot be instantiated Only descendant non-abstract classes can be instantiated


Abstract class: Example

import java.util.*; //Merchandize.javapublic abstract class Merchandize { private long productCode; private double unitPrice;

private Calendar manfDate; public Merchandize() { } public Merchandize(long p, double u,

Calendar g) { productCode = p; unitPrice = u; manfDate = g; } public long getCode() { return productCode; } public double getPrice() { return unitPrice; }

public String getManfDate() { int yr = manfDate.get(Calendar.YEAR); int mon = manfDate.get(Calendar.MONTH); int day =

manfDate.get(Calendar.DAY_OF_MONTH); String d = mon+"/"+day+"/"+yr; return d; }

public abstract void draw(); public abstract String warning();}

Merchandize is an abstract class and contains two abstract methods: draw, warning


Extending Abstract class: Example

import java.util.*; //Soup.javapublic class Soup extends Merchandize { private String manfName; public Soup() { super();

manfName = null; } public Soup(long code, double pr, Calendar m,

String n) { super(code,pr,m);

manfName = n; } public String getManfName() { return manfName; } public String warning() { return "This soup is quite safe"; } public void draw() {

System.out.println("No picture on file for this product");

}

public static void main(String args[]) { String manf = "Soup King";

long code = 121L;double pr = 23.29;Calendar gc = new GregorianCalendar(TimeZone.getDefault(),

Locale.getDefault());Soup sk = new Soup(code,pr,gc, manf);System.out.println("Product code = ” +

sk.getCode());System.out.println("Unit Price = ” +

sk.getPrice()); System.out.println("Manufacturing date = ” +

sk.getManfDate()); System.out.println("Manufacture's name = ” + sk.getManfName());

System.out.println("Picture of product");sk.draw();System.out.println("product warning message = ” + sk.warning());}

}


Rational for Abstract class

Consider the Merchandize class - it can be used to represent any merchandize in a store

Some products may have mandated warning, many may have pictures for display

How do we draw the picture without knowing which specific merchandize we are dealing with?

Soup, on the other hand, is a concrete class and we would know how to draw its picture

Similarly, we can put warning messages only for those subclasses that must carry such a warning: Cigarettes for example


Rational for Abstract class

In general, as you travel up an inheritance hierarchy, classes become progressively more general. It is difficult to define their behavior.

The subclasses are progressively more concrete and their behavior can be defined

Abstract methods are used in the super class to provide a common structure that all subclasses promise to implement

Subclasses then override the abstract methods to provide the applicable behavior for the class

Important: since a subclass inherits from its parent, the subclass must implement all abstract methods of the superclass, otherwise it becomes abstract


Interfaces

Interface is an abstract class where all methods are abstract It can contain data members, however, they must all be

static and final Can be used to implement multiple inheritance through

which a class can implement common behaviors from more than one parent

A class can implement one or more interfacespublic class X extends Y implements A, B { .... }

where A and B are two interfaces


Interface Example

Consider the ++ operator that adds one to its integral operand

Suppose we want to add this behavior for a few classes We can define an interface with an abstract method

public interface IncrementOperator {public void pp();

} Other classes can now implement this interface and

provide a definition for the abstract method


Use of Interface: MyFloat.java

public class MyFloat implements IncrementOperator {private float num;public MyFloat() {}public MyFloat(float f) { num = f;}public void pp(){ num += 1.0;}public float getValue(){

return num;}public static void main(String args[]){

MyFloat mf = new MyFloat(3.4f);System.out.println("Start value = "+mf.getValue());mf.pp();System.out.println("After increase = "+mf.getValue());

}}

Implementation of the abstract method declared in the interface. Compare this implementation to that in PointWithPP class

Declaring the intention to implement an Interface


Use of Interface: PointWithPP.java

public class PointWithPP implements IncrementOperator { private int x, y; public PointWithPP() { } public PointWithPP(int x, int y) {

this.x = x; this.y = y;

} public void pp(){

x++; y++;

} public void showCoordinates(){

System.out.println("x = "+x+" y = "+y); } public static void main(String args[]){

PointWithPP pt = new PointWithPP(10,15);pt.showCoordinates();pt.pp();pt.showCoordinates();

}}

Implementation of the abstract method declared in the interface. Notice that this implementation is significantly different from that in MyFloat class

Declaring the intention to implement an Interface


Exercise

Define an Interface called MathOperator with methods for the following

add 1 to a number subtract 1 from a number add an integer number supplied as an argument subtract an integer supplied as an argument print - prints the number value

Write a class called MyInt that defines exactly one integer as its instance variable. This class implements the MathOperator; add appropriate constructor

Write another class MyFloat that defines exactly one float as its instance variable. This class also implements the MathOpertaor; add appropriate constructor

Date post:	20-Dec-2015
Category:	Documents
View:	214 times
Download:	0 times

For use of IST410 students only Inheritance-1 Introduction to Inheritance and Polymorphism.

Documents