Java interfaces and abstract classes: the way to achieve code reuse

"Java Interfaces and Abstract Classes: How to Implement Code Reuse" is an article carefully written by PHP editor Xiaoxin. From the perspective of Java programming, this article deeply discusses the importance and application of interfaces and abstract classes in code reuse. Through the analysis and comparison of example codes, it helps readers better understand how to use interfaces and abstract classes to achieve code reuse and improve code reusability and maintainability. This article is a rare learning material for readers who want to learn Java programming systematically.

• The interface only contains abstract methods and has no concrete implementation.
• All methods in an interface are implicitly declared public and abstract.
• A class can implement multiple interfaces.
• Interfaces are mainly used to define contracts and specify the behaviors that classes must implement.
• The methods in the interface are not implemented and therefore cannot be used directly. They must be implemented by the class that implements it.

Abstract class

• Abstract classes can contain abstract methods and concrete methods.
• Abstract methods in abstract classes must be implemented by subclasses.
• Concrete methods in abstract classes provide default implementations.
• A class can only inherit one abstract class.
• Abstract classes are usually used to define common behavior and provide partial implementation.
• Concrete methods of abstract classes can be overridden by subclasses, while abstract methods must be implemented.

Choose interface or abstract class

Choosing an interface or an abstract class depends on the specific scenario:

• If you need to define a contract and do not need a specific implementation, choose an interface.
• If you need to define common behavior and provide partial implementation, choose an abstract class.
• If you need the class to support multiple inheritance, select the interface.
• If you need a class to have a stricter inheritance hierarchy, choose an abstract class.

Code reuse

Through interfaces and abstract classes, we can achieve code reuse, reduce redundancy and improve flexibility:

• Interfaces allow different classes to implement the same contract, thus promoting code reuse and pluggability.
• Abstract classes provide partial implementation, and subclasses can extend this implementation and customize specific behaviors to avoid writing the same code repeatedly.

Polymorphism

Interfaces and abstract classes also facilitate polymorphism, the ability to handle different types of objects in a uniform way:

• The type defined by an interface is the common parent type of all classes that implement the interface.
• The type defined by an abstract class is the common parent type of all subclasses.
• This allows objects to be handled polymorphically without worrying about their concrete types.

Example

Interface example:

public interface Shape {
double getArea();
double getPerimeter();
}

Abstract class example:

public abstract class Animal {
protected String name;

public abstract void speak();

public void eat() {
System.out.println("Animal is eating.");
}
}

Code reuse example:

ClassesCircle and Square implement getArea() and getPerimeter() by implementing the Shape interface method, thereby reusing the code for calculating the area and perimeter of a shape.

public class Circle implements Shape {
private double radius;

@Override
public double getArea() {
return Math.PI * radius * radius;
}

@Override
public double getPerimeter() {
return 2 * Math.PI * radius;
}
}

public class Square implements Shape {
private double side;

@Override
public double getArea() {
return side * side;
}

@Override
public double getPerimeter() {
return 4 * side;
}
}

Polymorphism example:

We can use Shape type variables to store Circle and Square objects and call their methods in a polymorphic manner.

Shape shape1 = new Circle(5);
Shape shape2 = new Square(10);

System.out.println(shape1.getArea()); // 78.53981633974483
System.out.println(shape2.getPerimeter()); // 40.0

By leveraging interfaces and abstract classes, Javaprogrammers can achieve code reuse and polymorphism, thereby writing more flexible and maintainable code.

The above is the detailed content of Java interfaces and abstract classes: the way to achieve code reuse. For more information, please follow other related articles on the PHP Chinese website!