Object Oriented Programming

Subject: Object Oriented Programming Language using JAVA

Faculty name: Bhushan Shewale.

Object-oriented programming (OOP) is a
programming methodology to design a
source code using objects, which are
instances of classes (Members of classes)
that encapsulate data and Method’s. It
provides a way to structure and design
software systems which are based on the
concept of objects, which interact with each
other to perform specific tasks.
There are four pillar of Oops concepts

1. Encapsulation:- Encapsulation is the process of binding or wrapping the states (non-

static variables) and behaviours(non-static methods) of an objects. It’s achieve with the
help of classes.
Encapsulation is Data Hiding process with verification and validation.

• With Data Hiding

• Without Data Hiding

Data Hiding :- Data hiding it is the process of restricting the direct access to the data member
by providing indirect secured access via methods. With the help of data hiding we can provide
security for our data members by providing verification and validation.

for data hiding we can make a use of getter and setter method.

 Getter method:- Getter method is used to get the data and fetch the data.

 Setter Method:- Setter method is used to set the data and modify the data.
Ex. Without Data hiding

public class A1
{
public static void main(String[] args)
{
B b1=new B();
System.out.println(b1.a);
}

-------------------------------------------

public class B1
{
public static void main(String[] args)
{
int a=10;
}
}
Ex. With Data hiding
public class A
{
public static void main(String[] args)
{
B b1 = new B();
System.out.println(b1.get());
}

------------------------------------------

public class B
{
private int a=10;

public int get()

{
return a;
}
}
• Private:

1. Private is a keyword and it is access modifier.

2. We can prefix private access modifier only for member of the class.

3. If we prefix any data member with private access modifier then it’s written in the same
class we can access the private member directly.

4. But outside of the class if you want access private member the we should make use of
Getter and Setter method.

5. We can achieve the data hiding with the help of private keyword.
• Rules to be follow uses of private keyword in encapsulation:

1. If we want make our private member only readable then we make create only Getter
method.

2. If we want to make our data member both readable and writable then create Getter and
Setter Method.

3. We want to make our data member only writable then create only Setter method.
Ex. UML Diagram:
2. Inheritance:-
• Inheritance is the process acquiring properties from Parent class to Child class. It’s
comes under Is-a Relationship.
• Is-a relationship means parent and child relationship.
• All properties from Parent class will get inherited to child class expect private member,
constructor, multiline initializer.
• We can achieved inheritance between class to class with the help of extends keyword.
• We can achieved inheritance between class to interface with the help of implements
keyword.
Que: Why we used Inheritance in Java?
• For Method Overriding (so runtime polymorphism can be achieved).
• For Code Reusability.
Phrase used in Inheritance

1. Class: A class is a group of objects which have common properties. It is a template or

blueprint from which objects are created.

2. Sub Class or Child Class: the class which is acquiring(receiving, obtaining) the
properties of parent class is called as derived class, extended class, or child class.

3. Super Class/Parent Class: The class which giving the properties is called as base
class or a parent class.

4. Reusability: As the name specifies, reusability is a mechanism which facilitates you

to reuse the fields and methods of the existing class when you create a new class. You
can use the same fields and methods already defined in the previous class.
Que: Which members inherits and which members are not inherits in class?
Ans:
Static Member
Inherited Not Inherited
Variables Yes
Methods Yes
Initializers -- No

Non – Static Member

Inherited Not Inherited
Variables Yes
Methods Yes
Initializers -- No
Constructors -- No
There are five type of Inheritance

1. Single level Inheritance:- Inheritance is possible only one level then such type of
inheritance is known as single level inheritance.

2. Multi level Inheritance:- Inheritance is possible more than one level then such type
of inheritance is known as multi level inheritance.
3. Hierarchical Inheritance:- If the parent class is having more than one child at same level
is known as hierarchical inheritance.
4. Multiple inheritance:- If the child class is having more one parent at same level it is
known as multiple inheritance. Multiple inheritance is not possible in java.
5. Hybrid Inheritance:- Hybrid inheritance is possible with the combination of any two
type of inheritance is known as hybrid inheritance.
• Super Call Statement:

Super is a keyword and it is used to access the member of super class (Parent Class). Super call statement is used to call
the constructor of parent class from child class.

When the object is created for child class, then super call statement is used to call the constructor of parent class to load
all the non-static members of that class into the object created.

Step to be followed

1. Check object is created in that Heap Area.

2. Call the constructor, if it is present then it will call the Parent class constructor. After that Parent class
constructor will call their Parent class constructor.

3. Check weather the non – static members are present in that parent class and load into object created inside
the heap area. And assign with default value.

4. After that check weather the non – static initializer is executing from top to bottom.

5. Then call the main method for execution.

Rules to followed

1. Super call statement should be used only inside constructor body.

2. Super call statement should be the first statement inside the constructor.

3. We can not used multiple Super call statement inside same constructor because multiple
inheritance is not possible.

4. We can not used ‘super call statements’ as well as ‘this call statement’.

5. If the programmer fails to declared Super call statement then compiler will add no –
argument Super call statement.
• Difference Between Super( ) and Super:

Super( ) Super

1. It is used to access variable and methods

1. It is used to invoke only the constructor
of parent class from subclass (non –
of parent class from subclass.
static context)

2. It can be used inside any non – static

2. It can used only inside constructor body.
context.

3. It must be the first statement of the 3. It can be used anywhere inside the
constructor body. constructor body.
• Difference Between Super( ) and this( ):

Super( ) This( )

1. It is used to invoke only the constructor 1. It is used to invoke constructor of same

of parent class from subclass. class.

2. Can be added in all the constructor of a 2. Can be added only in n-1 constructor of
class. a class.
3. Compiler will implicitly add no –
argument super( ) to the constructor 3. Compiler doesn’t add this( ) implicitly.
which doesn’t have this( ).
Ex.

public class Parent2 {

int a;
{
System.out.println(" From MLNSI 1 of Parent class ");
System.out.println(a);
a = 12;
}
Parent2()
{
super();
System.out.println(" From Parent() constructor");
}
{
System.out.println(a);
}

}
public class Child2 extends Parent2
{
int b;
{
System.out.println(" From MLNSI of Child Class");
a = 7;
b = 9;
}
Child2()
{
super();
System.out.println(" From child() constructor");
}
public static void main(String[] args)
{
Child2 ch1 = new Child2();
System.out.println(ch1.a);
System.out.println(ch1.b);
}
}
Ex.
public class Ola
{
String starting;
String destination;
Ola(String start, String end)
{
this.starting = start;
this.destination = end;
}
}

public class Bike extends Ola

{
double price = 5;
Bike(String start, String end, double price)
{
super(start, end);
}
public void getBikeAttribute()
{
System.out.println(" Starting Point = "+ this.starting);
System.out.println(" Destination Point = "+ this.destination);
System.out.println(" Cost per km = "+ this.price);
}
}
public class Auto extends Ola
{
double price = 10;
Auto(String start, String end, double price)
{
super(start, end);
}
public void getAutoAttributes()
{
System.out.println("Starting Point = "+ this.starting);
System.out.println("Destination Point = "+ this.destination);
System.out.println("Cost per km = "+ this.price);
}
}

public class OlaDriver

{
public static void main(String[] args)
{
Auto a1 = new Auto("Waghodia", "Parul University", 10.0);
a1.getAutoAttributes();
Bike b1 = new Bike("Waghodia", "Parul University", 5.0);
b1.getBikeAttribute();
}
}
• Understanding of Object Reference Variable
1. One object can be referred to multiple reference variable.
2. We can copy the address of one object in multiple variable.
3. We can access the attribute of object with all the multiple reference variable.
Ex.

public class Student

{
String name;
}

public class StudentDriver

{
public static void main(String[] args)
{
Student s1 = new Student();
Student s2 = s1;
Student s3 = s2;
System.out.println(s1.name );
System.out.println(s2.name );
System.out.println(s3.name );
}
}
Note:

1. We can access the member of student object using the reference variable s1, s2, s3.

2. We can copy the reference of one variable to another variable only when int is of some
type.

3. If the reference variable is of different type then type casting is required.

• Type Casting
 Non – primitive type Casting

• It is the process of converting one type of reference variable to another type of reference variable is known
as non – primitive type casting.

• Non – primitive data means object reference variable.

• Non – primitive type casting is also known as derived type casting.

Rules to achieve non – primitive type casting

• There must exists Is-a relationship (Is-a relationship means Parent – Child class relationship).

• Or else at least the class should have common child.

• Type of non – primitive type casting
They are further classified into two type,

1. Upcasting: It is the process of converting child class reference variable to Parent class
reference variable is known as upcasting.

It is the process creating object for child class and store it in the reference in parent class
reference variable is known as upcasting.
Ex.
Child ch1 = new child( ); // child type object.
Parent p1 = ch1; // child type reference variable/ converting child type reference variable to parent type
reference variable.
Ex.
Parent p1 = new Child( ); // Parent type reference variable.
Ex.
public class Parent
{
int a = 10;
}
----------------------------------------------------------------------------------------
public class Child extends Parent
{
int b = 20;
}
----------------------------------------------------------------------------------------
public class PCDriver
{
public static void main(String[] args)
{
Child ch1 = new Child();
System.out.println(ch1.a);
System.out.println(ch1.b);
System.out.println(" After upcasting ");
Parent p1 = ch1;
System.out.println(p1.a);// 10
//System.out.println(p1.b);// compile time error (using up-casting reference
variable we can not access child class member
}
}
Notes:

1. Upcasting can be done implicitly by the compiler.

2. Hence it is also called as auto upcasting.

3. Upcasting done explicitly using type cast operator also.

4. Ones if the reference variable got upcasting using upcasting reference variable we can
access only parent class member but not child class members.

Que: Why we do need upcasting?

Ans: For the Generalization.

• Generalization:

1. Upcasting is used to achieve generalization(common).

2. If we created generalised container so that we can stored any type of child class object
reference into that generalised container.
3. Parent class is always container generalized container or class.
Example:
Ola o = new Ola( );

Ola o = new Mini( ); Any type of its child class object can be stored
Ola o = new Micro( );
Ola o = new Prime( );

• Disadvantage of up – casting
1. Once the reference variable upcasted using up – casting reference variable we can not
access child class member. This is one and only the biggest disadvantage of upcasting.
2. To overcome this disadvantage of upcasting we are making use of down – casting
• Down – casting:
This process of converting parent class reference variable to child class reference variable is
known as down casting.
Ex.
public class Parent
{
int a = 10;
}
----------------------------------------------------------------------------------------
public class Child extends Parent
{
int b = 20;
}
----------------------------------------------------------------------------------------
public class PCDriver
{
public static void main(String[] args)
{
Child ch1 = new Child();
Parent p1 = ch1;// Upcasting
Parent p11 = (Parent)ch1;// Downcasting
System.out.println(ch1.a );
System.out.println(ch1.b );
}
}
Note:
1. Down – casting is not done implicitly by the compiler.
2. As a programmer we need to perform Down – casting using type cast operator.
Ex.

public class Parent

{
int a = 10;
}
---------------------------------------------------------------------------
public class Child extends Parent
{
int b = 20;
}
---------------------------------------------------------------------------
public class PCDriver
{
public static void main(String[] args)
{
Parent p1 = new Parent();
Child ch1 = (Child) p1;// Downcasting
System.out.println(ch1.a );
System.out.println(ch1.b );// Error? java.lang.ClassCastException
}
}
• Class Cast Exception:

1. It is the unexpected event which occurs during execution of program (at runtime).

2. Class cast exception is a runtime exception.

3. Class cast exception occurs during down – casting process.

Que: When we got class cast exception?

Ans: When we try to convert the ‘p1’ object reference to a specific child type and if the object
does not contain the actual runtime instance of that particular type of object then we get
ClassCastException.
• Instance of Operator:

1. Instance is a keyword and Binary operator.

2. The return type of instance type operator is Boolean.

3. It is used to check the object is of given type or not.

4. If the specific object is of given type then it returns ‘true’ which means down – casting is
possible.

5. If the specific object is not of given type then it returns false which means Down – casting
is not possible.

6. If down – casting is not possible and still if we try to perform down – casting forcefully
then we get class cast exception.
Case 1:

public class Parent

{
int a = 10;
}
---------------------------------------------------------------------------
public class Child extends Parent
{
int b = 20;
}
---------------------------------------------------------------------------
public class PCDriver
{
public static void main(String[] args)
{
Parent p1 = new Child();// Up casting
System.out.println(p1 instanceof Child);
Child ch1 = (Child) p1;// Down casting
System.out.println(p1.a);
}
}
Case 2:

public class Parent

{
int a = 10;
}
---------------------------------------------------------------------------
public class Child extends Parent
{
int b = 20;
}
---------------------------------------------------------------------------
public class PCDriver
{
public static void main(String[] args)
{
Parent p1 = new Parent();// Up casting
System.out.println(p1 instanceof Child);
Child ch1 = (Child) p1;// Down casting
System.out.println(p1.a);
}
}
Ex.
public class A
{
int k = 10;
}

------------------------------------------------------------------------------------
public class B extends A
{
int l = 20;
}

------------------------------------------------------------------------------------
public class C extends B
{
int m = 30;
}

------------------------------------------------------------------------------------
public class D extends C
{
int n = 40;
}
public class ABCDDriver
{
public static void main(String[] args)
{
A a1 = new B();//Up casting
System.out.println(a1.k);
B b1 = (B)a1;//Down casting
System.out.println(b1.k);
System.out.println(b1.l);
C c1 = (C)b1;//Down casting
System.out.println(c1.k);
System.out.println(c1.l);
System.out.println(c1.m);
D d1 = (D)a1;//Down casting
System.out.println(d1.k);
System.out.println(d1.l);
System.out.println(d1.m);
System.out.println(d1.n);
}
}
3. Polymorphism:

 The object has the ability to undergoes in multiple forms or different forms is known
as Polymorphism.

 One object execute Multiple behaviours is known as Polymorphism.

 It is Derived from two Greek word Poly or Morphism.

 ‘Poly’ means mini or numerous.

 ‘Morphism’ means forms or behaviours.

Example:
1. One name = Many forms
2. One Variable = Many value
3. One method = different behaviour
There are two type of polymorphism
1. Compile time Polymorphism

 If the binding is achieved during compile time and same behaviour is execute is known as
compile time polymorphism.

 Binding means the association between method called statement and the method declaration
statement during compile time and same behaviour is executed is known as compile time
polymorphism.

 Behaviour means method it is also known as Static Polymorphism.

 Compile time polymorphism is achieved by following way

1. Method overloading
2. Method shadowing
3. Variable shadowing
4. Operator overloading
5. Constructor overloading
• Method Overloading:

1. If a class have more than one method with same name but different formal argument is
known as Method Overloading.

2. Method Overloading is achieved by using static and non – static method.

3. We can achieve Method Overloading by Two way,

a. By changing number of Argument

b. By changing type of Argument

• Note: Method overloading is always based on method name and formal argument but not on

return type and method definition.

a. By changing number of argument:

public class Polymorphism

{
public static void main(String[] args)
{
add(10, 20, 30);
add(10, 20);
add(10);
}
public static void add(int a)
{
System.out.println("From add(int a)");
}
public static void add(int a, int b)
{
System.out.println("From add(int a), add(int b)");
}
public static void add(int a, int b, int c)
{
System.out.println("From add(int a), add(int b), add(int c)");
}

}
b. By changing type of Argument:

public class Polymorphism1

{
public static void main(String[] args)
{
add(10,20);
add(10, 12.50);
add(12.50, 11.20);
}
public static void add(double a, double b)
{
System.out.println("From add(double a, double b)");
}
public static void add(int a, double b)
{
System.out.println("From add(int a, double b)");
}
public static void add(int a, int b)
{
System.out.println("From add(int a, int b)");
}

}
• Method Overloading with Type promotion:
Ex 1:
public class PolymorphismWithTypePromotion
{
public static void main(String[] args)
{
add(10, 20);
}
public static void add(int a, float b)
{
System.out.println("From add(int a, float b)");
}
public static void add(int a, char b)
{
System.out.println("From add(int a, char b)");
}

Note: In above program we perform auto widening. Convert int type of data to float using
type promotion.
Note:

1. In case of method overloading if no suitable method is found then our compiler will try to
perform type promotion.

2. If type promotion is possible then respective method will called. If not we get compile
time error.

3. Type promotion is possible only in case of widening but not on case of narrowing.

4. Type promotion will perform while nearest value will take.

5. Type promotion will be done by the compiler to the nearest data type.
Que: Why main method always static?
Ans: Your java program execution is start from main method. When you run a Java program,
the Java Virtual Machine (JVM) looks for a public static void main(String[] args) method to
start executing the program. Because the main method is the starting point, it needs to be
accessible without creating an object of the class.
Since the main method is the starting point of the program and is called by the JVM before
any objects of the class are created, it cannot rely on the existence of any instances of the
class. Therefore, it must be declared as static so that it can be called on the class itself rather
than on an instance.
Making the main method as a static then it ensure the consistency in how it is invoked across
different java programs.
Declaring the main method as a static simplifies the program initialization process. You don't
need to create an object of the class just to execute the program.
Ex 2:
public class PolymorphismWithTypePromotion1
{
public static void main(String[] args)
{
add(5, 5.25);
}
public static void add(int a, double b)
{
System.out.println("From add(int a, double b)");
}
public static void add(double a, double b)
{
System.out.println("From add(double a, double b)");
}
}
Ex 3 : No Suitable method found

public class PolymorphismWithTypePromotion2

{
public static void main(String[] args)
{
add(5, 12.45);// no suitable method found
}

public static void add(int a, float b)

{
System.out.println("From add(int a, float b)");
}

public static void add(int a, int b)

{
System.out.println("From add(int a, int b)");
}

Note: Type promotion will done by the compiler to the nearest datatype
Ex 4: Ambiguity problem

public class PolymorphismWithAmbiguityProblem

{
public static void main(String[] args)
{
add(5, 10);// The method add(int, float) is ambiguous
}
public static void add(int a, float b)
{
System.out.println("From add(int a, float b)");
}
public static void add(float a, int b)
{
System.out.println("From add(float a, int b)");
}
public static void add(double a, int b)
{
System.out.println("From add(double a, int b)");
}
}
Note:

1. While performing type promotion if there exist more than one method which can perform
type promotion in this case we get ambiguity error.

2. Because if there exist more than one method which can perform type promotion then our
compiler will get confuse to call which particular method this lead to ambiguity problem.
Ex 5: Don’t care about return type

public class PolymorphismWithReturnType

{
public static void main(String[] args)
{
add(10, 20);
}

public static int add(int a, float b)

{
System.out.println("From add(int a, float b)");
return 10;
}

public static void add(int a, char b)

{
System.out.println("From add(int a, char b)");
}

}
Note: Method overloading is based on method signature but not on return type.
Que: Can we do method Overloading?
Ans: Yes, we can overload the main method but our JVM will call the main method which
accepts (String [] args).
Ex.

public class MainMethodOverloading

{
public static void main(String[] args)
{
System.out.println("From (String [] args)");
}
public static void main(int a)
{
System.out.println("From main(int a)");
}
public static void main()
{
System.out.println("From main()");
}
}
2. Run Time Polymorphism:
 The binding happens during runtime and different behaviour is executed is known as
run time polymorphism.

 Binding means the association between method called statement and the method
declaration statement happens during runtime(During execution of the Program) and
different behaviour execute is known as Runtime Polymorphism, and it is also known
as Dynamic polymorphism.

 We can achieved the runtime polymorphism by following way

1. Method over riding

• Method Overriding:
Changing the implementation of parent class to the child class is known as method
overriding.
Ex.

public class Parent

{
public void m1()
{
System.out.println(" From parent class m1 ");
}
}
------------------------------------------------------------------------------------

public class Child extends Parent

{
public void m1()
{
System.out.println(" From Child Class m1() ");
}
}
public class PCDriver
{
public static void main(String[] args)
{
Parent p1 = new Parent();
p1.m1();
Child ch1 = new Child();
ch1.m1();
Parent p2 = ch1;//Upcasting
p2.m1();
Child ch2 = (Child)p2;//Downcasting
ch2.m1();
}
}
Note: In above case we take runtime object. For execution of program.

Rules to achieve method overriding

1. Is – a relationship should be must.
2. Parent class method declaration and child class method declaration should be same.
3. Parent class method and child class method should be non – static.
4. If parent class method or child class method contains non – static method with same
declaration is known as method overriding.
Ex.
public class Parent
{
public void test()
{
System.out.println(" From parent class test() ");
}
}
------------------------------------------------------------------------------------
public class Child extends Parent
{
public void test()
{
System.out.println(" From Child Class test() ");
}
}
------------------------------------------------------------------------------------
public class PCDriver
{
public static void main(String[] args)
{
Parent p1 = new Parent();
p1.test();
Child ch1 = new Child();
ch1.test();
Parent p2 = ch1;//Upcasting
p2.test();
Parent p3 = new Child();
p3.test();
}
}
Ex.
public class Parent
{
public void test()
{
System.out.println(" From parent class test() ");
}
}
------------------------------------------------------------------------------------
public class Child extends Parent
{
public void test()
{
System.out.println(" From Child Class test() ");
}
}
------------------------------------------------------------------------------------
public class PCDriver
{
public static void main(String[] args)
{
Parent p1 = new Parent();
p1.test();
Child ch1 = new Child();
ch1.test();
Parent p2 = ch1;//Upcasting
p2.test();
Child ch2 = (Child)p2;//Downcasting
ch2.test();
Parent p3 = new Child();
p3.test();
}
}
• Method Shadowing

1. If the parent class and child class is having same static method with same method
signature then it is called as method shadowing.

2. Method shadowing come under compile time polymorphism.

3. In Method Shadowing it comes when reference variable type will called.

4. The method shadowing based on the reference variable type the respective class method
will get executed.
public class Parent
{
public static void test()
{
System.out.println(" From parent class test() ");
}
}
------------------------------------------------------------------------------------
public class Child extends Parent
{
public static void test()
{
System.out.println(" From Child Class test() ");
}
}
------------------------------------------------------------------------------------
public class PCDriver
{
public static void main(String[] args)
{
Parent p1 = new Parent();
p1.test();
Child ch1 = new Child();
ch1.test();
Parent p2 = ch1;//Upcasting
p2.test();
Child ch2 = (Child)p2;//Downcasting
ch2.test();
Parent p3 = new Child();
p3.test();
}
}
• Variable Shadowing

1. Variable Shadowing comes under compile time polymorphism, because the binding
achieve during compile time.

2. The variable used based on reference variable type but not based on runtime object.

3. Variable shadowing can be achieved by static variable as well as non – static variable.
Ex.
public class A
{
int a = 10;
}

------------------------------------------------------------------------------------
public class B extends A
{
int b = 20;
}

------------------------------------------------------------------------------------
public class C extends B
{
int c = 30;
}

------------------------------------------------------------------------------------
public class D extends C
{
int d = 40;
}
public class ABCDDriver
{
public static void main(String[] args)
{
C c1 = new C();
System.out.println(c1.c);
A a1 = c1;// Upcasting
System.out.println(a1.a);
B b1 = (B)a1;// Downcasting
System.out.println(b1.b);
D d1 = new D();
System.out.println(d1.d);

}
• Abstraction:
1. Showing essential feature by hiding the background details is known as abstraction.

2. Showing Method declaration hiding method implementation.

3. It is the design process of hiding the implementation and by showing only the functionality
(Method Declaration).

Que: How to achieved Abstraction?

Ans: It is Achieve with the help of Abstract class and Interface.

Que: How to create Abstract class?

Ans:

1. Using “abstract” keyword and Modifier.

2. We can provide implementation for abstract component with the help of inheritance and method
overriding.
 Abstract keyword:

1. Abstract is a keyword and modifier.

2. We can prefix abstract keyword for methods and classes.

 Abstract Method:

1. Any method which is prefixed with abstract modifier is known as abstract method.

2. Abstract method are incomplete method, Because abstract methods doesn't contain any method
definition and method implementation.

3. Abstract method contain only Method Declaration (Non – static method) but not method
implementation, the child class should provide implementation for this abstract method.

Syntax:

abstract[Access Modifier + [Modifier] ] + ReturnType + MethodName([Formal Argument])

Abstract Class:
1. Any class which is prefix with abstract keyword is known as abstract class.
2. If a class contains at least one abstract method or more than one abstract in this class we
must and should make the class as abstract.
3. If the class doesn’t contain any of the abstract method then making the class as abstract it
is optional.
4. Abstract class can contain both concreate method as well as abstract methods, hence main
method is a concreate method which can be declared inside abstract class.
5. If any class is contain main method then it is eligible for execution, therefore we can
execute abstract class as well.
6. We can not create object for abstract for abstract class but you can create the reference
type(if parent is abstract class then used to reference type: first create class as a Is – a
relationship then provide the implementation for that if this class is not have
implementation make as abstract then the upcoming child class is responsible to give the
implementation for that abstract class through inheritance or method overriding.)
7. If the class contains at least one abstract method either declared or inherited then we must
and should make the class as abstract.
Ex.
public abstract class Vehical
{
abstract public void wheels();
}
------------------------------------------------------------------------------------
public class Bike extends Vehical
{
@Override
public void wheels()
{
System.out.println("Bike contains 2 Wheels ");
}
}
------------------------------------------------------------------------------------
public class Car extends Vehical
{
@Override
public void wheels()
{
System.out.println("Car contains 4 wheels");
}
}
public class VehicalDriver
{
public static void main(String[] args)
{
//Vehical v = new Vehical();// CTE(Abstract class cannot be instantiated)

Vehical v1 = new Bike();//upcasting

v1.wheels();
Vehical v2 = new Car();//upcasting
v2.wheels();
}
}
Ex.
public abstract class Bank
{
abstract public double rateOfInterest();
}
------------------------------------------------------------------------------------
public class SBI extends Bank
{
@Override
public double rateOfInterest()
{
return 4.0;
}
}
------------------------------------------------------------------------------------
public class Kotak extends Bank
{
@Override
public double rateOfInterest()
{
return 5.7;
}
}
public class ICICI extends Bank
{
@Override
public double rateOfInterest()
{
return 10.78;
}
}
------------------------------------------------------------------------------------
public class BankDriver
{
public static void main(String[] args)
{
Bank b1 = new ICICI();//Upcasting
System.out.println(b1.rateOfInterest());

Bank b2 = new SBI();//Upcasting

System.out.println(b2.rateOfInterest());

Bank b3 = new Kotak();//Upcasting

System.out.println(b3.rateOfInterest());
}
}
 Concreate Class:
1. The class which is not prefixed with abstract keyword is known concrete class.
2. Concrete class doesn’t contain any abstract methods.
3. We can create object for concrete class.

 Concrete method
1. The method which is not prefixed with abstract keyword is know as concrete method.
2. Concrete method always contain implementation.

 Implementation of abstract method

Step 1: If a class is inheriting an abstract class the child class should provide implementation
for all the abstract methods of parent class .
In case if the child class doesn’t want to provide implementation for abstract method
of parent class then it is mandatory make the child class as a abstract class.
 Step to provide implementation for a abstract method

Step 1: Create a class by using inheritance make the class as child to abstract class(Parent).

Step 2: Using method overriding provide implementation for all the abstract method of parent
class.

Note:

In case if the child class doesn’t want to provide implementation for the abstract
method of parent class then make the class as abstract the next upcoming child will have the
responsibility to provide implementation for all the abstract methods.
Ex.
public abstract class Mobile
{
abstract public void Mp3();
abstract public void Camera();
abstract public void Browser();
}

------------------------------------------------------------------------------------
public abstract class Samsung extends Mobile
{
@Override
public void Mp3()
{
System.out.println(" Samsung Mobile has Mp3 ");
}
}
public class S22 extends Samsung
{
@Override
public void Camera()
{
System.out.println(" S22 has 108MP Camera ");
}
@Override
public void Browser()
{
System.out.println(" S22 Works on 5G Network ");
}
}
------------------------------------------------------------------------------------
public class MobileDriver
{
public static void main(String[] args)
{
Mobile m1 = new S22();
m1.Mp3();
m1.Camera();
m1.Browser();
}
}
• Interface
1. Interface is a component which is used to achieve 100% abstraction.
2. Inside the interface non – static concreate method are not allow.
Syntax:
[Access Modifier] + interface + InterfaceName
{
// Statement;
}
3. When the program is executes the source code is converted to .class extension file. Means
Before the compilation.
4. After compilation .class extension interface prefixed with abstract keyword to run the .java
extension file.
5. When we compile the interface byte code will generated which in form of .class extension
file.
Ex.
1. Before the compilation source code
interface Demo
{
public void m1();
}
2. After compilation .class extension
abstract interface I1
{
public void m1();
}

Nate: In interface by default the access modifier is specified as “ public ”.

Que: What are the class members that can be declared inside an interface?
Ans:

Class Member class interface

Static Variables Yes Yes

Non – Static Variables Yes No

Static Methods Yes Yes

Non – Static Methods Yes No

Constructor’s Yes No

Multiline Initializers Yes No

• Final

1. Final is keyword which is gives to the class, variable, Method.

2. If the final keyword is prefix with class name then it can not be inherited and it is final
class.

3. If the final keyword gives to the variable then we can not be modify by default consider as
final.

4. If any method is prefix with final keyword then the method can not be overridden.

5. Static method is not inherited inside the interface.

Note: Any variable declared in interface then compiler will add implicitly final static or you
have to declared explicitly.

Ex.
interface Demo
{
final static int a = 10;
public static void main(String[] args)
{
System.out.println(a);
a = 20;// / CTE(Final variable cannot be modified)
}
}

Note: Inside interface static methods are allowed hence we can create main method an
interface therefor we can execute interface as well.
Ex. Final Variable must should initialize at the time of declaration.
interface Demo
{
int a;// The blank final field a may not have been initialized
}
Ex. We cannot create object because by default class is abstract ( implicitly compiler ).
interface Demo
{
int a = 10;
public static void main(String []args)
{
Demo d1 = new Demo();//Cannot instantiate the type Demo
// We cannot create object for interface.
}
}

Ex. Concreate Non – Static method is not possible in interface only concreate static method is accept.
interface Demo
{
public void test() //Abstract methods do not specify a body
{
//Statement;
}
}
Note: Whenever if we create non – static method inside an interface implicitly our compiler
will make it as “abstract”.(no implementation )

Que: Why do we need Interface?

Ans: By using interface we can achieve 100% abstraction using interface we can provide
solution for diamond problem therefore we can achieve multiple inheritance with the help of
inheritance.

Que: What are all the member which will not get inherited from an interface?

Ans: From an interface static methods will never get inherited to the class to interface.
Que: Inheritance with respect to Interface?

Ans: An interface can inherited any number of interfaces at the same time with the help of
extends keyword.
Ex:
public interface I1
{
abstract public void m1();
}
------------------------------------------------------------------------------------
public interface I2 extends I1
{
public void m1();
}

Note: When an interface is inheriting another interface in this case the child interface need not
to provide implementation for abstract method of parent interface.
Ex.

public interface I1
{
public void m1();
public void m2();
public static void test();
}
Above program there are two non – static method abstract [m1(), m2()]. And one static
concrete test() method, total: 3 Methods
public interface I2 extends I1
{
public void m3();
}
Above program is only non – static method are inherited
i. public static void m1();
ii. public static void m2();
iii. public static void m3();
Ex. Interface can inherit any number of interface at same time (Multiple inheritance).
public interface I1
{
// Statement;
}
------------------------------------------------------------------------------------
public interface I2
{
// Statement;
}
------------------------------------------------------------------------------------
public interface I3 extends I1, I2
{
// Statement
}

Note: Using interface we don’t get any Dimond problem, hence we can achieve multiple
inheritance using interface.
• Solution on Diamond Problem:

1. Interface does not contain any constructors.

2. Non – static concrete method are not allow in an interface therefor non – static method are
abstract.

3. Static concrete method will never get inherited in an another interface or form an interface.

• Inheritance of an interface by the class

1. A class can inherit an interface with the help of implements keyword.

2. A class can inherit multiple interface as well as at the same time.

Ex.
public interface I1
{
public void m1();
}
------------------------------------------------------------------------------------
public interface I2
{
public void m1();
}
------------------------------------------------------------------------------------
public class DiamondSolution implements I1, I2
{
public void m1()
{
System.out.println("From m1() of class A");
}
public static void main(String[] args)
{
DiamondSolution d1 = new DiamondSolution();
d1.m1();
}

}
• Step to be follow when performing solution of Diamond Problem

1. new DiamondSolution(); means constructor, first this statement call the super call
statement, means accepts parent class. but in class not have constructor then no create
ambiguity problem.

2. In two interface two method declaration with the same method name and same method
signature but in class doesn’t accepts same method name and same method signature then
it is provide one method in class for implementation.

3. A class can inherit multiple interfaces at the same time but not multiple classes at same
time because of Diamond Problem.
Note:

1. When a class is inheriting an interface in this case all the abstract methods of an interface
will get inherited to the child class hence this child class as the responsibility to provide
implementation to the abstract method of parent interface.

2. In case if the child class doesn’t want to provide implementation for abstract method of
parent interface then make the class as abstract.

3. Then next upcoming child will provide implementation to the abstract methods of an
abstract class.
 Abstract class Interface
1) Abstract class can have abstract and non-abstract methods. Interface can have only abstract methods. Since Java 8, it can
have default and static methods also.

2) Abstract class doesn't support multiple inheritance. Interface supports multiple inheritance.

3) Abstract class can have final, non-final, static and non-static Interface has only static and final variables.
variables.

4) Abstract class can provide the implementation of interface. Interface can't provide the implementation of abstract class.

5) The abstract keyword is used to declare abstract class. The interface keyword is used to declare interface.

6) An abstract class can extend another Java class and implement An interface can extend another Java interface only.
multiple Java interfaces.

7) An abstract class can be extended using keyword "extends". An interface can be implemented using keyword "implements".

8) A Java abstract class can have class members like private, Members of a Java interface are public by default.
protected, etc.