Inheritance and Polymorphism

Inheritance and Polymorphism

Inheritance • It is one of the most important feature of object-oriented programs. • It allows creation of hierarchical classifications • You can create a general class and specific classes inherit the members of a general class • In java, the class that is inherited is called superclass • The class that is inheriting is called subclass • A subclass is a specialized version of a superclass

Simple Inheritance Example class TwoDShape { double width; double height; void showDim() { System.out.println("Width and Height are " + width + " and " + height); }; } class Triangle extends TwoDShape { String style; double area() { return ((width*height) / 2.0); } void showStyle() { System.out.println("Triangle is " + style); } }

Output -------- Info for t1: Triangle is isosceles Width and Height are 4.0 and 4.0 Area is 8.0 Info for t2: Triangle is right Width and Height are 8.0 and 12.0 Area is 48.0 class Shapes { public static void main(String args[ ]) { Triangle t1 = new Triangle(); Triangle t2 = new Triangle(); t1.width = 4.0; t1.height = 4.0; t1.style = "isosceles"; t2.width = 8.0; t2.height = 12.0; t2.style = "right"; System.out.println("Info for t1: "); t1.showStyle(); t1.showDim(); System.out.println("Area is " + t1.area()); System.out.println(); System.out.println("Info for t2: "); t2.showStyle(); t2.showDim(); System.out.println("Area is " +t2.area()); System.out.println(); } }

The superclass is TwoDShape. • The subclass is Triangle. • The keyword that makes Triangle to inherit the members of TwoDShape is extends. • TwoDShape is a superclass because it defines the attributes of a “generic” two-dimensional shape such as Square, Triangle, and so on. • Then the Triangle class is a specific type of TwoDShape. Triangle class includes all members of TwoDShape class plus some specific member (attributes and methods) that is specific to objects of type Triangle. • Note that the attributes width and height do not belong to Triangle class but they are used in the method “area” since they are inherited by Triangle class.

The general form of a class declaration that inherits a superclass is: • Class subclass-name extends superclass-name • { • // body • } • Several subclasses may inherit from the same superclass • However, a subclass can only inherit from one superclass • This is similar to saying a parent can have many children but a child can only have one parent. • Subclasses of the same superclass are not related. The only common feature between them is what they inherit.

class TwoDShape • { • double width; • double height; • void showDim() • { • System.out.println(“….”); • }; • } • class Rectangle extends TwoDShape • { • boolean isSequence() • { • ….. • } • double area() • { • …… • } • } • class Triangle extends TwoDShape • { • String style; • double area() • { • …… • } • }

Triangle and Rectangle both inherit the attributes “width” and “height” and the method “showDim()” from the TwoDShape class • The method “area()” and attribute “style” belong specifically to Triangle class • Further, the methods “isSequence()” and “area()” (the one that is defined in Rectangle class) belongs to Rectangle class • The “area()” that is defined in Triangle class has nothing to do with the “area()” defined in Rectangle class.

Member Access and Inheritance • Remember the rules of encapsulation property in object-oriented program • The rule is, a private member of a class can only be accessed through the methods of that class and not by members of other classes • The rule also applies for inheritance. It means when class B inherits the private members of class A, methods in class B do not allow to access private members inherited from class A.

class TwoDShape { private double width; private double height; void showDim() { System.out.println("Width and Height are " + width + " and " + height); }; } class Triangle extends TwoDShape { String style; double area() { return ((width*height) / 2.0); } void showStyle() { System.out.println("Triangle is " + style); } } Cannot access a private members of superclass

To overcome this limitation, it is possible to create a set of accessor routines (get() and set() values) for the superclass private members in order to access them. • class TwoDShape • { • private double width; private double height; • double getWidth(){return width;} • double getHeight(){return height;} • void setWidth(double w) { width = w; } • void setHeight(double h) { height = h; } • void showDim() • { System.out.println("Width and Height are " + width + " and " + height);}; • } • class Triangle extends TwoDShape • { • String style; • double area() • { return ((super.getWidth()*(super.getHeight())) / 2.0); } • void showStyle() • { System.out.println("Triangle is " + style); } • }

Output -------- Info for t1: Triangle is isosceles Width and Height are 4.0 and 4.0 Area is 8.0 Info for t2: Triangle is right Width and Height are 8.0 and 12.0 Area is 48.0 class Shapes3 { public static void main(String args[ ]) { Triangle t1 = new Triangle(); Triangle t2 = new Triangle(); t1.setWidth(4.0); t1.setHeight(4.0); t1.style = "isosceles"; t2.setWidth(8.0); t2.setHeight(12.0); t2.style = "right"; System.out.println("Info for t1: "); t1.showStyle(); t1.showDim(); System.out.println("Area is " + t1.area()); System.out.println(); System.out.println("Info for t2: "); t2.showStyle(); t2.showDim(); System.out.println("Area is " +t2.area()); System.out.println(); } }

Constructors and Inheritance • It is possible for both subclasses and superclasses to have their own constructors • The question is that when an object of subclass is created which constructor is called? • Constructor of superclass is called? Or • Constructor of subclass is called? Or • Both constructors are called? • The answer is, when an object of the subclass is created, it has two portions: the specialized portion and the inherited portion. • The constructor of the superclass initializes the inherited attributes and the constructor of the subclass initializes the specialized attributes. But how?

In java, it is the job of the subclass constructor to invoke the superclass constructor • This is done through the keyword called “super”. (We will see an example of “super” shortly). • Therefore, if a subclass does not have any constructor, java simply invokes the default constructor of the subclasses and superclasses • When the superclass does not have constructor, only the constructor of the subclass is invoked and the default constructor of superclass is called • So the only interesting case is to understand the role of “super” keyword when both subclass and superclass define one or more constructors

The subclass can call a constructor defined by its superclass using the following statement • super (parameter-list); • where parameter-list specifies which constructor of the superclass should be called • Consider the next example:

class TwoDShape • { double width; • double height; • TwoDShape(double w, double h) • { • width = w; • height = h; • } • } • class Triangle extends TwoDShape • { private String style; • Triangle (String s, double w, double h) • { • super(w,h); • style = s; • } • } class Shapes { public static void main(String args[ ]) { Triangle t1 = new Triangle(“isosceles”, 4.0, 4.0); Triangle t2 = new Triangle(“right”, 8.0,12.0); } }

Using “super” to Access superclass Members • There is also another version of “super” that acts like the “this” keyword • The “this” keyword refers to the attributes specialized by the subclass and “super” refers to attributes inherited by the class • This is used as follows: • super.member • When member is either a method or an attribute inherited by the class • This form of super is most applicable to situations in which member name of a subclass hides members by the same name in the superclass

class A { int i; } class B extends A { int i; B (int a, int b) { super.i = a; i = b; } void show() { System.out.println("i in superclass: " + super.i); System.out.println("i in subclass: " + i); } } class useSuper { public static void main (String args[ ]) { B subOb = new B(1,2); subOb.show(); } } Output -------- i in superclass: 1 i in subclass: 2

Method Overriding • When a method in a subclass has the same name and type signature as a method in its superclass, the method in the subclass is said to override the method inherited from its superclass • This is different from method overloading where methods have the same name but their signature (parameter list and return type) are different • When an overridden method is called from within a subclass, it will always refer to the version of the method defined by the subclass

class A { int i, j; A(int a, int b) { i = a; j = b; } void show() { System.out.println("i and j: " + i + " " + j); } } class B extends A { int k; B(int a, int b, int c) { super(a, b); k = c; } void show() {System.out.println("k: " + k); } } class Override { public static void main (String args[ ]) { B subOb = new B(1, 2, 3); subOb.show(); // THIS CALLS B's SHOW() function } }

Note that when show() method is invoked on an object of type B, the version of show() inside B overrides the version in A • If you need to invoke the version of show() inherited in class B, you need to use the super operator • super.show(); • class B extends A • { • int k; • B(int a, int b, int c) • { • super(a, b); • k = c; • } • void show() • { super.show(); // THIS CALLS A’s show() • System.out.println("k: " + k); • } • }

Polymorphism • Method overriding forms the basis for the concept of “Dynamic Method Dispatch” in java. • Dynamic Method Dispatch is the mechanism by which a call to an overridden method is resolved at run time rather than at compile time. • Java implements run-time polymorphism through Dynamic Method Dispatch. • When a reference object of a subclass is assigned to a reference object of its superclass, the overridden methods get polymorphic behavior. • This means, if through the object reference of the superclass an overridden method is called, java determines which version of that method to execute based on the type of object reference assigned to the object reference of the superclass.

class ClassA { int x, y; void show() { System.out.println(“This is show() in superclass”);} } class ClassB extends ClassA { int z; void show() { System.out.println(“This is show() in subclass”);} } class Shapes { public static void main(String args[ ]) { ClassA objA = new ClassA(); objA.show(); ClassB objB = new ClassB(); objA = objB; objA.show(); } } Output ---------- This is show() in superclass This is show() in subclass

After the statement • ClassA objA = new ClassA(); • objA.show(); • The show method in classA is called as expected. This is an example of non-polymorphic behavior because method invocation can be resolved at compile time • Now consider the following: • ClassB objB = new ClassB(); • objA = objB; • objA.show(); • In this case, the objA reference takes the reference objB. Now the statement objA.show() will call the show() method overridden in ClassB. • This is an example of polymorphic behavior because method invocation is resolved at run time and not at compile time

Abstract Methods and Abstract Classes • It is possible to create a superclass that only defines a generalized form that will be shared by all of its subclasses • Such a class should be declared as abstract • The abstract class determines the nature of the methods that the subclasses must implement but does not itself provide an implementation for some of its methods • We really should make a class as abstract if the class is unable to create a meaningful implementation for a method

Also, it is possible to make a method as an abstract method by specifying abstract type modifier. • An abstract method contains no body and therefore not implemented by the superclass • Therefore, a subclass must override it. It cannot simply use the version defined in the superclass • The general form of declaring an abstract method is: • abstract type name (parameter-list); • Note that no body for the method is presented • The abstract method can only be applied to normal methods and not to static methods or constructors

To make a class abstract, we need to precede its class declaration with the abstract modifier. • abstract class classA • { • …… • } • It is not possible to create an object of an abstract class. • It is only possible to create object reference for an abstract class for the purpose of polymorphism • It is important to remember that when a subclass inherits an abstract class, it must implement all of the abstract methods in the superclass

abstract class TwoDShape { private double width; private double height; private String name; TwoDShape() { width = height = 0.0; name = "null"; } TwoDShape(double w, double h, String n) {width = w; height = h; name = n;} double getWidth(){return width;} void setWidth(double w) { width = w; } double getHeight(){return height;}void setHeight(double h) { height = h; } void showDim() {System.out.println("Width and Height are " + width + " and " + height);}; abstract double area(); // Now area() is abstract } class Triangle extends TwoDShape { private String style; Triangle ( ) { super(); style = "null";} Triangle(String s, double w, double h){ super(w,h, "triangle"); style = s; } double area(){return (getWidth()*getHeight())/2.0;} }

class AbsShape { public static void main(String args[ ]) { double TheArea; //THE NEXT STATEMENT PRODUCES COMPILE //ERROR BECAUSE IT IS NOT POSSIBLE TO INSTANTIATE //AN OBJECT FROM AN ABSTRACT CLASS /*TwoDShape shape = new TwoDShape(); */ TwoDShape shape1; //THIS IS OK. CAN CREATE a REFERENCE //TO AN ABSTRACT CLASS Triangle t1 = new Triangle("right", 8.0, 12.0); shape1 = t1; t1.showDim(); //showDim DOES NOT HAVE TO BE //OVERRIDDEN BECAUSE IT IS NOT abstract TheArea = shape1.area(); //ABSTRACT METHOD area() HAS TO //BE OVERRIDDEN BECAUSE IT IS AN //ABSTRACT METHOD System.out.println("The area of the triangle is: " + TheArea); } }

Using Final • Although method overriding and inheritance are very powerful tools, in some occasions programmers may like to prevent them for some special classes. • For example, you may have a class that controls configuration of some hardware devices and you do not want any polymorphism attached to any methods of this class • Simply attach “final” modifier at the start of the class declaration • final class classA • { • …. • }

Further, methods declared as final cannot be overridden • Consider the following example: • class classA • { • final void meth() • { • System.out.println(“This is a final method”); • } • } • class classB extends ClassA • { • void meth() • { // THIS PRODUCES COMPILE ERROR • System.out.println(“illegal”); • } • } • Because meth() is declared final, it cannot be overridden in ClassB. If you attempt to do so, a compile-time error will result.

In general, by making a method to be a final method, we stop that method from being overridden. • If you make a class final, we stop that class from being inherited • If an attribute is declared final, that attribute is initialized at class level and its value cannot be changed

class ErrMsg { final int OUTERR = 0; final int INERR = 1; final int DISKERR = 2; final int INDEXERR = 3; String msg[ ] = {"Output Error", "Input Error", "Disk Full", "Index Out-Of-Bounds"}; String getErrorMsg(int i) { if (i>=0 && i<msg.length) return msg[i]; else return "Invalid Error Code"; } } class FinalDemo2 { public static void main(String args[]) { ErrMsg err = new ErrMsg(); System.out.println(err.getErrorMsg(err.OUTERR)); System.out.println(err.getErrorMsg(err.DISKERR)); } }

Inheritance and Polymorphism