抽象类

# 抽象类

每个子类在继承父类的时候，可以复写父类的方法，这样就实现了多态。

# 抽象类出现之前的问题

有时，会有这样一种情况：父类的方法是没有实际意义的，纯粹是用来被子类覆写的；但是，父类在定义方法的时候，必须实现方法的语句，否则会编译报错：例如定义了这样一个类

public class LearnAbstract {
  public void run();
}

1
2
3

运行结果：

$ javac LearnAbstract.java
LearnAbstract.java:2: 错误: 缺少方法主体, 或声明抽象
  public void run();
              ^
1 个错误

1
2
3
4
5

# 抽象类

能否去掉方法的执行语句？可以。如果父类的方法本身不需要实现任何功能，仅仅是为了定义方法签名，目的是让子类去覆写它，那么，可以把父类的方法声明为抽象方法：

public abstract void run();

把一个方法声明为 abstract，表示它是一个抽象方法，本身没有实现任何方法语句。因为这个抽象方法本身是无法执行的，所以，Person类也无法被实例化。编译器会告诉我们，无法编译 Person类，因为它包含抽象方法。

public class LearnAbstract {
  public static void main(String[] args) {
    new TestAb();
  }
}


abstract class TestAb {
  public abstract void run();
}

1
2
3
4
5
6
7
8
9
10

注意：必须把抽象方法的类，也声明为 abstract，才能正确编译。用 abstract 修饰的类就是抽象类。

运行结果：

> javac LearnAbstract.java
LearnAbstract.java:3: 错误: TestAb是抽象的; 无法实例化
    new TestAb();
    ^
1 个错误

1
2
3
4
5

# 使用抽象类的好处和注意点

好处：因为抽象类本身被设计成只能用于被继承，因此，抽象类可以强迫子类实现其定义的抽象方法，否则编译会报错。因此，抽象方法实际上相当于定义了“规范”。

注意点：

定义了抽象方法的 class 必须被定义为抽象类，但可以定义一个不含抽象方法的抽象类
抽象类不能被实例化
从抽象类继承的子类必须实现抽象方法；
抽象类的构造方法定义为 Protected, 因为它只被子类使用。创建一个具体子类的实例时，它的父类的构造方法会被调用，以初始化父类中定义的数据域。
如果不实现抽象方法，则该子类必须也得是一个抽象类。所以严格来说，抽象类是强迫其非抽象子类，实现其定义的抽象方法
子类可以覆写父类的方法，并将其定义为 abstract（少用）

# 抽象类举例

我们举一个实际的例子，看看抽象类的应用。我们后续会学习数值包装类、BigInteger 和 BigDecimal 类，这些类有共同的方法 byteValue()、shortValue()、intValue()、longValue() ,floatValue() 和 doubleValue()，分别从这些类的对象返回 byte、short, int, long, float 以及 double 值。这些共同的方法实际上在 Number 类中定义，该类是数值包装类、Biglnteger 和 BigDecimal 类的父类，如图 13-2 所示。

由于 intValue() 等方法不能在 Number 类中给出实现，它们在 Number 类中被定义为抽象方法。因此 Number 类是一个抽象类。

由于 intValue()、longValue() ,floatValue()和 doubleValue()等方法不能在 Number 类中给出实现，它们在 Number 类中被定义为抽象方法。因此 Number 类是一个抽象类。Number 类的源码如下

package java.lang;

public abstract class Number implements java.io.Serializable {

    public abstract int intValue();
    public abstract long longValue();
    public abstract float floatValue();
    public abstract double doubleValue();

    public byte byteValue() {
        return (byte)intValue();
    }

    public short shortValue() {
        return (short)intValue();
    }

    private static final long serialVersionUID = -8742448824652078965L;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

byteValue() 和 shortValue() 方法的实现从 intValue() 方法强制转换而来

# 面向抽象编程

当我们定义了抽象父类 Person，以及具体的 Student、Teacher 子类的时候，我们可以通过抽象类 Person 类型去引用具体的子类的实例：

Person s = new Student();
Person t = new Teacher();

1
2

这种引用抽象类的好处在于，我们对其进行方法调用，并不关心 Person 类型变量的具体子类型：

// 不关心Person变量的具体子类型:
s.run();
t.run();

1
2
3

同样的代码，如果引用的是一个新的子类，我们仍然不关心具体类型：

// 同样不关心新的子类是如何实现run()方法的：
Person e = new Employee();
e.run();

1
2
3

这种尽量引用高层类型，避免引用实际子类型的方式，称之为面向抽象编程。

面向抽象编程的本质就是：

上层代码只定义规范（例如：abstract class Person）；
不需要子类就可以实现业务逻辑（正常编译）；
具体的业务逻辑由不同的子类实现，调用者并不关心。

上次更新: 2024/9/30 20:09:39

← class 版本接口→