«Back to Home

Core Java
Topics

Abstraction In Java

Abstraction

In Java, abstraction is a procedure to hide the implementation details from the user and provides only functionality to the user.
 
In other words, it hides all the internal details and provides only important things to the user. For example in calculator, when we want to calculate some data, we use its keys but we don’t know, how it works internally. It provides only important things to the user and hides the internal process from the user.
 
In Java, there are two ways to achieve abstraction, which are,
  • Abstract class

  • Interface
Abstract class in Java

In Java, when we use abstract keyword with any class, this class is called as an abstract class.
  • Abstract class can have abstract methods and non-abstract methods.

  • If a class has an abstract method, this class must be abstract class.

  • If we want to use an abstract class, it needs to be extended and its method implemented.

  • If we extend an abstract class, we have to provide implementation for all the abstract methods in it.

  • We can’t instantiate an abstract class.
Let’s see an example of an abstract class, given below.
Code
  1. abstract class Person {  
  2.     abstract void work();  
  3. }  
  4. public class Women extends Person {  
  5.     void work() {  
  6.         System.out.println("Working hard");  
  7.     }  
  8.     public static void main(String args[]) {  
  9.         Person p = new Women();  
  10.         p.work();  
  11.     }  
  12. }  
19

Output

20

In this example, we create person class, which contains one abstract method work and its implementation is provided by the women class.
 
Abstract method in Java

In Java, when we use abstract keyword with any method, the method is called as an abstract method and an abstract method contains a method signature, but no method body.
 
For example

21
 
Another example of abstraction is given below.
 
Code
  1. abstract class Mobile {  
  2.     abstract void call();  
  3. }  
  4. //implementation is provided by others i.e. unknown by end user    
  5. class Nokia extends Mobile {  
  6.     void call() {  
  7.         System.out.println("Nokia phone is ringing");  
  8.     }  
  9. }  
  10. class Samsung extends Mobile {  
  11.     void call() {  
  12.         System.out.println("Samsung phone is ringing");  
  13.     }  
  14. }  
  15. // method is called by programmer or user    
  16. public class Example {  
  17.     public static void main(String args[]) {  
  18.         Mobile m = new Samsung(); //object is provided through method   
  19.         m.call();  
  20.     }  
  21. }  
22

Output

23
 
In this example, Mobile class is an abstract class and its implementation is provided by Nokia and Samsung classes. In it, if we create an instance of Nokia class, call () method of Nokia class will be invoked similar to Samsung class. In reality, we don’t know about the implementation class i.e. hidden to the user and object of the implementation class is provided by the factory method.
 
Factory method is used to return the instance of the class.
 
An abstract class can have variables, abstract method, method body, constructor and main () method also.
 
Let’s see an example, given below.
 
Code
  1. abstract class Mobile {  
  2.     Mobile() {  
  3.         System.out.println("Mobile is launched");  
  4.     }  
  5.     abstract void call();  
  6.     void message() {  
  7.         System.out.println("get message");  
  8.     }  
  9. }  
  10. class Nokia extends Mobile {  
  11.     void call() {  
  12.         System.out.println("Nokia phone is ringing");  
  13.     }  
  14. }  
  15. class Samsung extends Mobile {  
  16.     void call() {  
  17.         System.out.println("Samsung phone is ringing");  
  18.     }  
  19. }  
  20. public class Example {  
  21.     public static void main(String args[]) {  
  22.         Mobile m = new Nokia();  
  23.         m.call();  
  24.         m.message();  
  25.     }  
  26. }  
24

Output

25

In the example, shown above, Mobile class has a constructor, abstract method and non-abstract method and returns an output.
 
Summary

Thus, we learnt that an abstraction hides all the internal details and provides only important things to the user and also learnt how to create an abstract class and method in Java.