Abstraction & Interface in Java with Example

Everything You Need to Know About Hiding Complexity in OOP. Complexity becomes one of the most pressing problems for developers as software systems increase in size and complexity. Object-Oriented Programming (OOP) has a number of features that address the problem, and one of the main ones is abstraction. In Java, abstraction helps developers to build a program that is more understandable and flexible when changes are required.

In this text, I´ll show what abstraction in Java is, why we should use it, and how to implement it by means of abstract classes and interfaces with real examples.

Understanding Abstraction

Abstraction: Abstraction is the concept of hiding the internal details and showing only the necessary features of an object. They can interact with an object without having to understand how that object does what it says it will.

Abstraction in Java is like what an object does instead of how it is done. This disconnection of behavior and its implementation makes it easier to manage complexity and structure our code. Real-World Analogy

Consider an ATM machine. A user can take out money, check a balance or deposit cash by selecting buttons on the screen. All the internal operations like verifying an account, interacting with the database and doing security checks are abstracted from the end user. The user is only presented with the operations possible. This is a great example of abstraction.

Why You Should Learn About Abstraction in Java

There are many reasons why abstraction is important for the development of Java applications: 1. Reduces Complexity

Aspects of a system that are not relevant at a certain level of abstraction can be suppressed, which simplifies systems and aids in their understanding.

Improves Code Maintainability

Changes of implementation do not influence the user, as long as the abstract structure stays unchanged.

Enhances Security

And sensitive logic and data are never directly accessible.

Supports Scalability

It is easy to add new features with little modification of code.

Encourages Loose Coupling

Classes depend on abstractions not on the implementations.

Abstraction in Java: Key Mechanisms

Java gives the way to obtain abstraction in two ways:

Abstract Classes

Interfaces

They each have their own place and a time for being applied.

Abstract Classes in Java 

An abstract class is a class that cannot be instantiated and may contain abstract methods  (methods without a body). It can also include fully implemented methods. Characteristics of Abstract Classes 

• Declared using the abstract keyword 

• Can contain both abstract and non-abstract methods 

• Can have instance variables and constructors 

• Can provide partial abstraction 

Example of Abstract Class 

abstract class BankAccount { 

abstract void calculateInterest(); 

void accountType() { 

System.out.println("This is a bank account"); 

} 

} 

class SavingsAccount extends BankAccount { 

void calculateInterest() { 

System.out.println("Interest calculated for savings account"); 

} 

} 

public class Main { 

public static void main(String[] args) { 

BankAccount account = new SavingsAccount(); 

account.calculateInterest(); 

account.accountType(); 

} 

}

Explanation 

In this example: 

• BankAccount defines the structure and expected behavior 

• calculateInterest() is abstract because interest calculation differs across accounts • SavingsAccount provides its own implementation 

• The user interacts with the abstract class reference, not the concrete class ________________________________________ 

Interfaces in Java 

An interface represents a fully abstract structure that defines a set of methods a class must implement. Interfaces help achieve complete abstraction. 

Key Features of Interfaces 

• Declared using the interface keyword 

• Supports multiple inheritance 

• Variables are public, static, and final 

Example of Interface 

interface Vehicle { 

void start(); 

void stop(); 

} 

class Bike implements Vehicle { 

public void start() { 

System.out.println("Bike starts with a self-start button"); 

} 

public void stop() { 

System.out.println("Bike stops using brakes"); 

} 

} 

class Car implements Vehicle { 

public void start() { 

System.out.println("Car starts using a key"); 

}

public void stop() { 

System.out.println("Car stops using brakes"); 

} 

} 

public class Main { 

public static void main(String[] args) { 

Vehicle v = new Car(); 

v.start(); 

v.stop(); 

} 

} 

Explanation 

Vehicle defines common behavior for all vehicles 

Each class provides its own implementation 

The program can easily switch implementations without changing logic 

When to Use Abstract Class vs Interface 

Use an abstract class when: 

• You need instance variables or constructors 

• You want to provide default behavior 

Use an interface when: 

• You need multiple inheritance 

• You expect frequent implementation changes 

Abstraction in Real-Time Java Applications

Abstraction isn't entirely uncommon in real Java frameworks:

• JDBC employs interfaces such as Connection and Statement

• The Sprint Framework uses Interfaces heavily for DI (Dependency Injection)Collections Framework also uses interfaces such as List, Set andMap

These abstractions let developers work at a higher level without concerning themselves with difficult implementation details.

Advantages of Abstraction in Java

• Improves code reusability

• Allows flexible and extendable applications

• Enhances testability

• Clean architecture and design patterns are supported

• Reduces dependency between modules

Common Mistakes to Avoid

• Straining the concept of the abstract and rendering it meaningless

• Creating unnecessary interfaces

• Mixing abstraction with implementation

• Ignoring proper naming conventions

Conclusion

Abstraction forms the basis of Java’s object-oriented thought. It allows software engineers to develop robust, maintainable, and scalable programs. By decoupling what an object does and how it does it, abstraction facilitates the control of complexity in a large-scale system.

Wield abstraction either through abstract classes or through interfaces, and you’ll write professional, clean, Java code that scales. A good understanding of abstraction not only makes you a better coder but also improves software design thinking.

Do visit our channel to learn more: SevenMentor

Author:-

Pooja Ghodekar