How to Implement Data Abstraction in Java?

Abstraction, polymorphism, encapsulation, and inheritance are the four basic elements of object-oriented programming. One of them, Data Abstraction, will be discussed in detail in the following article. We will also learn how to perform data abstraction in Java.

What is Data Abstraction?

Data abstraction is the characteristic feature where just the most important details are shown to the user. The user is kept unaware of the trivial or non-essential details. For example, an automobile is considered as a whole rather than its distinct parts. The practice of identifying only the needed attributes of an item while discarding the extraneous information is known as data abstraction. 

In simple terms, data abstraction displays important items to the user while keeping insignificant elements hidden.

We use the keyword “abstract” to implement abstraction with the help of classes and interfaces. We can have both abstract and concrete methods in abstract classes.

What are Abstract Classes?

In Object-Oriented Programming, an abstract class is a class that declares one or more abstract methods. The sole distinction between abstract and regular Java classes is that abstract classes contain the abstract keyword, whereas regular Java classes do not. For the declaration of an abstract class, we use the abstract keyword before its class name. There can be both abstract and concrete methods in classes. However, abstract methods can’t be present in regular classes. A class with at least one abstract method is referred to as an abstract class.

Its syntax is: 

public abstract class Name_of_Class  

{  

public abstract Name_of_Method();  

}  

 

An example of implementing abstract class is: 

 

//abstract class naming

abstract class DemoClass  

{  

//abstract method naming

abstract void disp();  

}  

//proceeding with the abstract class  

public class MainClass extends DemoClass  

{  

//defining the abstract class’s method body

void display()  

{  

System.out.println(“Abstract method called.”);  

}  

public static void main(String[] args)  

{    

MainClass obj = new MainClass ();  

//invoking abstract method  

obj.display();  

}  

}  

</> Copy Code

To list pointwise: 

• A class must be defined as abstract if it has at least one abstract method.
• A class that has been declared abstract cannot be instantiated.
• You must inherit an abstract class from another class and supply implementations for its abstract methods to utilise it.
• You must supply implementations for all abstract methods in an abstract class if you inherit it.

What are Abstract Methods?

An abstract method has only the method declaration and no implementation. An abstract method can be represented by a method without a body of its own. Abstract methods must be declared exclusively within abstract classes.

If you want a class to have a method but the actual implementation of that method to be determined by child classes, designate the method as an abstract in the parent class.

Advantages of Data Abstraction in Object-Oriented Programming

• In Object-Oriented Programming, abstraction reduces the complexity of the programme design and the process of its implementation on software.
• The foremost advantage of implementing abstraction in Java programming is that users can then easily organise classes based on similarities, such as siblings, and therefore, inheritance of data and migration of data becomes easy and feasible.
• Inheritance is possible. For example: 

/* File name : DemoAbstract.java */

public class DemoAbstract {
   public static void main(String [] args) {
      /* the following cannot be written and initiate errors */
      employee e = new employee(“Peter D.”, “Hartford, CT”, 35);
      System.out.println(“\n Use Employee reference and call MailCheck–“);
      e.mailCheck();
   }
}

This shows the following error:

Employee.java:46: Employee is abstract; cannot be instantiated

      employee e = new employee(“Peter D.”, “Hartford, CT”, 35);
                   ^
1 error

So we use the abstract class usage as:

/* File name : employee.java */
public abstract class employee {
   private String N;
   private String Add;
   private int Num;

   public Employee(String N, String Add, int Num) {
      System.out.println(“Constructing an employee”);
      this.name = N;
      this.address = Add;
      this.number = Num;
   }
   
   public double compute_pay() {
     System.out.println(“Inside employee compute_pay”);
     return 0.0;
   }
   
   public void Mailcheck() {
      System.out.println(“Mailing a check to ” + this.name + ” ” + this.address);
   }

   public String toString() {
      return N + ” ” + Add + ” ” + N;
   }

   public String getName() {
      return N;
   }
 
   public String getAddress() {
      return Add;
   }
   
   public void setAddress(String newAddress) {
      Add = newAddress;
   }
 
   public int getNumber() {
      return Num;
   }
}

</> Copy Code

When do we use abstract class or abstract methods? 

When we consider the general  example of “shapes”, we may imagine it being used in reference to a computer-aided design system or for a video game simulation. The fundamental type referred to here is a “shape,” with every shape having its own color attributes, size, etc. Specific classes of shapes-circle, square, triangle, etc., are derived (inherited) from this, each of which may have extra unique properties and behaviors. Certain shapes, for example, can be symmetrical, while others are not. Both the similarities and distinct differences between the shapes are embodied in the type hierarchy.

Therefore, shape can be analogous to an abstract class, while the different types of shapes can be denoted as concrete classes. 

Here is a real-life scenario to explain abstract classes:

// Java program to demonstrate Abstraction

abstract class shape {

String colour;

 

abstract double area();

public abstract String toString();

 

// abstract class can have the constructor

public shape(String colour)
{
System.out.println(“Shape constructor called”);
this.colour = colour;
}

// this is a concrete method
public String getColour() { return colour; }
}
class Circle extends shape {
double r;

public Circle(String colour, double(r)
{

// calling Shape constructor
super(colour);
System.out.println(“Circle constructor called”);
this.r = r;
}

@Override double area()
{
return Math.PI * Math.pow(r, 2);
}

@Override public String toString()
{
return “Circle color is ” + super.getColor()
+ “and area is : ” + area();
}
}
class Rectangle extends shape {

double length;
double width;

public Rectangle(String colour, double length,
double width)
{
// calling Shape constructor
super(colour);
System.out.println(“Rectangle constructor called”);
this.length = length;
this.width = width;
}

@Override double area() { return length * width; }

@Override public String toString()
{
return “Rectangle colour is ” + super.getcolor()
+ “and area is : ” + area();
}
}
public class Test {
public static void main(String[] args)
{
Shape s1 = new Circle(“Red”, 2.2);
Shape s2 = new Rectangle(“Yellow”, 2, 4);

System.out.println(s1.toString());
System.out.println(s2.toString());
}
}

This segment of code is a modified version of the one here.

A code snippet of a program where data abstraction in Java is used:

 // Abstraction in Java
abstract class ElecBill
{
    //abstract method
    abstract float compBill();
}

class Comm extends ElecBill
{
    
    float compBill() {
        return 1.00*100;
    }
}
class Domestic extends ElecBill
{
    float compBill() {
        return 0.50*75;
    }
}

</> Copy Code

Conclusion