Inheritance and Interfaces

Mrs.M.Nagasuresh
Assistant Professor
Dept of IT
Karpagam Institute of Technology
Inheritance and Interfaces

• Inheritance is a mechanism in Java by which derived class can
borrow the properties of base class and at the same time the
derived class may have some additional properties.It is an
important part of OOPs (Object Oriented Programming system).
• The inheritance can be achieved by incorporating the definition of
one class into another using the keyword extends.
2
Inheritance

One of the key benefits of inheritance is to minimize the amount of
duplicate code in an application by sharing common code amongst
several subclasses.
1. Reusability : The base class code can be used by derived class
without any need to rewrite the code.
2. Extensibility : The base class logic can be extended in the derived
classes.
3. Data hiding : Base class can decide to keep some data private so
that it cannot be altered by the derived class.
4. Overriding : With inheritance, we will be able to override the
methods of the base class so that meaningful implementation of the
base class method can be designed in the derived class 3
Advantages of Inheritance

As we can see in the image, a child inherits the properties from his
father
4
Inheritance Example

Similarly, in Java, there are two classes:
1. Parent class ( Super or Base class)
2. Child class (Subclass or Derived class )
 A class which inherits the properties is known as Child Class
whereas a class whose properties are inherited is known as Parent
class.
5
Inheritance Example

class superclass
{
// superclass data variables
// superclass member functions
}
class subclass extends superclass
{
// subclass data variables
// subclass member functions
}
7
General format & Example for Inheritance
Class A // This is Base class
{
int a=10;
void mark();
}
Class B extends A // This is Derived class
{
String name=“Raja”; // uses properties of A
void grade(); and own properties
}
}

• The inheritance is a mechanism in which the child class is
derived from a parent class.
• This derivation is using the keyword extends.
• The parent class is called base class and child class is called
derived class.
For example
Class A // This is Base class
{
…
}
Class B extends A // This is Derived class
{
… // uses properties of A
}
8
Concept of Super and Sub Classes

• In single inheritance, there is a single child class that inherits
properties from one parent class.
• For example - class A is a base class that is derived from class B.
It is also known as single-level inheritance.
10
Types of Inheritance : Single

• The class which is inherited is called the base class or the
superclass and the class that does the inheriting is called the
derived class or the subclass.
• The method defined in base class can be used in derived class.
There is no need to redefine the method in derived class. Thus
inheritance promotes software reuse.
class nameofSubclass extends superclass
{
variable declarations
method declarations
}
• Note that the keyword extends represents that the properties of
superclass are extended to the subclass. Thus the subclass will now
have both the properties of its own class and the properties that are
inherited from superclass. 11
Types of Inheritance : Single

class A
{
int a;
void set_a(int i)
{
a=i;
}
void show_a()
{
System.out.println("The value of
a= "+a);
}
}
12
Example of Inheritance : Single
class B extends A
//extending the base class A
{
int b;
void set_b(int i)
{
b=i;
}
void show_b()
{
b= "+b);
}
void mul()
{
int c;
c=a*b;
System.out.println(" The value of c=
"+c);
}
}

13
Example of Inheritance : Single
class Single
{
public static void main(String args[])
{
B obj_B=new B();
obj_B.set_a(10);
obj_B.set_b(20);
obj_B.show_a();
obj_B.show_b();
obj_B.mul();
}
}
Output
F:>javac Single.java
F:>java Single
The value of a= 10
The value of b= 20
The value of c= 200
Note that object of class B is
accessing method of class A

14
Exercise
Write a java program to calculate area of rectangle using the
single inheritance.
Exercise:1

• In Multiple inheritance, When a derived class is derived from a
base class which itself is a derived class then that type of
inheritance is called multilevel inheritance.
• For example - class A is a base class and class B is another class
which is derived from A, similarly there is another class C being
derived from class B then such a derivation leads to multilevel
inheritance.
15
Types of Inheritance : Multilevel

class A
{
int a;
void set_a(int i)
{
a=i;
}
void show_a()
{
a= "+a);
}
}
16
Example of Inheritance : Multilevel
class B extends A
{
int b;
void set_b(int i)
{
b=i;
}
void show_b()
{
System.out.println("The value
of b= "+b);
}
}

17
Example of Inheritance : Multilevel
class C extends B
{
int c;
void set_c(int i)
{
c=i;
}
void show_c()
{
System.out.println("The value of c=
"+c);
}
void mul()
{
int ans;
ans=a*b*c;
System.out.println(" The value of
ans= "+ans);
}
}
class Multilevel
{
{
C obj_C=new C();
obj_C.set_a(10);
obj_C.set_b(20);
obj_C.set_c(30);
obj_C.show_a();
obj_C.show_b();
obj_C.mul();
}
}
Output
F:>javac Multilevel.java
F:>java Multilevel
The value of a= 10
The value of b= 20
The value of c= 30
The value of ans= 6000

• In Hierarchical inheritance, one class acts as a superclass
(base class) for more than one subclass. More than one subclass
can inherit the features of a base class.
• For example -class A is a base class for the derived classes B and
C.
18
Types of Inheritance : Hierarchical

class A
{
int a;
void set_a(int i)
{
a=i;
}
void show_a()
{
a= "+a);
}
}
19
Example of Inheritance : Hierarchical
class B extends A
{
int b;
void set_b(int i)
{
b=i;
}
void show_b()
{
System.out.println("The value
of b= "+b);
}
void mul()
{
int ans;
ans=a*b;
ans= "+ans);
}
}

20
Example of Inheritance : Hierarchical
class C extends A
{
int c;
void set_c(int i)
{
c=i;
}
void show_c()
{
"+c);
}
void mul()
{
int ans;
ans=a*c;
ans= "+ans);
}
}
class Hierarchical
{
{
B obj_B=new B();
obj_B.set_a(10);
obj_B.set_b(20);
obj_B.mul();
C obj_c=new C();
obj_c.set_a(10);
obj_c.set_c(30);
obj_c.mul();
}
}
Output
F:>javac Hierarchical.java
F:>java Hierarchical

• In Multiple inheritance, one child or subclass can have more than
one base class or superclass and inherit features from every parent
class which it inherits.
• Java does not support multiple inheritances with classes. We can
achieve multiple inheritances only with the help of Interfaces.
21
Types of Inheritance : Multiple

22
Protected Members
• Protected mode is another access specifier which is used in
inheritance.
• The protected mode allows accessing the members to all the
classes and subclasses in the same package as well as to the
subclasses in other package. But the non subclasses in other
package can not access the protected members.
• For example, if some variable is declared as protected, then
the class itself can access it, its subclass can access it, and any class
in the same package can also access it.
• Similarly if the variable is declared as private then that
variable is accessible by that class
only and its subclass or package can not access it.

• A constructor invokes its superclass's
constructor explicitly and if such explicit
call to superclass's constructor is not given
then compiler makes the call using super()
as a first statemen in constructor.
• Normally a superclass's constructor is
called before the subclass'sconstructor.
This is called constructor chaining.
• Thus the calling of constructor occurs from
top to down.
23
Constructors in Sub Classes

24
Example of Constructor chaining
class A
{
public A()//constructor defined
{
System.out.println("1. Statement in class
A");
}
}
class B extends A //Derived child of A
{
public B() //constructor defined
{
B");
}
}
class C extends B //derived class of class B
{
public C()//constructor defined
{
C");
}
}
class D extends C //derived class of class C
{
public D()//constructor defined
{
D");
}
}
class MainClass
{
{
D obj=new D(); //calling constructor
using derived class object
}
}
Output
F:>javac MainClass.java
F:>java MainClass
1.Statement in class A
2.Statement in class B
3.Statement in class C
4.Statement in class D

• Overloading is a mechanism in which we can use many methods
having the same function name but can pass different number of
parameters or different types of parameter.
• For example :
int sum(int a,int b);
double sum(double a,double b);
int sum(int a,int b,int c);
• That means, by overloading mechanism, we can handle different
number of parameters or different types of parameter by having
the same method name.
25
Method Overloading

26
Example of Method Overloading
public class OverloadingDemo
{
{
System.out.println("Sum of two integers");
Sum(10,20);
System.out.println("Sum of two double
numbers");
Sum(10.5,20);
System.out.println("Sum of three
integers");
Sum(10,20,30);
}
public static void Sum(int num1,int num2)
{
int ans;
ans=num1+num2;
System.out.println(ans);
}
public static void Sum(double num1,int num2)
{
double ans;
ans=num1+num2;
}
public static void Sum(int num1,int num2,int
num3)
{
int ans;
ans=num1+num2+num3;
}
}
Output
F:>javac OverloadingDemo.java
F:>java OverloadingDemo
Sum of two integers
30
Sum of two double numbers
30.9
Sum of three integers
60

• Method overriding is a mechanism in which a subclass inherits
the methods of superclass and sometimes the subclass modifies
the implementation of a method defined in superclass.
• The method of superclass which gets modified in subclass has the
same name and type signature. The overridden method must be
called from the subclass.
27
Method Overriding

28
Example of Method Overriding
class A
{
int a=0;
void fun(int i)
{
this.a=i;
}
}
class B extends A
{
int b;
void fun(int i)
{
int c;
b=20;
super.fun(i+5);
System.out.println("value of a:"+a);
System.out.println("value of b:"+b);
c=a*b;
"+c);
}
}
class OverrideDemo
{
{
B obj_B=new B();
obj_B.fun(10);//function re-defined in
derived class
}
}
Output
F:>javac OverrideDemo.java
F:>java OverrideDemo
value of a:15
value of b:20
The value of c= 300

1.The private data fields in superclass are not accessible
to the outside class. Hence the method of superclass using
the private data field cannot be overridden by the subclass.
2. An instance method can be overridden only if it is
accessible. Hence private method can not be overridden.
3. The static method can be inherited but can not be
overridden.
4. Method overriding occurs only when the name of the two
methods and their type signatures is same.
29
Rules for method overriding

30
Use of keyword Super
Super is a keyword used to access the immediate parent
class from subclass.
There are three ways by which the keyword super is used.

31
1.The super() is used to invoke the class method of immediate parent class.
class A
{
int x=10;
}
class B extends A
{
int x=20;
void display()
{
System.out.println(super.x);
}
{
B obj=new B();
obj.display();
}
}
Output
10

32
2. The super() is used to access the class variable of immediate parent class.
class A
{
void fun()
{
System.out.println("Method: Class A");
}
}
class B extends A
{
void fun()
{
System.out.println("Method: Class B");
}
void display()
{
super.fun();
}
{
B obj=new B();
obj.display(); Output

33
3. The super() is used to invoke the immediate parent class constructor.
class A
{
A()
{
System.out.println("Constructor of Class A");
}
}
class B extends A
{
B()
{
super();
System.out.println("Constructor of Class B");
}
{
B obj=new B();
}
}
Output
Constructor of Class A

1.The private data fields in superclass are not accessible
to the outside class. Hence the method of superclass using
the private data field cannot be overridden by the subclass.
2. An instance method can be overridden only if it is
accessible. Hence private method can not be overridden.
3. The static method can be inherited but can not be
overridden.
4. Method overriding occurs only when the name of the two
methods and their type signatures is same.
34
Rules for method overriding

35
Difference between Method Overloading
and Method Overriding

In Java there is a special class named Object. If no inheritance
is specified for the classes then all those classes are subclass of the
Object class.
In other words, Object is a superclass of all other classes by
default. Hence
public class A
{ …}
is equal to
public class A extends Object
{…}
There are two commonly used methods in Object class.
Those are toString() and equals().
36
Object Class

37
Object Class : toString Method
class A extends Object
{
public String toString()
{
String str="Hello Friends";
return str;
}
class B extends A
{
}
}
class ObjectClassDemo1
{
{
A obj= new A();
System.out.println("Obj:"+obj);
System.out.println("Obj.toString():” + obj.toString());
}
}

38
Object Class : equals Method
class A extends Object
{
int a=10;
public boolean equals(Object obj)
{
if(obj instanceof B)
{ return a==((B)obj).b; }
else
return false;
}
}
class B extends A
{
int b=10;
}
class ObjectClassDemo2
{
{
A obj1=new A();
B obj2=new B();
System.out.println("The two values of a and b are equal:"+obj1.equals(obj2));
}
}

39
Abstract Classes and Methods
• In inheritance hierarchy, the superclass is very general and less
specific. This class does nothing but only specifies the member
functions that can be used in hierarchy. Such a classis called
abstract class.

40
For example –
In the above Java program we have created three
classes - class A is a superclass containing two methods, the class
B and class C are inherited from class A.
The class A is an abstract class because it contains one
abstract method fun1().
We have defined this method as abstract because, its
definition is overridden in the subclasses B and C, another
function of class A that is fun2() is a normal function.

41
abstract class A
{
abstract void fun1();
void fun2()
{
System.out.println("A:Infun2");
}
}
class B extends A
{
void fun1()
{
System.out.println("B:In fun1");
}
}
class C extends A
{
void fun1()
{
System.out.println("C:In fun1");
}
}
public class AbstractClsDemo
{
public static void main(String[] args)
{
B b=new B();
C c=new C();
b.fun1(); //invoking the overridden
method of class B
b.fun2();
c.fun1();//invoking the overridden
method of class C
c.fun2();
}
}
Output
F:test>javac AbstractClsDemo.java
F:test>java AbstractClsDemo
B:In fun1
A:In fun2
C:In fun1
A:In fun2

42
Points to Remember about abstract classes and abstract methods
1. An abstract method must be present in an abstract class only. It
should not be present in a non-abstract class.
2. In all the non-abstract subclasses extended from an abstract
superclass all the abstract methods must be implemented. An
un-implemented abstract method in the subclass is not allowed.
3. Abstract class cannot be instantiated using the new operator.
4. A constructor of an abstract class can be defined and can be
invoked by the subclasses.
5. A subclass can be abstract but the superclass can be concrete. For
example the superclass Object is concrete but the subclass class A
of it can be abstract.
6. The abstract class cannot be instantiated using new operator but an
abstract class can be used as a data type.

43
Points to Remember about abstract classes and abstract methods
1. An abstract method must be present in an abstract class only. It
should not be present in a non-abstract class.
2. In all the non-abstract subclasses extended from an abstract
superclass all the abstract methods must be implemented. An
un-implemented abstract method in the subclass is not allowed.
3. Abstract class cannot be instantiated using the new operator.
4. A constructor of an abstract class can be defined and can be
invoked by the subclasses.
5. A subclass can be abstract but the superclass can be concrete. For
example the superclass Object is concrete but the subclass class A
of it can be abstract.
6. The abstract class cannot be instantiated using new operator but an
abstract class can be used as a data type.

44
Difference between
Abstract Class and Concrete Class

45
Final Methods and Classes
The final keyword can be applied at three places
 For declaring variable
 For declaring the methods
 For declaring the class

46
Final Variables and Methods
A variable can be declared as final. If a particular variable is declared as final
then it cannot be modified further. The final variable is always a constant.
For example :
final int a=10;
The final keyword can also be applied to the method. When final keyword is
applied to the method, the method overriding is avoided.
For example :
final void fun()
{
System.out.println("n Hello, this function declared using final");
}
That means the methods those are declared with the keyword final cannot be
overridden.

47
Consider the following Java program which makes use of the keyword final for declaring the
method
class Test
{
final void fun()
{
System.out.println("n Hello, this function declared using final");
}
}
class Test1 extends Test
{
final void fun()
{
System.out.println("n Hello, this another function");
}
}
Output
D:>javac Test.java
Test.java:10: fun() in Test1 cannot override fun() in Test; overridden method is final
final void fun()
^
1 error

48
Final Classes to Stop Inheritance
If we declare particular class as final, no class can be
derived from it.
For example :
final class Test
{
void fun()
{
System.out.println("n Hello, this function in base class");
}
}

49
Final Classes to Stop Inheritance
class Test
{
void fun()
{
System.out.println("n Hello, this function in base class");
}
}
{
final void fun()
{
System.out.println("n Hello, this another function");
}
}
Output
D:>javac Test.java
Test.java:8: cannot inherit from final Test
^
1 error

50
Interfaces
Defining an Interface
The interface can be defined using following syntax
access_modifier interface name_of_interface
{
return_type method_name1(parameter1,parameter2,…parametern);
…
return_type method_name1(parameter1,parameter2,…parametern);
type static final variable_name=value;
…
}

51
Interfaces
The access_modifier specifies the whether the interface is public or
not. If the access specifier is not specified for an interface then that
interface will be accessible to all the classes present in that package
only. But if the interface is declared as public then it will be
accessible to any of the class.
The methods declared within the interface have no body. It is
expected that these methods must be defined within the class
definition.

52
Interfaces
Difference between Class and Interface

53
Interfaces
Difference between Abstract Class and Interface

54
Interfaces
The access_modifier specifies the whether the interface is public or
not. If the access specifier is not specified for an interface then that
interface will be accessible to all the classes present in that package
only. But if the interface is declared as public then it will be
accessible to any of the class.
The methods declared within the interface have no body. It is
expected that these methods must be defined within the class
definition.

55
Interfaces
Implementing Interface
It is necessary to create a class for every interface.
The class must be defined in the following form while using the
interface
class Class_name extends superclass_name
implements interface_name1,interface_name2,…
{
//body of class
}

56
Interfaces
Let us learn how to use interface for a class
Step 1 : Write following code and save it as
my_interface.java
public interface my_interface
{
void my_method(int val);
}
Do not compile this program. Simply save it.

57
Interfaces
Let us learn how to use interface for a class
Step 1 : Write following code and save it as
my_interface.java
public interface my_interface
{
void my_method(int val);
}
Do not compile this program. Simply save it.

58
Interfaces
Step 2 : Write following code in another file and save it using InterfaceDemo.java
Java Program[InterfaceDemo.java]
class A implements my_interface
{
public void my_method(int i)
{
System.out.println("n The value in the class A: "+i);
}
public void another_method() //Defining another method not declared in interface
{
System.out.println("nThis is another method in class A");
}
}
class InterfaceDemo
{
{
my_interface obj=new A();
//or A obj=new A() is also allowed
A obj1=new A();
obj.my_method(100);
obj1.another_method();
}

59
Interfaces
Step 3 : Compile the program created in step 2 and get the following
output
F:test>javac InterfaceDemo.java
F:test>java InterfaceDemo
The value in the class A: 100
This is another method in class A

60
Interfaces
Various ways of interface implementation

61
Interfaces
Step 2 : Write following code in another file and save it using InterfaceDemo.java
Java Program[InterfaceDemo.java]
class A implements my_interface
{
public void my_method(int i)
{
System.out.println("n The value in the class A: "+i);
}
public void another_method() //Defining another method not declared in interface
{
System.out.println("nThis is another method in class A");
}
}
class InterfaceDemo
{
{
my_interface obj=new A();
//or A obj=new A() is also allowed
A obj1=new A();
obj.my_method(100);
obj1.another_method();
}

62
Nested interface is an interface which is declared within another interface.
For example -
interface MyInterface1
{
interface MyInterface2
{
void show();
}
}
class NestedInterfaceDemo implements MyInterface1.MyInterface2
{
public void show()
{
System.out.println("Inside Nested interface method");
}
{
MyInterface1.MyInterface2 obj= new NestedInterfaceDemo();
obj.show();
}
}
Output

63
Variables in Interface
The variables can be assigned with some values within the interface.
They are implicitly
final and static. Even if you do not specify the variables as final and
static they are assumed
to be final and static.
The members of interface are static and final because -
1) The reason for being static - The members of interface belong
to interface only and not object.
2) The reason for being final - Any implementation can change
value of fields if they are not defined as final. Then these
members would become part of the implementation. An interface
is pure specification without any implementation.

64
Extending Interface
Interfaces can be extended similar to the classes. That means we can derive subclasses from
the main class using the keyword extend , similarly we can derive the subinterfaces from
main interfaces by using the keyword extends.
The syntax is
interface Interface_name2 extends interface_name1
{
…
…
…
}
For example
interface A
{
int val=10;
}
interface B extends A
{
void print_val();
}

65
Similarly more than one interfaces can be extended.
interface A
{
int val=10;
}
interface B
{
void print_val();
}
interface C extends A,B
{
…
…
}
Even-though methods are declared inside the interfaces and sub-interfaces, these
methods are not allowed to be defined in them. Note that methods are defined only
in the classes and not in the interfaces.

66
Multiple Inheritance
Definition: Multiple inheritance is a mechanism in which the
child class inherits the properties from more than one parent
classes.
For example
Java does not support multiple inheritance because it creates
ambiguity when the properties from both the parent classes are
inherited in child class or derived class. But it is supported in case of
interface because there is no ambiguity as implementation is
provided by the implementation class.

67
Multiple Inheritance
interface A
{
void display1();
}
interface B
{
void display2();
}
class C implements A,B
{
public void display1()
{
System.out.println("From Interface A");
}
public void display2()
{
System.out.println("From Interface B");
}
{
C obj = new C();
obj.display1();
obj.display2();
}
}

68
Object Cloning
Object cloning is technique of duplicating the object in the Java
program. If object copying is planned then the copy must be done by
copying the each fields of the object. This is poor method of copying the
contents from one class to another.
But object cloning technique simplifies it. The object cloning is
implemented using the interface called cloneable.
This interface requires the method clone. The clone() method
returns the object. Following Java code shows how objects are cloned. In
the following example we have created a simple class named student. The
object of this class has two fields Name and Course which define the name
of the student and the course chosen by him. For getting and setting these
field values the getName, getCourse,setName and setCourse methods are
used.

69
Object Cloning
public class CloneDemo
{
public static void main(String[] args)
{
Student s1=new Student();
s1.setName("Chitra");
s1.setCourse("Computer");
Student s2=(Student)s1.clone();
System.out.println("ttStudent 1");
System.out.println("Name:
"+s1.getName());
System.out.println("Course:
"+s1.getCourse());
System.out.println("ttStudent 2");
System.out.println("Name:
"+s2.getName());
System.out.println("Course:
"+s2.getCourse());
}
}
class Student implements Cloneable
{
private String Name;
private String Course;
public Object clone()
{
Student obj=new Student();
obj.setName(this.Name); //current name
obj.setCourse(this.Course); //current course
return obj; //is assigned to the obj
}
public String getName()
{
return Name;
}
public void setName(String Name)
{
this.Name=Name;
}
public String getCourse()
{
return Course;
}
public void setCourse(String Course)
{
this.Course=Course;
}
}

Inheritance and Interfaces

Recommended

More Related Content

What's hot (20)

Similar to Inheritance and Interfaces (20)

Recently uploaded (20)

Inheritance and Interfaces