Abstraction
Abstraction
Abstraction is one of the fundamental concepts in object-oriented programming, and Java supports abstraction through abstract classes and interfaces.
Abstraction is the process of hiding the implementation details and showing only the essential features of an object to the user. In Java, abstraction is achieved through the following mechanisms:
- Abstract classes: An abstract class is a class that cannot be instantiated, but can be subclassed. It is used to define common characteristics of a group of subclasses, and can contain both abstract and non-abstract methods. Abstract methods are declared without a body and are implemented by the subclasses. The purpose of an abstract class is to provide a common interface for a group of related classes.
- Interfaces: An interface is a collection of abstract methods and constant variables. It provides a way to achieve abstraction by specifying a set of methods that a class must implement. An interface is similar to an abstract class, but it cannot contain any implementation code. A class can implement one or more interfaces, and must provide an implementation for all of the abstract methods declared in those interfaces.
Abstraction helps to achieve two important goals in software design: modularity and flexibility. By hiding the implementation details of an object, we can create a modular design where different parts of the system can be developed independently. This makes the code easier to maintain and modify. Additionally, abstraction makes the system more flexible, because it allows us to change the implementation of an object without affecting the rest of the system that uses that object.
In summary, abstraction is an important concept in Java and object-oriented programming, and is achieved through abstract classes and interfaces. It helps to achieve modularity and flexibility in software design.
Abstract class in Java:
In Java, an abstract class is a class that cannot be instantiated, but can be subclassed. It is used to define common characteristics of a group of subclasses, and can contain both abstract and non-abstract methods.
An abstract class is declared using the abstract keyword, and can have any number of abstract and non-abstract methods. An abstract method is a method that is declared without a body, and must be implemented by any concrete subclass of the abstract class. Non-abstract methods can have a body and can be inherited by the subclasses without any changes.
Here is an example of an abstract class in Java:
public abstract class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void makeSound();
}
In this example, Animal is an abstract class that has a private instance variable name, a constructor, two getter/setter methods, and an abstract method makeSound(). Any concrete subclass of Animal must implement the makeSound() method.
Here is an example of a concrete subclass of Animal:
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
public void makeSound() {
System.out.println("Woof!");
}
}
In this example, Dog is a concrete subclass of Animal that implements the makeSound() method.
Abstract classes are useful when you want to define a common interface or behavior for a group of related classes, without providing a specific implementation. They allow you to create a hierarchy of classes that share a common interface, but provide different implementations of the abstract methods.