【JAVA】《接口，抽象方法，抽象类 》之四 、开发实践

一、接口

1.1、接口的概念
1.2、接口的作用：
1.3、接口应用：
1.4、接口实践
详情参考【JAVA】《接口，抽象方法，抽象类 》之一、接口详解

二、抽象方法

2.1、抽象方法概念
2.2、抽象方法的特点：
2.3、抽象方法的作用：
2.4、抽象方法的应用：
2.5、抽象方法的实践：
2.6、使用抽象方法的注意事项
详情参考【JAVA】《接口，抽象方法，抽象类 》之二 、抽象方法详解

三、抽象类

如果一个类继承了抽象类或实现了接口，并且其中包含抽象方法，那么子类必须实现这些抽象方法，除非子类自己也声明为抽象类。下面介绍一下抽象类。
3.1、抽象类的概念
3.2、抽象类的特点：
3.3、抽象类的作用：
3.4、抽象类的应用：
3.5、抽象类的注意事项：
详情参考【JAVA】《接口，抽象方法，抽象类 》之三 、抽象类详解

四、开发实践

应用场景：
有一种设计模式叫 “模板方法模式”（Template Method Pattern）。在模板方法模式中，一个抽象类定义了一个模板方法，该方法包含了算法的框架，其中的某些步骤由子类实现。这样一来，子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤，从而实现算法的定制化。

在下面例子中，抽象类 MyAbstractClass 中的 normalMethod() 就是模板方法，它定义了算法的框架，而抽象方法 abstractMethod() 则是由子类实现的可定制的步骤。这种模式允许子类通过实现抽象方法来定制算法的具体步骤，同时又能够共享算法的通用部分。

这种设计模式的应用场景是在需要一种默认的行为，但这种行为又可能因为不同的子类而不同的情况下。抽象类提供了一个默认的行为实现，同时通过接口定义了子类必须实现的抽象方法，而具体的实现则由子类完成。这样一来，所有的子类都可以通过继承抽象类来获得默认的行为，同时又能够自由地实现接口定义的抽象方法。

4.1、定义接口：

首先定义一个接口 MyInterface，其中包含一个抽象方 abstractMethod()。

interface MyInterface {
    void abstractMethod();
}
1
2
3

4.2、实现抽象类：

接着定义一个抽象类 MyAbstractClass，它实现了 MyInterface 接口，但并未提供 abstractMethod() 的具体实现。而是在其中定义了一个普通方法 normalMethod()，在该方法中调用了 abstractMethod()。

abstract class MyAbstractClass implements MyInterface {
    void normalMethod() {
        System.out.println("Calling abstractMethod() from MyAbstractClass");
        abstractMethod(); // 调用接口中的抽象方法
    }
}
1
2
3
4
5
6

4.3、创建具体实现类：

接下来创建两个具体的类 ClassA 和 ClassB，它们都继承自 MyAbstractClass，并且实现了接口中的抽象方法 abstractMethod()。

class ClassA extends MyAbstractClass {
    @Override
    public void abstractMethod() {
        System.out.println("Implementation of abstractMethod() in ClassA");
    }
}

class ClassB extends MyAbstractClass {
    @Override
    public void abstractMethod() {
        System.out.println("Implementation of abstractMethod() in ClassB");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

4.4、使用示例：

在 Main 类中创建对象并进行测试。

public class Main {
    public static void main(String[] args) {
        MyAbstractClass objA = new ClassA();
        MyAbstractClass objB = new ClassB();

        objA.normalMethod(); // 输出 ClassA 中的实现
        objB.normalMethod(); // 输出 ClassB 中的实现
    }
}
1
2
3
4
5
6
7
8
9

4.5、调用流程：

在 Main 类中创建 objA 对象时，实际上是创建了 ClassA 类的实例，并将其向上转型为 MyAbstractClass 类型。

调用 objA.normalMethod() 方法时，会执行 MyAbstractClass 中的 normalMethod() 方法。

在 normalMethod() 方法中，调用了 abstractMethod() 方法。由于 objA 的实际类型是 ClassA，因此会执行 ClassA 中的 abstractMethod() 方法，输出

"Implementation of abstractMethod() in ClassA"
1

同理，创建 objB 对象时，实际上是创建了 ClassB 类的实例，并将其向上转型为 MyAbstractClass 类型。调用 objB.normalMethod() 方法时，会执行 MyAbstractClass 中的 normalMethod() 方法。

在 normalMethod() 方法中，调用了 abstractMethod() 方法。由于 objB 的实际类型是 ClassB，因此会执行 ClassB 中的 abstractMethod() 方法，输出

"Implementation of abstractMethod() in ClassB"
1

关于其向上转型之后怎么识别可参考【多态和继承应用】之向上转型和向下转型 instanceof的使用