Upload
truongtu
View
219
Download
0
Embed Size (px)
Citation preview
Pemrograman Lanjut
PTIIK - 2014
Inheritance
Objectives
How inheritance promotes software reusability.
The notions of superclasses and subclasses
To use keyword extends to create a class that
inherits attributes and behaviors from another
class.
To use access modifier protected to give
subclass methods access to superclass
members.
To access superclass members with super.
Introduction - Inheritance
Object oriented languages have a feature called
inheritance.
Inheritance enables you to define a new class
based upon an existing class.
The new class is similar to the existing class, but
has additional member variables and methods.
This makes programming easier because you
can build upon an existing class instead of
starting out from scratch.
Introduction - Inheritance
Software reusability
Create new class from existing class
Absorb existing class’s data and behaviors
Enhance with new capabilities
New class extends Existing class
New class
• More specialized group of objects
• Behaviors inherited from Existing class
– Can customize
• Additional behaviors
Problems with Hacking Code
If you have the source code for a class, you
could copy the code and change it to do what
you wanted. Before object oriented programming
that was what was done. But there are at least
two problems with this:
It is hard to stay organized.
You need to study the original code.
The automatic inheritance mechanism of Java
greatly relieves both of these problems.
Problems with Hacking Code
In diagrams that show inheritance, an
arrow points from the new class to the
class it is based upon. The arrow is
sometimes labeled "is a".
In these notes, clouds represent classes
and rectangles represent objects.
Single Inheritance
The class that is used to define a new class is called a
parent class (or superclass or base class.) The class
based on the parent class is called a child class (or
subclass or derived class.)
In Java, (unlike with humans) children inherit
characteristics from just one parent. This is called single
inheritance. Some languages allow a child to inherit
from more than one parent. This is called multiple
inheritance. With multiple inheritance, it is sometimes
hard to tell which parent contributed what characteristics
to the child (as with humans). Java avoids these
problems by using single inheritance.
Interchangeable Phrases
There are three sets of phrases for describing
inheritance relationships: parent/child,
superclass/subclass , base class/derived class.
Programmers use all three sets interchangeably.
Is-a Relationship
The picture shows a parent class and a child
class. The line between them shows the "is-a"
relationship. The arrow points to the parent class
from the child class. The picture can be read as
"a Ford is-a automobile."
Inheritance is between classes, not between
objects.
A parent class is a blueprint that is followed
when an object is constructed. A child class of
the parent is another blueprint (that looks much
like the original), but with added features. The
child class is used to construct objects that look
like the parent's objects, but with added features.
Objects
The picture shows a parent class and a child class, and
some objects that have been constructed from each.
These objects are shown as rectangles (to convey the
idea that they are more real than the classes, which are
only designs).
Hierarchies
This picture shows a hierarchy of classes. It shows that
"Ford is-a automobile," "Nissan is-a automobile," and that
"VW is-a automobile." It also shows that "Sentra is-a
Nissan."
Superclasses and subclasses
There are two kinds of superclass base on class
hierarchy, i.e. direct superclass and indirect superclass.
The direct superclass is the superclass from which
the subclass explicitly inherits.
An indirect superclass is any class above the direct
superclass in the class hierarchy, which defines the
inheritance relationships between classes.
Characteristics of Inheritance
New class inherits the members of an existing class
Existing class is called the superclass, and the new class is
the subclass.
Subclass normally adds its own fields and methods that are
specific to the subclass.
Subclass is more specific than its superclass and represents a
more specialized group of objects.
Java does not support multiple inheritance (which occurs when
a class is derived from more than one direct superclass).
Unlike properties and methods, the constructors of a
superclass are not inherited in the subclass
Other Example
Superclass Subclasses
Student GraduateStudent, UndergraduateStudent
Shape Circle, Triangle, Rectangle
Loan CarLoan, HomeImprovementLoan, MortgageLoan
Employee Faculty, Staff
BankAccount CheckingAccount, SavingsAccount
Inheritance hierarchy for university
CommunityMembers
Inheritance hierarchy for Shapes
18
Inheritance hierarchy 2D-Shapes Class
Relative Terms
The syntax for deriving a child class from a
parent class is:
class childClass extends parentClass
{
// new characteristics of the child class go here
}
Video Store Example
Using Inheritance
The class Movie is a subclass of Video.
22
• The keyword super refers to the superclass of the class in
which super appears.
• It can be used to call a superclass constructor and a
superclass method.
• The syntax to call a superclass constructor:
super() or super(parameters);
• The statement super() invokes the no-arg constructor of its
superclass, and the statement super(arguments) invokes
the superclass constructor that matches the arguments.
• The statement super() or super(arguments) must appear in
the first line of the subclass constructor.
Using the super Keyword
Using a Super Class's Constructor
The class definition for Video has a constructor that
initializes the member data of Video objects. The class
Movie has a constructor that initializes the data of Movie
objects. The constructor for class Movie looks like this: // constructor
public Movie( String ttl, int lngth, String dir, String
rtng ) {
super(ttl, lngth); // use the super class's constuctor
director = dir;
rating = rtng; // initialize the members new to Movie
}
Note: super() must be the first statement in the subclass's constructor.
The Constructor Invoked by super()
A constructor for a child class always starts with
an invocation of one of the constuctors in the
parent class. If the parent class has several
constructors then the one which is invoked is
determined by matching argument lists.
No-argument Constructor
It looks like there is no need to invoke the parent class's
constructor since all variables are initialized in this one.
However a constructor from the parent class is always
invoked even if you don't explicity ask for it.
The Java compiler regards the above code as
"shorthand" for this:
As always, super() comes first, even if you don't write it
in. If the parent does not have a no-argument constructor,
then using this "shorthand" causes a syntax error.
Instantiating Movie
In the example program, the class definition for Video includes a
constructor, so the default constructor was not automatically
supplied. So the constructor proposed for Movie causes a syntax
error. Let us not use it.
The statement item2.show() calls the show() method of
item2. This method was inherited without change from
the class Video. This is what it looks like:
public void show() {
System.out.println( title + ", " + length + " min.
available:" + avail );
}
It does not mention the new variables that have been
added to objects of type Movie, so nothing new is printed
out.
Overriding Methods
We need a new show() method in the class Movie:
// added to class Movie
public void show() {
System.out.println( title + ", " + length + "
min. available:" + avail );
System.out.println( "dir: " + director + " " +
rating );
}
Now, even though the parent has a show() method the
new definition of show() in the child class will override
the parent's version.
Overriding Methods
A child's method overrides a parent's method when
it has the same signature as a parent method.
Now the parent has its method, and the child has its
own method with the same signature.
(Remember that the signature of a method is the
name of the method and its parameter list.)
An object of the parent type includes the method
given in the parent's definition.
An object of the child type includes the method given
in the child's definition.
Using super in a Child's Method
Sometimes (as in the example) you want a child class to have its
own method, but that method includes everything the parent's
method does.
The Object Class
Remember the rule: every constructor starts out with a
super() constructor. If you don't explicitly put it in, then
the Java compiler automatically puts it in for you.
The Object Class
All classes have a parent class (a super class)
except one. The class at the top of the Java
class hierarchy is called Object. If a class
definition does not specify a parent class then it
automatically has Object as a parent class. The
compiler automatically assumes, for example:
Only One Class Hierarchy
If you define a class that does not explicitly
extend another class, then it automatically
extends Object.
If you define the class so that it extends a
class other than Object, then that class
either extends another class or extends
Object. Now that class in turn must either
extend another class or extend Object.
There is no way to end the chain except by
(ultimately) extending Object.
You might cleverly try to have class A
extend class B, and have class B extend
class A. But this (and other loops) is not
allowed.
protected Members
protected access
Intermediate level of protection between public and
private
protected members accessible by
• superclass members
• subclass members
• Class members in the same package
Subclass access to superclass member
• Keyword super and a dot (.)
Note 1
Methods of a subclass cannot directly access
private members of their superclass.
A subclass can change the state of private
superclass instance variables only through non-
private methods provided in the superclass and
inherited by the subclass (encapsulation).
Note 2
Declaring private instance variables helps
programmers test, debug and correctly modify
systems.
If a subclass could access its superclass’s
private instance variables, classes that inherit
from that subclass could access the instance
variables as well.
This would propagate access to what should be
private instance variables, and the benefits of
information hiding would be lost.
Note 3
The Java compiler sets the superclass of a class
to Object when the class declaration does not
explicitly extend a superclass
Common Error 1
It is a syntax error to override a method with a
more restricted access modifier :
a public method of the superclass cannot become a
protected or private method in the subclass;
a protected method of the superclass cannot become
a private method in the subclass.
Doing so would break the “is-a” relationship in
which it is required that all subclass objects be
able to respond to method calls that are made to
public methods declared in the superclass.
Common Error 2
If a public method could be overridden as a
protected or private method, the subclass
objects would not be able to respond to the same
method calls as superclass objects.
Once a method is declared public in a
superclass, the method remains public for all
that class’s direct and indirect subclasses.
Tugas
Buatlah class sesuai dengan hirarki class di bawah ini
Buat: 2 atribut, 1 method, dan 2 konstruktor pada class
Binatang
Tambahkan pada masing2 class turunan Binatang: 2
atribut, 1 method, 1 konstruktor, dan 1 overriding method
Binatang
Kucing Ayam Sapi
081 331 834 734 / 088 160 127 40