Together with encapsulation, inheritance, and polymorphism, abstraction is one of the four fundamental concepts of object-oriented programming. Java is an object-oriented language, so it makes extensive use of abstraction to make complicated systems simpler. This essay will explore Abstraction in Java concept, its significance, and practical implementation techniques.
What is Abstraction in Java?
Since Java is an object-oriented programming language, abstraction is one of its key characteristics and fundamental building blocks. An abstract class and interface are used to implement abstraction in Java.
So how can we use Java to implement abstraction? Java offers the “abstract” non-access modifier to implement abstraction. Variables cannot be used with this abstract modifier; only classes and methods can.
The interface provides only method prototypes, not the actual implementation of the methods; in other words, it provides complete abstraction. Partial abstraction is offered by an abstract class, which prohibits the implementation of at least one method.
What is an Abstract Class?
An abstract class in Java is intended to be subclassed and cannot be instantiated on its own. It gives subclasses a common base from which to inherit field and method definitions, but it also permits subclasses to supply their implementations.
To help us understand it better, we can designate the attack method and the Bird class abstract as abstract:
class abstract Bird {
String name;
int size;
int strength;
// other properties go here
protected abstract void attack();
public String getName(){
return name;
}
}
What is an Abstract Method?
A method that is declared in a class but not defined is called an abstract method. For methods that need to be implemented in subclasses, it serves as a placeholder. It is employed to guarantee that subclasses carry out particular behaviors and to enforce a certain degree of consistency among related classes. When a method is declared as abstract, it means that an implementation for the method is not provided in the superclass; instead, it must be implemented in a subclass.
Advantages of Abstraction
- It makes things seem less complicated.
- It makes the application easier to maintain.
- It enhances the application’s modularity.
- reduces duplication of code and improves reusability.
- increases the maintainability and reusability of code.
- gives the user an intuitive and uncomplicated interface.
- keeps implementation specifics hidden and only displays pertinent data.
- increases security by blocking access to information about internal classes.
- helps to improve an application’s or program’s security by giving the user access to only the information that is necessary.
When to use abstract classes and abstract methods?
In certain cases, we will want to define a superclass that provides a complete implementation of each method, but still declares the structure of the given abstraction. At times, we may wish to develop a superclass that simply specifies a generalization form that all of its subclasses will use; the details will need to be filled in by each subclass.
Think of a traditional “shape” example, such as one from a game simulation or computer-aided design system. “Shape” is the basic type, and each shape has a color, size, and other attributes. This leads to the derivation (hereditary) of particular shapes, such as triangles, squares, circles, and so forth, each of which may have additional traits and behaviors. For instance, it is possible to flip some shapes. Certain behaviors might differ, such as when attempting to determine a shape’s area. Both the similarities and differences between the shapes are embodied in the type hierarchy.
Java Abstraction Example
Example 1:
// Java program to illustrate the
// concept of Abstraction
abstract class Shape {
String color;
// these are abstract methods
abstract double area();
public abstract String toString();
// abstract class can have the constructor
public Shape(String color)
{
System.out.println(“Shape constructor called”);
this.color = color;
}
// this is a concrete method
public String getColor() { return color; }
}
class Circle extends Shape {
double radius;
public Circle(String color, double radius)
{
// calling Shape constructor
super(color);
System.out.println(“Circle constructor called”);
this.radius = radius;
}
@Override double area()
{
return Math.PI * Math.pow(radius, 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 color, double length,
double width)
{
// calling Shape constructor
super(color);
System.out.println(“Rectangle constructor called”);
this.length = length;
this.width = width;
}
@Override double area() { return length * width; }
@Override public String toString()
{
return “Rectangle color 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());
}
}
Example 2:
// Java Program to implement
// Java Abstraction
// Abstract Class declared
abstract class Animal {
private String name;
public Animal(String name) { this.name = name; }
public abstract void makeSound();
public String getName() { return name; }
}
// Abstracted class
class Dog extends Animal {
public Dog(String name) { super(name); }
public void makeSound()
{
System.out.println(getName() + ” barks”);
}
}
// Abstracted class
class Cat extends Animal {
public Cat(String name) { super(name); }
public void makeSound()
{
System.out.println(getName() + ” meows”);
}
}
// Driver Class
public class AbstractionExample {
// Main Function
public static void main(String[] args)
{
Animal myDog = new Dog(“Buddy”);
Animal myCat = new Cat(“Fluffy”);
myDog.makeSound();
myCat.makeSound();
}
}
Interface
Another way to implement abstraction in Java is through interfaces. The main distinction is that Java classes can achieve 100% abstraction through the use of interfaces. Interfaces, whether in Java or another language, are composed of variables and methods, but they do not have a method body. In Java, interfaces can be used for interface implementation in addition to abstraction.
// Define an interface named Shape
interface Shape {
double calculateArea(); // Abstract method for
// calculating the area
}
// Implement the interface in a class named Circle
class Circle implements Shape {
private double radius;
// Constructor for Circle
public Circle(double radius) { this.radius = radius; }
// Implementing the abstract method from the Shape
// interface
public double calculateArea()
{
return Math.PI * radius * radius;
}
}
// Implement the interface in a class named Rectangle
class Rectangle implements Shape {
private double length;
private double width;
// Constructor for Rectangle
public Rectangle(double length, double width)
{
this.length = length;
this.width = width;
}
// Implementing the abstract method from the Shape
// interface
public double calculateArea() { return length * width; }
}
// Main class to test the program
public class Main {
public static void main(String[] args)
{
// Creating instances of Circle and Rectangle
Circle myCircle = new Circle(5.0);
Rectangle myRectangle = new Rectangle(4.0, 6.0);
// Calculating and printing the areas
System.out.println(“Area of Circle: “
+ myCircle.calculateArea());
System.out.println(“Area of Rectangle: “
+ myRectangle.calculateArea());
}
}
Conclusion
Java abstraction hides implementation details and exposes only the features that are necessary to simplify complex systems. Java offers both complete and partial abstraction through the use of abstract classes and interfaces, improving the maintainability, modularity, and security of code. As demonstrated by the given examples, these features assist developers in creating user-friendly interfaces and consistent behaviors across related classes.
