2.3. 接口与抽象类

接口和抽象类是 Java 中两种实现抽象和多态的方法。它们之间有一些区别，但也有一些相似之处。这一节我们将通过详细的例子来更深入地了解接口和抽象类。
2.3.1. 接口

接口可以定义一组方法签名，但不能包含方法的实现。一个类可以实现多个接口，实现接口的类必须实现接口中定义的所有方法。
定义接口：

1. interface InterfaceName {
2.     ReturnType methodName(Parameters);
3. }

复制代码

实现接口：

1. class ClassName implements InterfaceName {
2.     // 实现接口中的所有方法
3. }

复制代码

示例1：接口

1. interface Drawable {
2.     void draw();
3. }
5. class Circle implements Drawable {
6.     double radius;
8.     @Override
9.     public void draw() {
10.         System.out.println("Drawing a circle with radius " + radius);
11.     }
12. }
14. class Square implements Drawable {
15.     double sideLength;
17.     @Override
18.     public void draw() {
19.         System.out.println("Drawing a square with side length " + sideLength);
20.     }
21. }
23. class Main {
24.     public static void main(String[] args) {
25.         Circle circle = new Circle();
26.         circle.radius = 5;
27.         circle.draw(); // 实现接口的方法
29.         Square square = new Square();
30.         square.sideLength = 4;
31.         square.draw(); // 实现接口的方法
32.     }
33. }

复制代码

接口还可以具有默认方法和静态方法，这些方法可以包含实现。

1. interface InterfaceName {
2.     default ReturnType defaultMethodName(Parameters) {
3.         // 默认方法的实现
4.     }
6.     static ReturnType staticMethodName(Parameters) {
7.         // 静态方法的实现
8.     }
9. }

复制代码

2.3.2. 抽象类

抽象类可以包含抽象方法（没有实现的方法）和具体方法。子类必须实现抽象类中的所有抽象方法。一个类只能继承一个抽象类。
定义抽象类：

1. abstract class AbstractClassName {
2.     abstract ReturnType methodName(Parameters);
4.     ReturnType methodName(Parameters) {
5.         // 具体方法的实现
6.     }
7. }

复制代码

继承抽象类：

1. class ClassName extends AbstractClassName {
2.     // 实现抽象类中的所有抽象方法
3. }

复制代码

示例2：抽象类

1. abstract class Shape {
2.     abstract double getArea();
4.     void printArea() {
5.         System.out.println("The area is " + getArea());
6.     }
7. }
9. class Circle extends Shape {
10.     double radius;
12.     @Override
13.     double getArea() {
14.         return Math.PI * radius * radius;
15.     }
16. }
18. class Square extends Shape {
19.     double sideLength;
21.     @Override
22.     double getArea() {
23.         return sideLength * sideLength;
24.     }
25. }
27. class Main {
28.     public static void main(String[] args) {
29.         Circle circle = new Circle();
30.         circle.radius = 5;
31.         circle.printArea(); // 继承自抽象类的具体方法
33.         Square square = new Square();
34.         square.sideLength = 4;
35.         square.printArea(); // 继承自抽象类的具体方法
36.     }
37. }

复制代码

2.3.3. 接口与抽象类的区别

• 一个类可以实现多个接口，但只能继承一个抽象类。
  
• 接口中的方法默认是 public，不能有其他访问修饰符。抽象类中的方法可以有不同的访问修饰符。
  
• 接口不能包含实例变量（成员变量），只能声明静态常量。抽象类可以包含实例变量。
  
• 接口支持默认方法和静态方法，抽象类不支持默认方法。
  

2.3.4. 何时使用接口和抽象类？

• 当你想要定义一组相关对象应该实现的方法，但不关心具体的实现时，使用接口。
  
• 当你想要为一组相关对象提供共享的实现和行为时，使用抽象类。
  
• 如果需要实现多个不同的行为组合，使用接口。因为 Java 不支持多继承，所以不能继承多个抽象类，但可以实现多个接口。
  

2.3.5. 小结

通过本节的学习，我们了解了接口和抽象类的概念以及它们之间的区别。接口和抽象类都可以实现抽象和多态，选择使用哪个取决于具体的需求和设计。
我们学习了如何定义接口和抽象类，如何使用它们来实现多态，并通过具体的例子加深了对这两个概念的理解。
在实际开发中，根据具体的应用场景和需求，合理地使用接口和抽象类，可以帮助我们设计出更加灵活、可扩展和易于维护的代码。


推荐阅读：
https://mp.weixin.qq.com/s/dV2JzXfgjDdCmWRmE0glDA
https://mp.weixin.qq.com/s/an83QZOWXHqll3SGPYTL5g


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！