Abstraction in Object-Oriented Programming

Abstraction is one of the core concepts of Object-Oriented Programming. Abstraction defines a model to create an application component. The implementation of abstraction depends on the language-specific features and processes.

1. What is Abstraction?

Abstraction is the process of hiding the internal details of an application from the outer world. It is used to describe things in simple terms and create a boundary between the application and the client programs.

2. Abstraction in Real Life

Abstraction is present in almost all the real-life machines. Your car and microwave are great examples of abstraction where the complex logic and internal implementation are completely hidden from the user, providing a simple interface to interact with.

3. Abstraction in OOPS

Objects are the building blocks of Object-Oriented Programming. An object contains some properties and methods which we can hide from the outer world through access modifiers, providing access only to the required functions and properties to other programs. This is the general procedure to implement abstraction in OOPS.

4. What are the different types of abstraction?

There are two types of abstraction: Data Abstraction and Process Abstraction. Data Abstraction involves hiding the object data from the outer world, providing access through methods if needed. Process Abstraction hides the internal implementation of the different functions involved in a user operation.

5. Abstraction in Java

Abstraction in Java is implemented through interfaces and abstract classes. They are used to create a base implementation or contract for the actual implementation classes.

Car.java: Base interface or abstract class

package com.journaldev.oops.abstraction;

public interface Car {

	void turnOnCar();

	void turnOffCar();

	String getCarType();
}

ManualCar.java, AutomaticCar.java: implementation classes of Car.

package com.journaldev.oops.abstraction;

public class ManualCar implements Car {

	private String carType = "Manual";
	
	@Override
	public void turnOnCar() {
		System.out.println("turn on the manual car");
	}

	@Override
	public void turnOffCar() {
		System.out.println("turn off the manual car");
	}

	@Override
	public String getCarType() {
		return this.carType;
	}
}
package com.journaldev.oops.abstraction;

public class AutomaticCar implements Car {

	private String carType = "Automatic";

	@Override
	public void turnOnCar() {
		System.out.println("turn on the automatic car");
	}

	@Override
	public void turnOffCar() {
		System.out.println("turn off the automatic car");
	}

	@Override
	public String getCarType() {
		return this.carType;
	}
}

User Program: Let’s look at a test program where the Car functions will be used.

package com.journaldev.oops.abstraction;

public class CarTest {

	public static void main(String[] args) {
		Car car1 = new ManualCar();
		Car car2 = new AutomaticCar();

		car1.turnOnCar();
		car1.turnOffCar();
		System.out.println(car1.getCarType());

		car2.turnOnCar();
		car2.turnOffCar();
		System.out.println(car2.getCarType());

	}

}

The client program only knows about the Car and the functions that the Car provides. The internal implementation details are hidden from the client program. References: Wikipedia, Oracle Docs