Abstraction in Java

Abstraction is one of the strong concepts of object-oriented programming (OOP). In this tutorial, we will learn all about abstraction in Java with examples.

What is abstraction in Java?

Abstraction is a mechanism of hiding the implementation details and showing only functionality to the user. Abstraction enables developers to create modular, reusable, and maintainable code in Java.

One simple example of Abstraction, we use mobile phones every day, but we know only the functionality of the phones but not their internal details.

Benefits of abstraction in Java:

📝 Abstraction is a cornerstone of object-oriented programming, and its effective use in Java leads to well-structured, maintainable, and reusable code. By understanding and applying abstraction principles, developers can create robust and scalable software applications.

How to achieve abstraction in Java?

Using the Interface we can achieve 100% abstraction (complete abstraction) whereas through the abstract class we can achieve 0-100% abstraction (partial or complete abstraction) depending on the implementation of the abstract class.

Abstract Class
(can be achieved 0 - 100% abstraction)

A class that is declared with an abstract keyword is known as an abstract class in Java. An abstract class cannot be instantiated, which means we cannot create the object of an abstract class.

An abstract class may or may not contain abstract methods (methods that do not have a body, such as public void display();). But, if a class has at least one abstract method, then the class must be declared as an abstract class.

To use an abstract class, we have to inherit it from another class and provide implementations for the abstract methods in it. It's mandatory to provide implementations for all the abstract methods in it. If any abstract method is not implemented, then that sub-class should be declared as ‘abstract’.

  abstract class ClassName {
    // variables
    // Blocks
    // constructors
    // abstract methods
    // instance methods
    // static methods
    // final methods
  }

A method that is declared with an abstract keyword is known as an abstract method in Java. An abstract method doesn't have its body in the abstract class we provide implementations of the abstract method in the subclass class only.

An Abstract Method is just a prototype for the method with the following attributes:

  abstract class Order {
    abstract String getOrderSummary(int orderId) throws OrderNotFoundException;<br>
  }

Let's see a complete example of an abstract class with abstract and non-abstract methods in Java program.

  abstract class MobileFeatures {
    abstract void newFeatures();
    void commonFeatures() {
      System.out.println("Mobile Common Features");
    }
  }
  
  class RealMe7 extends MobileFeatures {
    @Override
    void newFeatures() {
      System.out.println("RealMe7 Mobile - New Features");
    }
    void baseFeatures () {
      System.out.println("RealMe7 Mobile - Base Features");
    }
  }
  
  class RealMe8 extends MobileFeatures {
    @Override
    void newFeatures() {
      System.out.println("RealMe8 Mobile - New Features");
    }
    void baseFeatures () {
      System.out.println("RealMe8 Mobile - Base Features");
    }
  }
  
  public class AbstractClassExample2 {
    public static void main(String args[]) {
  
      RealMe7 realMe7 = new RealMe7();
      realMe7.commonFeatures();         // calling base class method
      realMe7.baseFeatures();		    // calling child class method
      realMe7.newFeatures();		    // calling overridden method
      
      System.out.println();	// Line break
      
      RealMe8 realMe8 = new RealMe8();
      realMe8.commonFeatures();	
      realMe8.baseFeatures();
      realMe8.newFeatures();
    }
  }

Mobile Common Features
RealMe7 Mobile - Base Features
RealMe7 Mobile - New Features

Mobile Common Features
RealMe8 Mobile - Base Features
RealMe8 Mobile - New Features

Interface
(can be achieved 100% abstraction)

In Java, An interface is an abstract type that is used to specify a behavior that classes must implement. An Interface contains only method declaration(no method body) and constant variables without Constructor and static methods.

In Interface all methods by default public and abstract and all variables by default public, static and final.

Use the interface keyword we can create Interface in Java but we cannot create objects of Interface.

  modifier interface interfaceName {
   // variables
   // methods 
  } 
  modifier class className implements interfaceName {
    // methods from the interface
  }

  interface Animal {
    int number_of_legs = 4;
    void eat();
    void run();
  }
  
  class Cow implements Animal {
    @Override
    public void eat() {
      System.out.println("Cow eats grass");
    }
    @Override
    public void run() {
      System.out.println("Cow runs slow");
    }
    public void legs() {
      // All variables of an Interface are by default final 
      // so we cannot the value of number_of_legs.
      // number_of_legs = 2; --> Compile Time Error
      System.out.println("Cow has total legs: " + number_of_legs);
    }
  }
  
  public class InterfaceExample1 {
	  public static void main(String args[]) {
      Cow cow = new Cow();
      cow.eat();
      cow.run();
      cow.legs();
    }
  }

Abstraction in Java

What is abstraction in Java?

Benefits of abstraction in Java:

How to achieve abstraction in Java?

Abstract Class (can be achieved 0 - 100% abstraction)

Interface (can be achieved 100% abstraction)

Currently No Video available

Abstract Class
(can be achieved 0 - 100% abstraction)

Interface
(can be achieved 100% abstraction)