jedi slides intro1 chapter11 inheritance polymorphism interfaces

8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces

1/40

Introduction to Programming 1 1

11 Inheritance,Polymorphism, Interfaces


2/40


Objectives

At the end of the lesson, the student should be able to:

Define super classes and subclasses

Override methods of superclasses

Create final methods and final classes


3/40


Inheritance

In Java, all classes, including the classes that make up theJava API, are subclassed from the Object superclass.

A sample class hierarchy is shown below.

Superclass Any class above a specific class in the class hierarchy.

Subclass

Any class below a specific class in the class hierarchy.


4/40


Inheritance

Superclass Any class above a specific class in the class hierarchy.

Subclass

Any class below a specific class in the class hierarchy.


5/40


Inheritance

Benefits of Inheritance in OOP : Reusability

Once a behavior (method) is defined in a superclass, that behavioris automatically inherited by all subclasses.

Thus, you can encode a method only once and they can be used byall subclasses.

A subclass only needs to implement the differences between itselfand the parent.


6/40


Inheritance

To derive a class, we use the extends keyword.

In order to illustrate this, let's create a sample parent class.

Suppose we have a parent class called Person.

public class Person {protected String name;protected String address;

/*** Default constructor*/public Person(){

System.out.println(Inside Person:Constructor);name = ""; address = "";

}. . . .

}


7/40


Inheritance

Now, we want to create another class named Student.

Since a student is also a person, we decide to just extendthe class Person, so that we can inherit all the properties

and methods of the existing class Person. To do this, we write,public class Student extends Person {

public Student(){System.out.println(Inside Student:Constructor);

}

. . . .}


8/40


Inheritance

When a Student object is instantiated, the defaultconstructor of its superclass is invoked implicitly to do thenecessary initializations.

After that, the statements inside the subclass are executed.


9/40


Inheritance:

To illustrate this, consider the following code,

In the code, we create an object of class Student. Theoutput of the program is,

public static void main( String[] args ){Student anna = new Student();

}

Inside Person:ConstructorInside Student:Constructor


10/40


Inheritance

The program flow is shown below.


11/40


The super keyword

A subclass can also explicitly call a constructor of itsimmediate superclass.

This is done by using the super constructor call.

A super constructor call in the constructor of a subclass willresult in the execution of relevant constructor from thesuperclass, based on the arguments passed.


12/40


The super keyword

For example, given our previous example classes Personand Student, we show an example of a super constructorcall.

Given the following code for Student,public Student(){

super( "SomeName", "SomeAddress" );System.out.println("Inside Student:Constructor");

}


13/40


The super keyword

Few things to remember when using the super constructorcall:

The super() call MUST OCCUR AS THE FIRST STATEMENT IN ACONSTRUCTOR.

The super() call can only be used in a constructor definition.

This implies that the this() construct and the super() calls CANNOTBOTH OCCUR IN THE SAME CONSTRUCTOR.


14/40


The super keyword

Another use of super is to refer to members of thesuperclass (just like the this reference ).

For example,

public Student() {super.name = somename;super.address = some address;

}


15/40


Overriding methods

If for some reason a derived class needs to have a differentimplementation of a certain method from that of thesuperclass, overriding methods could prove to be veryuseful.

A subclass can override a method defined in its superclassby providing a new implementation for that method.


16/40


Example

Suppose we have the following implementation for thegetName method in the Person superclass,

public class Person {:

:public String getName(){

System.out.println("Parent: getName");return name;

}}


17/40


Example

To override, the getName method of the superclass Person,we write in the subclass Student,

Now, when we invoke the getName method of an object ofthe subclass Student, the overridden getName methodwould be called, and the output would be,

public class Student extends Person{::

public String getName(){

System.out.println("Student: getName");return name;

}:

}

Student: getName


18/40


Final Classes Final Classes

Classes that cannot be extended

To declare final classes, we write,public final ClassName{

. . .

}

Example:

Other examples of final classes are your wrapper classesand Strings.

public final class Person {. . .

}


19/40


Final Methods and Classes

Final Methods

Methods that cannot be overridden

To declare final methods, we write,public final [returnType] [methodName]([parameters]){

. . .}

Static methods are automatically final.


20/40


Example

public final String getName(){return name;

}


21/40


Polymorphism

Polymorphism

The ability of a reference variable to change behavior according towhat object it is holding.

This allows multiple objects of different subclasses to be treated as

objects of a single superclass, while automatically selecting theproper methods to apply to a particular object based on the subclassit belongs to.

To illustrate polymorphism, let us discuss an example.


22/40


Polymorphism

Given the parent class Person and the subclass Student ofthe previous examples, we add another subclass of Personwhich is Employee.

Below is the class hierarchy for that,


23/40


Polymorphism

In Java, we can create a reference that is of type superclassto an object of its subclass. For example,

public static main( String[] args ) {

Person ref;Student studentObject = new Student();Employee employeeObject = new Employee();

ref = studentObject; //Person reference points to a// Student object

}


24/40


Polymorphism

Now suppose we have a getName method in our superclassPerson, and we override this method in both the subclassesStudent and Employee.

public class Student {

public String getName(){System.out.println(Student Name: + name);return name;

}

}

public class Employee {

public String getName(){System.out.println(Employee Name: + name);

return name;}

}


25/40


Polymorphism

Going back to our main method, when we try to call thegetName method of the reference Person ref, the getNamemethod of the Student object will be called.

Now, if we assign ref to an Employee object, the getNamemethod of Employee will be called.


26/40


Polymorphism1 public static main( String[] args ) {2 Person ref;3 Student studentObject = new Student();4 Employee employeeObject = new Employee();56 ref = studentObject; //Person ref. points to a7 // Student object

89 //getName of Student class is called10 String temp=ref.getName();11 System.out.println( temp );1213 ref = employeeObject; //Person ref. points to an14 // Employee object

1516 //getName of Employee class is called17 String temp = ref.getName();18 System.out.println( temp );19 }


27/40


Abstract Classes

Abstract class

a class that cannot be instantiated.

often appears at the top of an object-oriented programming classhierarchy, defining the broad types of actions possible with objects

of all subclasses of the class.


28/40


Abstract Classes

abstract methods

methods in the abstract classes that do not have implementation

To create an abstract method, just write the method declarationwithout the body and use the abstract keyword

For example,

public abstract void someMethod();


29/40


Sample Abstract Classpublic abstract class LivingThing {

public void breath(){System.out.println("Living Thing breathing...");

}

public void eat(){System.out.println("Living Thing eating...");

}

/*** abstract method walk* We want this method to be overridden by subclasses of* LivingThing*/

public abstract void walk();}


30/40


Abstract Classes

When a class extends the LivingThing abstract class, it isrequired to override the abstract method walk(), or else, thatsubclass will also become an abstract class, and thereforecannot be instantiated.

For example,public class Human extends LivingThing {

public void walk(){System.out.println("Human walks...");

}

}


31/40


Coding Guidelines

Use abstract classes to define broad types of behaviors atthe top of an object-oriented programming class hierarchy,and use its subclasses to provide implementation details ofthe abstract class.


32/40


Interfaces

An interface

is a special kind of block containing method signatures (and possiblyconstants) only.

defines the signatures of a set of methods, without the body.

defines a standard and public way of specifying the behavior ofclasses.

allows classes, regardless of their locations in the class hierarchy, toimplement common behaviors.

NOTE: interfaces exhibit polymorphism as well, since program maycall an interface method, and the proper version of that method willbe executed depending on the type of object passed to the interfacemethod call.


33/40

Introduction to Programming 133

Interfaces

Differences between an interface and an abstract class:

In an interface, all methods do not have a body and you can onlydefine constants. (an interface is not a class)

For abstract classes, they are just like ordinary class declarations,

with some abstract methods.

Interfaces have no direct inherited relationship with any particularclass, they are defined independently.


34/40


Interfaces

To create an interface we write,

public interface [InterfaceName]{

//some methods without the body}


35/40


Interfaces

As an example, let's create an interface that definesrelationships between two objects according to the naturalorder of the objects.

public interface Relation

{public boolean isGreater( Object a, Object b);public boolean isLess( Object a, Object b);public boolean isEqual( Object a, Object b);

}


36/40


Interfaces To use an interface, we use the implements keyword. For example,

1 /**2 * This class defines a line segment3 */

4 public class Line implements Relation5 {6 private double x1;7 private double x2;8 private double y1;9 private double y2;1011 public Line(double x1,double x2,double y1,double y2{12 this.x1 = x1;13 this.x2 = x2;14 this.y1 = y1;15 this.y2 = y2;16 }


37/40


Interfaces17 public double getLength(){18 double length = Math.sqrt( (x2-x1)*(x2-x1) +19 (y2-y1)*(y2-y1));20 return length;21 }2223 public boolean isGreater( Object a, Object b){

24 double aLen = ((Line)a).getLength();25 double bLen = ((Line)b).getLength();26 return (aLen > bLen);27 }2829 public boolean isLess( Object a, Object b){30 double aLen = ((Line)a).getLength();31 double bLen = ((Line)b).getLength();

32 return (aLen < bLen);33 }


38/40


Interfaces

34 public boolean isEqual( Object a, Object b){35 double aLen = ((Line)a).getLength();36 double bLen = ((Line)b).getLength();37 return (aLen == bLen);

38 }39 }


39/40


40/40

jedi slides intro1 chapter11 inheritance polymorphism interfaces

Documents