UNIT III

INHERITANCE, INTERFACE AND PACKAGE

Unit Outcomes
 Apply the identified type of inheritance for the given

programming problem.

 Differentiate between overloading and overriding for the

given example.

 Develop program using the specified interface.

 Create user defined package for the given problem.

 Add class and interface to the given package.

TOPICS AND SUB-TOPICS
 Inheritance: concept of inheritance, types of inheritance

 Single inheritance, multilevel inheritance, hierarchical inheritance, method and

constructor overloading and overriding, dynamic method dispatch, final

variables, final methods, use of super, abstract methods and class, static
members

 Interfaces: Define interface, implementing interface, accessing interface,

variables and methods, extending interfaces, interface references, nested

interfaces

 Package: Define package, type of package naming and creating packages,

accessing package, import statement, static import, adding class and interfaces
to a package.
 Inheritance in Java
 Reusability is yet another aspect of OOP paradigm
 It is always nice if we could reuse something that already exists
rather than creating the same class all over again.
 This is basically done by creating new classes, reusing the properties
of existing ones.
 Mechanism of deriving new class from old class is called
inheritance
 The old class is known as-
Base Class / Super class / Parent Class
 The new class is known as-
Derived class/ Sub Class / Child class
 Inheritance in Java
 Inheritance allows subclasses to inherit all the variables and
methods of their parent classes.
Types:
1. Single Inheritance
2. Multilevel Inheritance
3. Multiple inheritance
4. Hierarchical Inheritance
 Java does not directly implement multiple inheritance.
However this concept is implemented using a concept of
interface
 Defining Subclass
 A subclass is defied as follows:
class sub_class extends super_class
{
variable declarations;
method declarations;
}
 The keyword extends signifies that the properties of the
super_class are extended to the sub_class.
 The sub_class will now containts its own variable and methods
as well as those of the super_class.
 Inheritance In Java

 Single inheritance -

 When a class extends another one class

only then we call it a single inheritance. A

 The below flow diagram shows that class B

extends only one class which is A.

 Here A is a parent class of B and B would

B
be a child class of A.
 Single Inheritance example program in Java
Class A
{
public void method_A()
{
System.out.println("Base class method");
}
}
Class B extends A
{
public void method_B()
{
System.out.println("Child class method");
}
public static void main(String args[])
{
B obj = new B();
obj.method_A(); //calling super class method
obj.method_B(); //calling local method
}
}
 Single Inheritance example program in Java
class Base {
Base() {
System.out.println("Base Class Constructor Called ");
}
}
class Derived extends Base {
Derived() {
System.out.println("Derived Class Constructor Called ");
}
}
public class Main {
public static void main(String[] args) {
Derived d = new Derived();
}
}
 Sub Class Constructor
 A subclass constructor is used to construct the instance variables of
both the subclass and the superclass.
 The subclass constructor uses the keyword super to invoke the
constructor method of superclass.
 The super Keyword is used with following Conditions
 super may only be used within a subclass constructor.
 The call to super must appear as first statement.
 Parameters in the super call must match with declaration in superclass
 Single Inheritance example program in Java

class Vehicle
{
Vehicle()
{
System.out.println("Vehicle is created");
}
}
class Bike extends Vehicle{
Bike()
{
super();//will invoke parent class constructor
System.out.println("Bike is created");
}
public static void main(String args[]){
Bike b=new Bike();
}
}
 Multiple Inheritance
 “Multiple Inheritance” refers to the concept of one class
extending (Or inherits) more than one base class.
 The problem with “multiple inheritance” is that the derived class
will have to manage the dependency on two base classes.

A B

C
 Multilevel Inheritance
 Multilevel inheritance refers to a mechanism in OO
A
technology where one can inherit from a derived class,
thereby making this derived class the base class for the new class.
B
 As you can see in below flow diagram C is subclass or child class

of B and B is a child class of A.

C
 This concept allows us to build a chain of classes

 The class A serves as a base class for the derived class B which in

turn serves as base class for the derived class C. The chain ABC is
known as inheritance path
Class X
{
public void methodX()
{
System.out.println("Class X method");
}
}
Class Y extends X
{
public void methodY()
{
System.out.println("class Y method");
}
}
Class Z extends Y
{
public void methodZ()
{
System.out.println("class Z method");
}
public static void main(String args[])
{
Z obj = new Z();
obj.methodX(); //calling grand parent class method
obj.methodY(); //calling parent class method
obj.methodZ(); //calling local method
}
}
class Car{
public Car()
{
System.out.println("Class Car");
}
public void vehicleType()
{
System.out.println("Vehicle Type: Car");
}
}
class Maruti extends Car{
public Maruti()
{
System.out.println("Class Maruti");
}
public void brand()
{
System.out.println("Brand: Maruti");
}
public void speed()
{
System.out.println("Max: 90Kmph");
}
}
public class Maruti800 extends Maruti{

public Maruti800()
{
System.out.println("Maruti Model: 800");
}
public void speed()
{
System.out.println("Max: 80Kmph");
}
public static void main(String args[])
{
Maruti800 obj=new Maruti800();
obj.vehicleType();
obj.brand();
obj.speed();
}
}
class Design {
Design(){
System.out.println("Design()...");
} public class TestCallOrder {
} public static void main(String[] args)
class Coding extends Design { {
Coding(){ //Create object of bottom most
System.out.println("coding()..."); class object
} System.out.println("Constructor
} call order...");
class Testing extends Coding { new Testing();
Testing() }
{ }
System.out.println("Testing()...");
}
}
class X class Z extends Y
{ {
int i; int k;
X(int i) Z(int i, int j, int k)
{ {
this.i = i; super(i, j);
System.out.println("Created X"); this.k = k;
} System.out.println("Created Z");
} }
}
class Y extends X
{ class MultiLevelConstructors
int j; {
Y(int i, int j) public static void main(String arg[])
{ {
super(i); Z z = new Z(12, 22, 32);
this.j = j; System.out.println("---------------");
System.out.println("CreatedY");
} }
} }
 Hierarchical Inheritance
 In such kind of inheritance one class is

inherited by many sub classes.

 In below example class B,C and

D inherits the same class A.

A
 A is parent class (or base class) of

B,C & D.

B C D
 Hierarchical Inheritance
 Many programming problems can be cast into a hierarchy where

certain features of one level are shared by others below

Account

Fixed-
Saving deposit
Current

Short Medium Long

Class A
{
public void methodA()
{
System.out.println("method of Class A");
}
}
Class B extends A
{
public void methodB()
{
System.out.println("method of Class B");
}
}
Class C extends A
{
public void methodC()
{
System.out.println("method of Class C");
}
}
 Class D extends A
{
public void methodD()
{
System.out.println("method of Class D");
}
}
Class MyClass
{
public static void main(String args[])
{
B obj1 = new B();
C obj2 = new C();
D obj3 = new D();
obj1.methodA();
obj2.methodA();
obj3.methodA();
}} `
 Overriding Methods
 If subclass (child class) has the same method as declared in the
parent class, it is known as method overriding.
 In other words, If subclass provides the specific
implementation of the method that has been provided by one
of its parent class, it is known as Method Overriding.
 Advantage of Java Method Overriding
 provide specific implementation of a method that is already provided by its super class.

 Rules for Method Overriding

 method must have same name as in the parent class
 method must have same parameter as in the parent class.
 must be IS-A relationship (inheritance).
 Example
class Vehicle
{
void run()
{
System.out.println("Vehicle is running");
}
}
class Bike extends Vehicle
{
void run()
{
System.out.println("Bike is running safely");
}
public static void main(String args[])
{
Bike obj = new Bike();
obj.run();
}
}
 class Bank{
int getRateOfInterest()
{return 0;}
}

class SBI extends Bank{

int getRateOfInterest()
{return 8;}
}

class ICICI extends Bank{

int getRateOfInterest()
{return 7;}
}

class Test{
public static void main(String args[]){
SBI s=new SBI();
ICICI i=new ICICI();
System.out.println("SBI Rate of Interest: "+s.getRateOfInterest());
System.out.println("ICICI Rate of Interest: "+i.getRateOfInterest());

}
 Method Overloading Method Overriding

1) Method overloading is used Method overriding is used

to increase the readability of to provide the specific
the program. implementation of the
method that is already
provided by its super class.

2) method overloading is Method overriding occurs

performed within a class. in two classes that have
IS-A relationship.

3) In case of method In case of method

overloading parameter must overriding parameter must
be different. be same.
 Final variables and Methods
 All methods and variables can be overridden by default in subclasses.
 To prevent the subclasses from overriding the members of the superclass,
declare them as final using final keyword.

final int SIZE=10;

final void showstatus(..) {…}

 Defining method final ensures that functionality of defined method will

not be altered.
 Similarly the value of final variable never be changed.
 Final Classes
 A class that can not be sub-classed is called final class.

final class Aclass

{
…
}

final class Bclass extends Someclass

{
…
}
 Finalizer Methods
 Constructors are used to initialize an object when it is declared. This process
is known as “Initialization”.

 Similarly, java supports a concept called “finalization”.

 Java run time is automatic garbage collecting system. It automatically frees up the
memory resources used by the objects.

 But objects may hold other non-object resources.

 To free these resources we must use a finalizer method

finalize( )
 Abstract Methods and Classes
 A class declared as abstract is known as abstract class.
 It needs to be extended and its method implemented.
 It cannot be instantiated.

Syntax to declare the abstract class

abstract class <class_name>{ }
Abstract Method
• A method that is declared as abstract and does not have
implementation is known as abstract method.
Syntax to define the abstract method

abstract return_type <method_name>();

//no braces{}
 Example
abstract class Bike{
abstract void run( );
}
class Honda extends Bike
{
void run()
{ System.out.println("running safely..");
}
public static void main(String args[])
{
Bike obj = new Honda();
obj.run();
}
}
//example of abstract class having constructor, field and met
hod

abstract class Bike

{ int limit=30;
Bike( )
{ System.out.println("constructor is invoked"); }
void getDetails() {
System.out.println("it has two wheels"); }
abstract void run();
}
class Honda extends Bike{
void run(){ System.out.println("running safely.."); }
public static void main(String args[]){
Bike obj = new Honda();
obj.run();
obj.getDetails();
System.out.println(obj.limit); } }
 Methods with Varargs
 Varargs represents variable length arguments in methods.
 It makes the code simpler and flexible.

<access specifier> void method-name(object…arguments)

 In this syntax, the method contains an argument called

varargs ,in which
 Object is type of an argument.
 Ellipsis (…) is the key to varargs and
 arguments is the name of variable.
 Thus varargs allows us to declare a method with the unspecified number
of parameters.
 The varargs must be the final argument in the argument list of a method.
 Example :

Public void sample(String username, String password, String mailId);

 This method can be replaced by varargs:

public void sample(String … var_name)
 Example program for varargs
class Exampleprg
{
Exampleprg (String… person)
{
for(String name: person)
{
System.out.println(“Hello ”+ name);
}
}
public static void main(String args[])
{
Exampleprg(“John”, “Janny”, “Janardan”);
}
}