Introduce Java Abstraction and give examples
Java abstraction is a fundamental concept in object-oriented programming that allows you to hide the complex implementation details of a system and expose only the necessary parts to the user. This helps in reducing complexity and increasing efficiency by allowing programmers to focus on interactions at a higher level without needing to understand the underlying code.
In Java, abstraction can be achieved using:
Abstract Classes: These are classes that cannot be instantiated on their own and may contain abstract methods (methods without a body) as well as concrete methods (methods with a body).
Interfaces: An interface is a reference type in Java that is similar to a class but can only contain constants, method signatures, default methods, static methods, and nested types. Interfaces cannot contain instance fields or constructors.
// Abstract class
abstract class Animal {
// Abstract method (does not have a body)
abstract void sound();
// Concrete method
void sleep() {
System.out.println("Sleeping...");
}
}
// Subclass (inheriting from Animal)
class Dog extends Animal {
// Implementing the abstract method
void sound() {
System.out.println("Bark");
}
}
// Subclass (inheriting from Animal)
class Cat extends Animal {
// Implementing the abstract method
void sound() {
System.out.println("Meow");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
Animal myCat = new Cat();
myDog.sound(); // Output: Bark
myDog.sleep(); // Output: Sleeping...
myCat.sound(); // Output: Meow
myCat.sleep(); // Output: Sleeping...
}
}
In this example, the Animal
class is an abstract class with an abstract method sound()
. The Dog
and Cat
classes extend Animal
and provide their own implementations of the sound()
method. The sleep()
method is a concrete method that can be used by all subclasses.
// Interface
interface Vehicle {
void start();
void stop();
}
// Class implementing the Vehicle interface
class Car implements Vehicle {
public void start() {
System.out.println("Car is starting");
}
public void stop() {
System.out.println("Car is stopping");
}
}
// Class implementing the Vehicle interface
class Bike implements Vehicle {
public void start() {
System.out.println("Bike is starting");
}
public void stop() {
System.out.println("Bike is stopping");
}
}
public class Main {
public static void main(String[] args) {
Vehicle myCar = new Car();
Vehicle myBike = new Bike();
myCar.start(); // Output: Car is starting
myCar.stop(); // Output: Car is stopping
myBike.start(); // Output: Bike is starting
myBike.stop(); // Output: Bike is stopping
}
}
In this example, the Vehicle
interface defines two methods: start()
and stop()
. The Car
and Bike
classes implement the Vehicle
interface and provide their own implementations of these methods.
In summary, Java abstraction is a powerful feature that helps in designing systems that are easier to understand, maintain, and extend.