Inheritance and Polymorphism

Inheritance One of the fundamental object-oriented design techniques. Advantages: Code sharing. To minimize duplication. To maintain update consistency.

Example Person Name SSN Sex Date of birth Marital status if married or widowed a. Date of marriage b. Number of children if divorced a. Date of divorce b. First divorce if single a. Independent residency

Use only one class Person Name SSN Sex Date of birth Marital status Date of marriage Number of children Date of divorce First divorce Independent residency Some operations Waste memory space

Use 3 independent classes Married Name SSN Sex Date of birth Marital status Date of marriage Number of children Some operations Divorced Name SSN Sex Date of birth Marital status Date of divorce First divorce Some operations Single Name SSN Sex Date of birth Marital status Independent residency Some operations Can’t share methods Any change must be done 3 times

Use inheritance Person Name SSN Sex Date of birth Marital status Some operations Married Date of marriage Number of children Divorced Date of divorce First divorce Single Independent residency

Deriving Classes class classname extends parent-class { [variable declaration;] [method declaration;] } Deriving Classes Superclass (Base/parent class) subclass extends superclass A subclass is A superclass Subclass (Derived class) Inheritance is used to model the Is-A relationship. Inheritance - inherits fields and methods of its superclass. Advantage of inheritance: Code reuse

Overriding Methods A child class can override the definition of an inherited method in favor of its own That is, a child can redefine a method that it inherits from its parent The new method must have the same signature as the parent's method, but can have different code in the body The type of the object executing the method determines which version of the method is invoked

Method Overriding class A { // Base class int method1() { …} float method2(int x) { …} } class B extends A { // subclass float method2(int z) { …} void method3() { …}

A method overriding error class A { // Base class int method1() { …} float method2(int x) { …} } class B extends A { // subclass char method2(int z) { …} void method3() { …} If the argument types match, the return type must match also

Overloading vs. Overriding Overloading deals with multiple methods in the same class with the same name but different signatures Overriding deals with two methods, one in a parent class and one in a child class, that have the same signature Overloading lets you define a similar operation in different ways for different data Overriding lets you define a similar operation in different ways for different object types

The super and this references super: reserved word used in a derived class to refer to its parent class allows us to access those members of the parent class that are not inherited example: invoking the parent’s constructor class A { // Base class f(int x) { …} } class B extends A { // subclass f(int z) { …} … super.f(); this.f(); // same as f();

Polymorphism Literally polymorphism is: multiple forms. In programming, polymorphism means: one interface, multiple implementations of a method (overriding). Which implementation of the method actual called depends on the type of the object passed to the method. Advantage: Can write generic code that can be applied to different kinds of objects. In Java, polymorphism is implemented using a technique called dynamic (or late) method binding: which exact method to call is determined at run time.

Basis of Polymorphism Inheritance Method overriding Polymorphic assignment Polymorphic methods In Java, all methods are polymorphic. That is, choice of method depends on the object.

Polymorphic assignment SuperClassVariable = SubclassObject;

Example: Polymorphism Furniture void prnt(); abstract class Furniture { public int numlegs; } abstract class Chair extends Furniture { public String fabric; abstract void prnt(); class Recliner extends Chair { void prnt() { System.out.println(“I’m a recliner”); class LaZBoy extends Recliner { System.out.println(“I’m a lazboy”); Chair void prnt(); Recliner void prnt(); LaZBoy void prnt(); What is the output? Chair cha; cha = new LaZBoy(); cha.prnt(); Furniture furn; furn = new Recliner(); furn.prnt(); Furniture furn; furn = new LaZBoy(); furn.prnt();

Example: Polymorphism Furniture void prnt(); void display(Furniture furn) { furn.prnt(); } Chair void prnt(); What is the output? display(new LaZBoy()); Recliner void prnt(); display(new Recliner()); LaZBoy void prnt();

Example: Polymorphism class Queue { Object e; public String toString() { String Str = “”; for every element e in the queue Str += e.toString() + “ “; return Str; } Object String toString(); Token Operator String toString(); Operand String toString();

Members use compile-time binding class Base{ int X=99; public void prnt(){ System.out.println("Base"); } class Rtype extends Base{ int X=-1; System.out.println("Rtype"); What is the output? Base b=new Rtype(); System.out.println(b.X); b.prnt();

Homework 1 Show the output of the following program. abstract class Furniture { abstract void prnt();} class Recliner extends Furniture { void prnt() { System.out.println("I'm a recliner");} } class LaZBoy extends Recliner { void prnt() { System.out.println("I'm a lazboy");} public class furnitureTest2 { public static void main(String[] args) { Furniture [] A = { new Recliner(), new Recliner(), new LaZBoy()}; for (int i=0; i<3; ++i) A[i].prnt(); Homework 1

Homework 2 Show the output of the following program. class A { int x = 1; } class B extends A { } class C extends B { int x = 2;} public class classTest { public static void main(String[] args) { A w = new A(); System.out.println(w.x); B u = new B(); System.out.println(u.x); C v = new C(); System.out.println(v.x); A [] a = { new A(), new B(), new C()}; for (int i=0; i<3; ++i) System.out.println(a[i].x); } Homework 2