inheritance
DESCRIPTION
Inheritance. Inheritance is a fundamental object-oriented technique it enhances software design and promotes reuse We will focus on: deriving new classes creating class hierarchies the protected modifier polymorphism via inheritance. The Three Pillars of OOP. Encapsulation - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/1.jpg)
Inheritance Inheritance is a fundamental object-oriented technique
it enhances software design and promotes reuse
We will focus on: deriving new classes
creating class hierarchies
the protected modifier
polymorphism via inheritance1
![Page 2: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/2.jpg)
The Three Pillars of OOP
Encapsulation
Inheritance
Polymorphism
Every class in Java extends some other class.
2
![Page 3: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/3.jpg)
Inheritance
If you don't explicitly specify the class that your new class extends
it automatically extend the class Object.
3
![Page 4: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/4.jpg)
Encapsulation - By creating class e Student -
and storing in it all the variables and methods
associated with a student we are:
Encapulating in the Student class
All data pertaining to a student in one place
4
![Page 5: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/5.jpg)
Class Hierarchy
Java uses a class hierarchy class hierarchy to organize its classes. All classes in Java exist in a class hierarchy
The Object class Object class forms the root of the hierarchy. forms the root of the hierarchy.
5
![Page 6: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/6.jpg)
OBJECT CLASS
Some classes extend extend Object directlyObject directly,
while other classes are subclasses of Objectsubclasses of Object further down the hierarchy.
The Object class contains methods that are inherited by
all its child classes
6
![Page 7: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/7.jpg)
Inheritance allows a software developer to derive a new class from an existing one
The existing class is called the parent class, or
superclass, or base class
The derived class The derived class is called the child class or subclass.
7
![Page 8: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/8.jpg)
8
Object classObject class
Child classChild class
PARENTPARENT
Child Child
PARENT CHILD RELATIONSHIPPARENT CHILD RELATIONSHIP
UML OR Unified Modeling Language is used to model UML OR Unified Modeling Language is used to model an application’s structures, behavior and even business an application’s structures, behavior and even business
processesprocesses
![Page 9: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/9.jpg)
Inheritance
The child inherits characteristics of the parent.
The child class inherits the methods and datamethods and data defined in the parent class
This means that all child classes have access to the methods and data.
9
![Page 10: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/10.jpg)
Inheritance relationships are shown in a UML class diagram as solid arrow with an unfilled triangular arrowhead pointing to the parent class
10
Vehicle
Car
Inheritance creates an is-a relationship,
meaning the child is a more specific version of the parent
![Page 11: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/11.jpg)
Class Car is a subclass of Vehicle and
It inherits state and behavior from its parent
An object’s object’s statestate is in the form of instance variables
its behaviorbehavior in the form of methods.
The child inherits both from all of its ancestors.
11
![Page 12: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/12.jpg)
12
Class VehicleClass Vehicle extends extends ObjectObject // not necessary // not necessary{{ // data// data
// methods ( functions)// methods ( functions) }}
Class Car Class Car extends Vehicleextends Vehicle{{ // data - -
// methods ( functions)// methods ( functions)
//some data and methods can be inherited from Vehicle//some data and methods can be inherited from Vehicle
}}
![Page 13: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/13.jpg)
13
ClassVehicle
Method 1
Method 2
Method 3
Class CarInherits all of the above methods and
can add methods of its own
![Page 14: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/14.jpg)
CODE REUSE
A programmer can tailor a child class by :
adding new variables or methods,
or by modifying the inherited ones
Software reuse Software reuse is the fundamental benefit of inheritancefundamental benefit of inheritance
14
![Page 15: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/15.jpg)
CODE REUSE
We can create new software by reusing existing software components to create new
ones,
we capitalize on all the effort we capitalize on all the effort spent on the design,
15
![Page 16: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/16.jpg)
16
Class Accountdeposit()
Class SavingsAcco
untInherits
deposit ()
Class SeniorAccount
Inherits deposit()
![Page 17: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/17.jpg)
Inheritance
///*************MOST IMPORTANT******
When changes are made on the parent information,
all child classes automatically are changed also.
.
17
![Page 18: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/18.jpg)
CODE REUSE Thus the models that are created are :Thus the models that are created are :
easier to modify and easier to modify and
easier to implementeasier to implement
18
![Page 19: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/19.jpg)
Concepts to Review WHAT IS AN “ISA” Relationship?
What is Encapsulation?
What are the benefits of Inheritance?
What does “Code Reuse” mean in terms of efficiency?
What effect does a code change in the parent class have on a child class?
19
![Page 20: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/20.jpg)
T he reserved word extends sets up an inheritance relationship
To declare a subclass you would write:
class subclass extends SuperClass { . . . } or,
class Dictionary extends Book{…}
A Java class can have only one direct superclass.
20
![Page 21: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/21.jpg)
Sub or Child Classes
class ParentClass // the super class{ protected int num; // instance variable
public ParentClass(int num) // constructor { this. num = num;}
21
![Page 22: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/22.jpg)
class ParentClass{ protected int num; // instance variable
public ParentClass (int num) // constructor// constructor { this. num = num;
}
*******************************************class ChildClass extends ParentClass {
private float num1; // instance variable
public ChildClass(int newnum, float num1) // Constructor {
super(newnum); // calls parent class constructor this.num1 = num1;
}} 22
![Page 23: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/23.jpg)
Using super
The child class inherits the varible num declared in the parent class ?
How does the child class set up a value for the variable num it inherits?
23
![Page 24: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/24.jpg)
INHERITANCE
TO create an instance of the Childclass we use:
Childclass child = new Childclass ( 20, 30);
How does it set up memory for the variable “num ‘ it inherits?
24
![Page 25: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/25.jpg)
We create a child object :Childclass child = new Childclass ( 20, 30);
In the first line of the child’s constructor,
public ChildClass(int newnum, float num1) // child Constructor { // it calls the parent class constructor with this code super(newnum); // calls parent class constructor
This is the parent class constructor
public ParentClass (int num) // constructor// constructor { this. num = num;
}// So the value in newnum is stored in the parent class num 25
![Page 26: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/26.jpg)
Deriving Subclasses
In Java, we use the reserved word extends to establish an inheritance relationship
class Car extends Vehicle{
// class contents
}
26
![Page 27: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/27.jpg)
Controlling Inheritance Visibility modifiers
determine which class members get inherited
Variables and methods declared with public visibility are inherited, and
those with private visibility are not
27
![Page 28: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/28.jpg)
PROTECTED VISIBILITY MODIFIER But public instance variables violate our goal of
encapsulation
(DO NOT USE THEM IN THIS COURSE!!!)
SO -------
There is a third visibility modifier : protected
28
![Page 29: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/29.jpg)
The protected Modifier
The protected visibility modifier allows a
member of a base class to be inherited into the child class
Encapsulation requires that we protect our protect our instance variables from outside access.
29
![Page 30: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/30.jpg)
30
Accessibility Summary
Modifier on members in a class
Accessed from the same class
Accessed from the same class clpackage
Accessed from a subclass
Accessed from a different package
public
protected -
default - -
private - - -
![Page 31: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/31.jpg)
Class Book//-------------------------------------------------------------------// Class Book serves as a parent class for class Dictionary//-------------------------------------------------------------------class Book { protected int pages = 1500;//========================================// Prints a message using the value of an instance variable.//======================================== public void page_message () { System.out.println ("Number of pages: " + pages); } // method page_message} // class Book
31
![Page 32: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/32.jpg)
//-------------------------------------------------------------------
class Dictionary extends Book { private int definitions = 52500; //========================================= // Prints an instance variable declared in this class and // an instance variable one that it inherited from Book//======================================
public void definition_message () {
System.out.println ("# of definitions: " + definitions); System.out.println ("Definitions per page: " + definitions/pages); } // method definition_message} // class Dictionary
32
![Page 33: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/33.jpg)
Class Words//=====================================// Instantiates a child class and calls its inherited methods.//===================================== public static void main (String[] args) { // create object of Dictionary class(child of Word Class) Dictionary webster = new Dictionary ();
webster.page_message(); // method defined in Book class webster.definition_message(); //method in Dictionary class } // method main} OUTPUT: “ “ Number of pages: 1500”Number of pages: 1500” “ “ # of definitions: 52500/1500 Definitions per page: "# of definitions: 52500/1500 Definitions per page: " 33
![Page 34: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/34.jpg)
Default Constructor In the previous slide, we created an object of the
Dictionary class.
Dictionary webster = new Dictionary ();
But the Dictionary class has no coded constructor.
How can this be? All classes must have a constructor
34
![Page 35: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/35.jpg)
default constructor
Answer:
The default constructor is called if a class has no coded constructor.
This happens when instance variables already have a value.
So no constructor is needed.
35
![Page 36: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/36.jpg)
The Super Reference
Constructors are Constructors are not inheritednot inherited, ,
even though they have even though they have public public visibilityvisibility !!!! !!!!
So we need to call the So we need to call the parent class constructor parent class constructor
to give values to to give values to the instance variables the instance variables in the parent classin the parent class
To do this, we use The “To do this, we use The “super”super” reference . reference .36
![Page 37: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/37.jpg)
The The supersuper reference reference
The The supersuper reference in a child constructor reference in a child constructor
calls the parent class constructor. calls the parent class constructor.
The call must made in The call must made in first line first line of the constructorof the constructor
e.g super(parameters)
37
![Page 38: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/38.jpg)
//----------------------------------------------------------// Class Book ‘s constructor initializes pages.// Instance variable “pages” has no value to start//------------------------------------------------------------class Book 2{ protected int pages; // instance variable
//---------------------------------------------------------------- // Sets up a book with the specified number of pages. //----------------------------------------------------------------public Book 2(int num_pages) { pages = num_pages; // sets number of pages } // constructor Book} // class Book2
38
![Page 39: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/39.jpg)
//=======================================// //prints out the number of pages in a book
//======================================= public void page_message () {
System.out.println ("Number of pages: " + pages);
} // method page_message // Close class Book2
39
![Page 40: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/40.jpg)
//------------------------------------------------------------------------------------------- // Class Dictionary demonstrates the interaction between the constructors of
parent and child classes.// __________________________________________________ class Dictionary2 extends Book 2{ private int definitions; // child class instance variable //-----------------------------------------------------------------------------------------// CONSTRUCTOR USES the super reference to call parent class Book's
constructor.//_________________________________________________________ public Dictionary2 (int num_pages, int num_definitions) {// “super” calls parent class constructor and sends it the number of pages
super (num_pages); definitions = num_definitions; // sets # of definitions } // constructor Dictionary 40
![Page 41: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/41.jpg)
Dictionary2 class//========================================= // Prints an instance variable declared in this class and // an instance variable one that it inherited from Book//====================================== public void definition_message () { System.out.println ("# of definitions: " + definitions); System.out.println ("Definitions per page: " + definitions/pages); } // method definition_message
NOTE that pages is inherited from the parent class41
![Page 42: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/42.jpg)
//----------------------------------------------------------// Driver class that creates an object of the Dictionary2 class. //------------------------------------------------------------class Words2
{ public static void main (String[] args) { /// Dictionary2 is child of class Book2
Dictionary2 webster = new Dictionary2 (1500, 52500); //webster calls method from the parent Book class webster.page_message(); // webster calls method from Dictionary class webster.definition_message();
} // method main} // class Words2
42
![Page 43: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/43.jpg)
Review I want to create an object of the child class Dictionary2 –
Dictionary2 inherits the number of pages from its parent Book 2
HOW Did I GIVE A VALUE TO the inherited variable Num_Pages?
How do I create an object of Dictionary2?
How many parameters do I use for the constructor ?43
![Page 44: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/44.jpg)
Class Diagram for Words
44
Book2# pages : int
+ pageMessage() : void
Dictionary2- definitions : int
+ definitionMessage() : void
Words2+ main (args : String[]) : void
![Page 45: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/45.jpg)
The Super Reference – Rules - In Words2.java The Dictionary2 class uses the super reference to call
the parent constructor
so that the number of pages can be set.
Java requires that a child class must call the parent class constructor using “super”
IF and ONLY IF the the parent class constructor has parent class constructor has one or more one or more parametersparameters..
45
![Page 46: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/46.jpg)
SUPER and Constructors
This This insuresinsures that the parent class’s that the parent class’s instance variables instance variables are are given given valuesvalues..
If the If the parent class constructor has no parameters, parent class constructor has no parameters,
the the child class is not required to call it. child class is not required to call it.
A A default constructor default constructor is called for the is called for the parent class parent class instead.instead.
46
![Page 47: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/47.jpg)
Key Terms to Review
Visibility modifiers: protected
The Super Reference
47
![Page 48: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/48.jpg)
Super Reference - A review
When we create the constructor for a child class,
we call the constructor for the super class.
This is done in the first line of the sub class constructor
// it initializes the # of pages in parent class variable pages
super(num_pages)
48
![Page 49: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/49.jpg)
OVERLOADED CONSTRUCTORS:
We might have a constructor for a Rectangle class with one parameter
public Rectangle(int width) { .. Initialize instance variables}
49
![Page 50: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/50.jpg)
50
50
Overloaded Constructors Another constructor could be defined by a
Rectangle with two parameters:
public Rectangle(int length, int width) { this.length = length; // shortcut assignment this.width = width }
Both constructors share the same nameshare the same name,,
Rectangle(variables)
but they have different parameter lists.
![Page 51: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/51.jpg)
OVERLOADED CONSTRUCTORS
The compiler determines which constructors to use based on the
number and types of the parameters to the constructor.
E.g // calls a constructor with one parameter Rectangle rect = new Rectangle(20); // requires a constructor with two parameters Rectangle rect2 = new Rectangle(20,30);
51
![Page 52: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/52.jpg)
Overloaded constructors
// calls a constructor with one parameter Rectangle rect = new Rectangle(20); // requires a constructor with two parameters Rectangle rect2 = new Rectangle(20,30);
Each Rectangle object, rect and rect2, call a different constructor
52
![Page 53: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/53.jpg)
5353
Overloading Methods – similar to overloaded Overloading Methods – similar to overloaded constructorsconstructors
Method Method overloadingoverloading is the process of is the process of using the using the same method name same method name for for multiple methods. multiple methods.
The signature of each overloaded method must be unique
The signature is based on the number, type, and order of the parameters.
![Page 54: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/54.jpg)
Method Overloading The compiler determines the version of the
method being invoked by :
analyzing the parameters.
The return type of the method is not part of the signature!
54
![Page 55: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/55.jpg)
5555
Overloading Methods
![Page 56: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/56.jpg)
5656
Overloaded Methods The println method is overloaded: println (String s) println (int i)
println (double d) etc.
The following lines invoke different versions of the println method:
System.out.println ("The total is:");
System.out.println (total);
![Page 57: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/57.jpg)
Overriding Methods
A child class can override the definition of an inherited method in favor of its own.
This is different from the overloading that we used in constructors.
A child class can can redefineredefine a method a method it inherits from its parent.
57
![Page 58: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/58.jpg)
Overriding Methods
The new method must have the same signature as the parent's method,
but can have different code in the body
Same signature = same number and type of parameters etc.
58
![Page 59: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/59.jpg)
//**********************************************// Contains a method that is overridden in a child class.//**********************************************
class Thought { public void message() { System.out.println ("I feel like I'm diagonally parked " +
"in a parallel universe."); } // method message} // class Thought
59
![Page 60: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/60.jpg)
//------------------------------------------------------------------------// Class Advice overrides the message method.// it keeps same method name and number of parameters//____________________________________________class Advice extends Thought {// This method overrides the parent version, public void message() { System.out.println ("Warning: Dates in calendar are " +
"closer than they appear."); } // method message} // class Advice
60
![Page 61: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/61.jpg)
///**********************************************// Driver class that creates objects of parent and child classes. // __________________________________________________class Messages {public static void main (String[] args) { Thought parked = new Thought(); // create Thought object
Advice dates = new Advice();// create Advice object
parked.message(); // calls method in Thought class
dates.message(); // calls method in Advice class
} // method main} // class Messages
61
![Page 62: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/62.jpg)
Overloading vs. Overriding
Don't confuse the concepts of
overloading and overriding
Overloading : deals with multiple methods in the same class
With the same name but with different signatures
62
![Page 63: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/63.jpg)
Overriding vs Overloading
Overriding deals with two methods,
one in a parent class and
one in a child class,
That both have the same signature
63
![Page 64: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/64.jpg)
Overloading VS Overriding
Overloading lets you define a method in different ways
for different data in the same class
Overriding lets you define a method in a child class
that has the same signature as the parent class
But
Implements it differently Implements it differently from the parent classfrom the parent class64
![Page 65: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/65.jpg)
MOST IMPORTANT!!!!
To overload a method in the same class
You must duplicate the method name,
but use a different argument list.
65
![Page 66: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/66.jpg)
OverRiding a method
To override a method,
you must match the entire method signature -
same argument list
AND The method overridden is in the parent class
66
![Page 67: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/67.jpg)
Class Hierarchies
Two children of the same parent are called siblings.
Good class design puts all common features as high in the hierarchy as is possible.
67
![Page 68: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/68.jpg)
Single vs. Multiple Inheritance
Java supports single inheritance, meaning that a derived class can have only one parent class
Multiple inheritance allows a class to be derived from two or more classes,
inheriting the members of all parents’ classes This causes “Collisions”, such as the same variable name in two
parents, have to be resolved
68
![Page 69: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/69.jpg)
The Object Class
The class Object is defined in the java.lang package of the Java standard class library
All classes are derived from the Object class
The ObjectObject class class is therefore the
ultimate root of all class hierarchiesultimate root of all class hierarchies
69
![Page 70: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/70.jpg)
The Object Class The Object class contains a few useful methods, inherited by all classes, e.g.
The toString method in the object class : 1. prints out the name of the class and 2. its memory address (hexadecimal representation of
the hash code of the object)
We override the We override the toStringtoString method method in OUR classes to in OUR classes to output the instance variables in output the instance variables in OUR classOUR class
70
![Page 71: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/71.jpg)
71
Class ObjectClass Object The class Object defines the following methods:
• clone() --we use• equals(Object obj) -- we use• finalize()• getClass() - we use• hashCode() - we use sometimes• notify()• notifyAll()• toString() -- we use• wait()• wait(long timeout)• wait(long timeout, int nanos)
As you can see, this list includes three overloaded versions of the method named wait
![Page 72: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/72.jpg)
Class Object Because every class is
either a direct or indirect subclass of Objectdirect or indirect subclass of Object,
every class in Java inherits these eleven methods. inherits these eleven methods.
Many of these eleven methods are intended to be overridden for various purposes.
However, some of them, such as getClass, notify, and wait, getClass, notify, and wait, are intended to be used directly without overriding. to be used directly without overriding.
72
![Page 73: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/73.jpg)
The super Reference Revisited
A method in the parent class can be invoked explicitly using super.methodName(parameters)
To call a method in the parent class, the syntax is:
super.method(parameters)
73
![Page 74: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/74.jpg)
public class Student{ protected String Firstname, Lastname; protected int numCourses; //----------------------------------------------------------------- // Sets up a student with a name and number of courses. //----------------------------------------------------------------- public Student (String Firstname, String Lastname, int
numCourses) { this.Firstname = Firstname;
this. Lastname = LastName this.numCourses = numCourses; } (con’d)
74
![Page 75: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/75.jpg)
To String method//----------------------------------------------------------------- // Returns information about this student as a string. // Used in System.out.println calls – typical toString //----------------------------------------------------------------- public String toString () { String result = "Student name: " + Firstname + “ “ +
Lastname "\n";
result += "Number of courses: " + numCourses;
return result; }(con’d) 75
![Page 76: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/76.jpg)
//method to compare two objects// Uses String class equals method to do comparison// String class overrides equals method of Object class
public boolean equals(Object other){ boolean result = false;
if (LastName.equals(((Student)other).LastName)) result = FirstName.equals(((Student)other).FirstName); return result; }}
76
![Page 77: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/77.jpg)
public class GradStudent extends Student{ private String source; // instance variables private double rate; //----------------------------------------------------------// Sets up the gradate student using the specified information. Parameters
include values for parent class instance variables//------------------------------------------------------------- public GradStudent (String Fastname, String LastName , int
numCourses, String source, double rate) { // call parent class constructor to initialize its instance variables super (Firstname, Lastname, numCourses);
// initalize this class’s instance variables this.source = source; this.rate = rate; }
77
![Page 78: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/78.jpg)
ToString method//-----------------------------------------------------------------// Returns a description of this graduate student as a string. –
uses super to call parent class toString() and adds some data declared in this class
//----------------------------------------------------------------- public String toString ()
{ // call parent class toString method and store in “result”call parent class toString method and store in “result”
String result = super.toString();
// add instance variables of this class to “result”
result += result += "\nSupport source: " + source + "\n” + "Hourly pay rate: " + rate;
return result; }} 78
![Page 79: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/79.jpg)
class Academia{ //---------------------------------------------------- // Creates objects of two student types, prints some //information
about them, then checks them for equality. //----------------------------------------------------- public static void main (String[] args) { Student susan = new Student ("Susan", “James”, 4);
GradStudent Paul = new GradStudent ("Paul",”McCartney” , 1,“Gov’t”, 10.00);
System.out.println (susan); // uses toString method in Student System.out.println (Paul); // uses toString method in GradStudent // calls equals method in Student which compares last and first names
- if (!susan.equals(Paul)) System.out.println ("These are two different students."); }}
79
![Page 80: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/80.jpg)
OUTPUT FOR Susan & Paul
From the toString method in Student class for object Susan toString() { "Student name: " + Firstname + “ “ + Lastname "\n"; result += "Number of courses: " + numCourses;
Output FOR SUSAN: Susan James Number of courses 4
From the toString method in gradStudent for object PaultoString (){ String result = super.toString(); // invokes parent class toString)( see above)// invokes parent class toString)( see above)
// concatenate instance variables of this class to “result” result += result += "\nSupport source: " + source + "\n” + "Hourly pay rate: " + rate; return result;}
Output for GradStudent PAULPaul McCartney Number of courses 1Support source Gov’t Hourly pay Rate 10.00
80
![Page 81: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/81.jpg)
Grad Student uses parent to String() So the grad student class makes use of the toString
method in the parent class
AND adds new values particular to
the GradStudent class.
81
![Page 82: Inheritance](https://reader036.vdocument.in/reader036/viewer/2022062422/56812fc6550346895d95476f/html5/thumbnails/82.jpg)
REVIEW What is overloading - for Constructors AND class methods
What is overriding
How do they differ
What does equals method in Object class do. What does equals method DO in child classes
What does toString method in Object class return What does toString method implemented in your class
return 82