Java Inheritance PDF
Java Inheritance PDF
Java Inheritance PDF
http://www.tutorialspoint.com/java/java_inheritance.htm
Copyright tutorialspoint.com
Inheritance can be defined as the process where one class acquires the properties methodsandfields
of another. With the use of inheritance the information is made manageable in a hierarchical
order.
The class which inherits the properties of other is known as subclass derivedclass, childclass and the
class whose properties are inherited is known as superclass baseclass, parentclass.
extends Keyword
extends is the keyword used to inherit the properties of a class. Below given is the syntax of
extends keyword.
class Super{
.....
.....
}
class Sub extends Super{
.....
.....
}
Sample Code
Below given is an example demonstrating Java inheritance. In this example you can observe two
classes namely Calculation and My_Calculation.
Using extends keyword the My_Calculation inherits the methods addition and Subtraction of
Calculation class.
Copy and paste the program given below in a file with name My_Calculation.java
class Calculation{
int z;
public void addition(int x, int y){
z=x+y;
System.out.println("The sum of the given numbers:"+z);
}
public void Substraction(int x,int y){
z=x-y;
System.out.println("The difference between the given numbers:"+z);
}
}
public class My_Calculation extends Calculation{
public void multiplication(int x, int y){
z=x*y;
System.out.println("The product of the given numbers:"+z);
}
public static void main(String args[]){
int a=20, b=10;
My_Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Substraction(a, b);
demo.multiplication(a, b);
}
}
In the given program when an object to My_Calculation class is created, a copy of the contents of
the super class is made with in it. That is why, using the object of the subclass you can access the
members of a super class.
The Superclass reference variable can hold the subclass object, but using that variable you can
access only the members of the superclass, so to access the members of both classes it is
recommended to always create reference variable to the subclass.
If you consider the above program you can instantiate the class as given below as well. But using
the superclass reference variable ( cal in this case ) you cannot call the method multiplication,
which belongs to the subclass My_Calculation.
Calculation cal=new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
Note: A subclass inherits all the members fields, methods, andnestedclasses from its superclass.
Constructors are not members, so they are not inherited by subclasses, but the constructor of the
superclass can be invoked from the subclass.
below.
super.variable
super.method();
Sample Code
This section provides you a program that demonstrates the usage of the super keyword.
In the given program you have two classes namely Sub_class and Super_class, both have a
method named display with different implementations, and a variable named num with different
values. We are invoking display method of both classes and printing the value of the variable num
of both classes, here you can observe that we have used super key word to differentiate the
members of super class from sub class.
Copy and paste the program in a file with name Sub_class.java.
class Super_class{
int num=20;
//display method of superclass
public void display(){
System.out.println("This is the display method of superclass");
}
}
public class Sub_class extends Super_class {
int num=10;
//display method of sub class
public void display(){
System.out.println("This is the display method of subclass");
}
public void my_method(){
//Instantiating subclass
Sub_class sub=new Sub_class();
//Invoking the display() method of sub class
sub.display();
//Invoking the display() method of superclass
super.display();
//printing the value of variable num of subclass
System.out.println("value of the variable named num in sub class:"+ sub.num);
//printing the value of variable num of superclass
System.out.println("value of the variable named num in super class:"+ super.num);
}
public static void main(String args[]){
Sub_class obj = new Sub_class();
obj.my_method();
}
}
Compile and execute the above code using the following syntax.
javac Super_Demo
java Super
Sample Code
The program given in this section demonstrates how to use the super keyword to invoke the
parametrized constructor of the superclass. This program contains a super class and a sub class,
where the super class contains a parametrized constructor which accepts a string value, and we
used the super keyword to invoke the parametrized constructor of the super class.
Copy and paste the below given program in a file with name Subclass.java
class Superclass{
int age;
Superclass(int age){
this.age=age;
}
public void getAge(){
System.out.println("The value of the variable named age in super class is: " +age);
}
}
public class Subclass extends Superclass {
Subclass(int age){
super(age);
}
public static void main(String argd[]){
Subclass s= new Subclass(24);
s.getAge();
}
}
Compile and execute the above code using the following syntax.
javac Subclass
java Subclass
IS-A Relationship:
IS-A is a way of saying : This object is a type of that object. Let us see how the extends keyword is
Now, based on the above example, In Object Oriented terms, the following are true:
Animal is the superclass of Mammal class.
Animal is the superclass of Reptile class.
Mammal and Reptile are subclasses of Animal class.
Dog is the subclass of both Mammal and Animal classes.
Now, if we consider the IS-A relationship, we can say:
Mammal IS-A Animal
Reptile IS-A Animal
Dog IS-A Mammal
Hence : Dog IS-A Animal as well
With use of the extends keyword the subclasses will be able to inherit all the properties of the
superclass except for the private properties of the superclass.
We can assure that Mammal is actually an Animal with the use of the instance operator.
Example
class Animal{
}
class Mammal extends Animal{
}
class Reptile extends Animal{
}
public class Dog extends Mammal{
public static void main(String args[]){
Animal a = new Animal();
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
}
true
true
Since we have a good understanding of the extends keyword let us look into how the implements
keyword is used to get the IS-A relationship.
The implements keyword is used by classes by inherit from interfaces. Interfaces can never be
extended by the classes.
Example
public interface Animal {
}
public class Mammal implements Animal{
}
public class Dog extends Mammal{
}
HAS-A relationship
These relationships are mainly based on the usage. This determines whether a certain class HASA certain thing. This relationship helps to reduce duplication of code as well as bugs.
Lets us look into an example:
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle{
private Speed sp;
}
This shows that class Van HAS-A Speed. By having a separate class for Speed, we do not have to
put the entire code that belongs to speed inside the Van class., which makes it possible to reuse
the Speed class in multiple applications.
In Object-Oriented feature, the users do not need to bother about which object is doing the real
work. To achieve this, the Van class hides the implementation details from the users of the Van
class. So basically what happens is the users would ask the Van class to do a certain action and the
Van class will either do the work by itself or ask another class to perform the action.
Types of inheritance
There are various types of inheritance as demonstrated below.
A very important fact to remember is that Java does not support multiple inheritance. This means
that a class cannot extend more than one class. Therefore following is illegal:
public class extends Animal, Mammal{}
However, a class can implement one or more interfaces. This has made Java get rid of the
impossibility of multiple inheritance.
Loading [MathJax]/jax/output/HTML-CSS/jax.js