Abstraction and Encapsulation in JAVA
Abstraction
Abstraction is the technique of hiding the implementation details and showing
only functionality to the user.
For example, when we call any person we just dial the numbers and are least
bothered about the internal process involved.
Abstract class
● A class that can contain abstract keywords is known as an abstract class.
● Abstract methods do not have body.
● It forces the user to extend the implementation rather than modification.
● An abstract class cannot be instantiated.
Abstract Method
● If a method is declared as an abstract, then it is called abstract method.
● It does not have an implementation.
● It contains method signature but not method body.
Syntax:
abstract class Student
private String name;
private int Rollno
private String course;
public abstract int m1()
}
Example: Program for abstract class and method
abstract class Vehicle
abstract int getSpeed();
class Bike extends Vehicle
int getSpeed()
return 60;
class Car extends Vehicle
int getSpeed()
return 70;
}
public class TestVehicle
public static void main(String args[])
Vehicle bike = new Bike();
Vehicle car = new Car();
int bikespeed = bike.getSpeed();
int carspeed = car.getSpeed();
System.out.println("Speed of Bike is: "+bikespeed+" Km/h");
System.out.println("Speed of Car is: "+carspeed+" Km/h");
Output:
Speed of Bike is: 60 Km/h
Speed of Car is: 70 Km/h
Difference between Abstract Class and Final Class
Abstract Class Final Class
Inheritance can be allowed. Inheritance cannot be allowed.
It contains abstract method. It cannot contain abstract method.
Abstract method must be overridden. Final method cannot be overridden.
Encapsulation
● Encapsulation is the mechanism to bind together code (methods) and
data (variables) into a single unit.
● Encapsulation is used for information hiding.
● Encapsulation can be achieved by declaring variables of class as private.
Advantages of Encapsulation
● Using the getter and setter method, the field of the class can be made
read-only or write-only.
● It improves the flexibility & maintainability of the code.
● By encapsulation we can hide the implementation details.
● Class has total control over the data.
Example: Program to use setter getter method in Java.
// EmpSetGet.java
public class EmpSetGet
private int empId;
private String name;
private int age;
private String dept;
public int getEmpId()
return empId;
public String getName()
return name;
public int getAge()
return age;
public String getDept()
return dept;
}
public void setEmpId( int empId)
this.empId = empId;
public void setName(String name)
this.name = name;
public void setAge( int age)
this.age = age;
public void setDept(String dept)
this.dept = dept;
}}
Example:
//Employee.java
public class Employee
public static void main(String args[])
EmpSetGet emp = new EmpSetGet();
emp.setEmpId(101);
emp.setName("ABC");
emp.setAge(25);
emp.setDept("Testing");
System.out.print("Employee Id : "+emp.getEmpId() + "\nName : " +
emp.getName() + "\nAge : " + emp.getAge() + "\nDepartment :
"+emp.getDept());
Output:
Employee Id : 101
Name : ABC
Age : 25
Department : Testing
