In Java, Abstraction is one of the major building block. It is a process of hiding internal working and showing only necessary details. In simple form abstraction means:
Important Note: Interface is used to achieve 100% Abstraction in JAVA. Here we only discuss Abstraction in full details but we recommend you to learn Abstraction and Interface topic simultaneously as both topics are similar with little bit difference.
Table of Contents
The best explanation of Abstraction is using the common example of sending SMS. When a user send SMS, he simply enter the address, type message in the text box and send it. He doesn’t know what is happening behind the scene when this message is getting send to the other user. So here implementation details has been hided from the user and only functionality is presented to user. This is achieved in JAVA either through Abstraction or Interface.
Before we share syntax you first need to understand abstract class, abstract methods and why/how to extend Abstract class:
What Is Abstract Class:
An abstract class is declared with abstract keyword which may contain methods without body, with body or mixture of both. If a class have at least one method without body then it has to be declared abstract.
Important Note: Method without body means method without any functionality or implementation.
In the below example you can see one method calling is without body. So here class has to be declared abstract because it has one method without body.
abstract class Mobile{
abstract void calling();
abstract void messaging()
{
System.out.println("Messaging");
}
}
What Is Abstract Method:
The methods without body or methods with only signatures are called abstract methods. The abstract method doesn’t have any implementation details. It is declared using abstract keyword before method name. For example, calling method is an abstract method.
abstract void calling();
Syntax: of Abstract Method
abstract void method_name();
Important Note: In order to use abstract method we first need to override that method in subclass (i.e. child class).
Why And How To Extend Abstract Class:
As now you already know Abstract class may contains abstract method without any implementation and thus we cannot instantiate abstract class. In case we try instantiating it, the object might be useless because methods inside abstract class may not have any implementation at all. So to avoid this situation, JAVA doesn’t allow us to instantiate abstract class.
We first need to extend abstract class where we will do the implementation of those abstract method and then we instantiate this new class.
So let’s see how to extend Abstract class:
Step 1: First we define abstract class with abstract method:
abstract class Mobile{
abstract calling(); //Method without body
}
Step 2: Now we extends abstract class and implement abstract methods:
class Samsung extends Mobile{
void calling();
{
System.out.println("Start Calling");
}
}
Pro Note: An example of abstract class is AbstractMap which is part of collection framework include TreeMap, HashMap and ConcurrentHashMap and share many methods like isEmpty(), put() , get(), containValue() , containKey() etc that AbstractMap defines.
The syntax of abstraction start with abstract keyword before class name. It then contains mixture of abstract and non-abstract methods.
abstract class <ClassName>{
//Mixture of abstract methods(Without body/implementation) and non-abstract methods(with body/implementation)
//If it contains atleast one abstract method then a class has to be declared abstract
}
Example 1: Lets now understand abstraction concept using real life examples of different sounds created by animals. For example Cat does Meow and Lion Does Roar. We will display different sounds using Abstraction in JAVA.
Step 1: First create a new project in Eclipse and create a abstract class Sound. Below is the code of Sound.java
abstract class Sound {
//Non-abstract method i.e. method with implementation
public void soundmessage(){
System.out.print("Animal Sound");
}
//Abstract method i.e. without body/implementation
abstract void sound();
}
Step 2: Now create another class name Cat which extends Sound class. Here we will implement abstract sound() method for Cat. Below is the code of Cat.java
class Cat extends Sound{
void sound(){
soundmessage();
System.out.println(" of Cat: Meow");
}
}
Step 3: In the same way we are creating another Lion class which extends Sound class. Here also we will implement the sound() method but for Lion. Below is the code of Lion.java:
class Lion extends Sound {
void sound(){
soundmessage();
System.out.println(" of Lion: Roar");
}
}
Step 4: Now create AnimalSound main class. Here first we will create object of Cat & Lion class and then we will call sound() method on these objects. Below is the code of AnimalSound.java
public class AnimalSound {
public static void main(String[] args) {
Cat cat = new Cat();
cat.sound();
Lion lion = new Lion();
lion.sound();
}
}
Output:
Now run the program and you will see sounds of Cat and Lion printed.
Animal Sound of Cat: Meow Animal Sound of Lion: Roar
Conclusion: So you can see how useful is Abstraction. We just define mixture of abstract and non-abstract methods in Abstract class and then implement abstract method in child class (i.e. sub class) according to requirement. In the end same method gives different result depending on Objects of which sub-class. Remember we can’t instantiate Abstract class as discussed earlier.
Example 2: In second Abstraction example we simply display a text “AbhiAndroid” by using an abstract method of an abstract Base class. In this, Child class extends the Base class and override the display method and then prints the text as shown in below example.
Here in this example we have provided lots of explanation in the code itself as comments.
Below is the code of Base.java
abstract class Base //abstract class
{
abstract void display(); //abstract method
}
Below is the code of Child.java and also main function of class
class Child extends Base //child class which extends the property of base class
{
void display() // override method of base class
{
System.out.println("AbhiAndroid"); //prints the text “AbhiAndroid” as an output
}
public static void main(String args[]) //main function of class
{
Child c=new Child(); //create an object of child class
c.display(); //call the display method of child class with the help of object
}
}
OUTPUT:
AbhiAndroid
Conclusion: In the above example, Base is abstract class that contain abstract method display(). Its implementation is provided by the Child class.
Below is the some major important points of abstraction in java.
Abstract class is quite similar to interface like both contain abstract method and also we can’t initiate both of them. But below are the some key differences between both the topics:
Abstract class:
Interface:
Premium Project Source Code:
Leave a Reply