-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
1/40
Introduction to Programming 1 1
11 Inheritance,Polymorphism, Interfaces
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
2/40
Introduction to Programming 1 2
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
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
3/40
Introduction to Programming 1 3
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
4/40
Introduction to Programming 1 4
Inheritance
Superclass Any class above a specific class in the class hierarchy.
Subclass
Any class below a specific class in the class hierarchy.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
5/40
Introduction to Programming 1 5
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
6/40
Introduction to Programming 1 6
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 = "";
}. . . .
}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
7/40
Introduction to Programming 1 7
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/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
8/40
Introduction to Programming 1 8
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
9/40
Introduction to Programming 1 9
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
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
10/40
Introduction to Programming 1 10
Inheritance
The program flow is shown below.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
11/40
Introduction to Programming 1 11
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
12/40
Introduction to Programming 1 12
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");
}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
13/40
Introduction to Programming 1 13
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
14/40
Introduction to Programming 1 14
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;
}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
15/40
Introduction to Programming 1 15
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
16/40
Introduction to Programming 1 16
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;
}}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
17/40
Introduction to Programming 1 17
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
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
18/40
Introduction to Programming 1 18
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 {. . .
}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
19/40
Introduction to Programming 1 19
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
20/40
Introduction to Programming 1 20
Example
public final String getName(){return name;
}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
21/40
Introduction to Programming 1 21
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
22/40
Introduction to Programming 1 22
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,
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
23/40
Introduction to Programming 1 23
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
}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
24/40
Introduction to Programming 1 24
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;}
}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
25/40
Introduction to Programming 1 25
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
26/40
Introduction to Programming 1 26
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 }
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
27/40
Introduction to Programming 1 27
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
28/40
Introduction to Programming 1 28
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();
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
29/40
Introduction to Programming 1 29
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();}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
30/40
Introduction to Programming 1 30
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...");
}
}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
31/40
Introduction to Programming 1 31
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
32/40
Introduction to Programming 1 32
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
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.
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
34/40
Introduction to Programming 134
Interfaces
To create an interface we write,
public interface [InterfaceName]{
//some methods without the body}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
35/40
Introduction to Programming 135
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);
}
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
36/40
Introduction to Programming 136
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 }
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
37/40
Introduction to Programming 137
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 }
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
38/40
Introduction to Programming 1 38
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 }
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
39/40
-
8/14/2019 JEDI Slides Intro1 Chapter11 Inheritance Polymorphism Interfaces
40/40