2023-HIT-软件构造1 关于 checkRep() 的继承和 Java 多态的思考

近几天在进行 软构实验3 的实现。由于 Lab3 提倡代码的复用，我对于 checkRep() 方法的继承进行了一些尝试。在此期间踩了不少坑，同时发现这个问题和 Java 的多态机制有很大的联系，和我之前进行的 C++ 编程有着很大的不同，在此记录一下解决问题的过程和思考。

1. equals() 方法在继承语境下的实现

这次踩坑的起因是在实现 CentralObject 时，我发现各个具体的类都有“名称”这一个属性，于是设计了一个公共的接口 CentralObject 来定义这个操作，并且用一个抽象类 AbstractCentralObject 来实现这些公共的操作，比如 getName() 等、

但是当实现 AbstractCentralObject 时，遇到了一个问题，我最初实现的代码是这样的：

@Override
public boolean equals(Object obj) {
    boolean result = false;
    if (obj instanceof AbstractCentralObject) {
        final AbstractCentralObject abstractCentralObject = (AbstractCentralObject) obj;
        result = this.name.equals(abstractCentralObject.name);
    }
    return result;
}

 这种写法在平时并没有发现有很大的问题，但是当检查代码时突然想到 instanceof 这个关键字在 Java 中的作用是检查当前对象是否是当前类或者是当前类的子类。而在这个应用中，这样的操作是不正确的，因为一个 Person 类和一个 Stellar 类即使名称相同，也不应当被判定是相等的。编写一段测试代码进行验证：

final Person person = new Person("Test");
final Stellar stellar = new Stellar("Test", BigDecimal.ONE, BigDecimal.ONE);
assertNotEquals(person, stellar);

得到结果如下：

 这显然是不符合要求的。回顾 PPT 发现，在父类中用 instanceof 关键字判断子类是不可取的，因此 instanceof 这种判断方式不适用于这种情况。查阅相关资料和 Java API，发现 getClass() 方法似乎适用于这种情况，getClass() 方法的文档如下：

    /**
     * Returns the runtime class of this {@code Object}. The returned
     * {@code Class} object is the object that is locked by {@code
     * static synchronized} methods of the represented class.
     *
     * <p><b>The actual result type is {@code Class<? extends |X|>}
     * where {@code |X|} is the erasure of the static type of the
     * expression on which {@code getClass} is called.</b> For
     * example, no cast is required in this code fragment:</p>
     *
     * <p>
     * {@code Number n = 0;                             }<br>
     * {@code Class<? extends Number> c = n.getClass(); }
     * </p>
     *
     * @return The {@code Class} object that represents the runtime
     *         class of this object.
     * @jls 15.8.2 Class Literals
     */
    public final native Class<?> getClass();

getClass() 方法可以直接通过 == 符号判断，通过这种方式的比较，可以直接比较两个类是否严格的是同一个类，因此可以将 equals() 方法改写成如下形式：

@Override
public boolean equals(Object obj) {
    boolean result = false;
    if (obj != null && obj.getClass() == this.getClass()) {
        final AbstractCentralObject abstractCentralObject = (AbstractCentralObject) obj;
        result = this.name.equals(abstractCentralObject.name);
    }
    return result;
}

先判断是否为空，再判断 Class<?> 是否相同，测试结果如下：

 2. checkRep() 的继承和 Java 多态的思考

在实现基本的方法后，开始向 AbstractCentralObject 中添加 checkRep() 方法。由于这个类中设计了 final 的字段，需要在构造器中对其进行赋值。最初的设计是在 AbstractCentralObject 中添加一个 protected 的 checkRep() 方法，在子类中进行重写和对于父类方法的调用，这样就可以完美地实现对于 Rep Invariant 的检查，代码如下：

// AbstractCentralObject.java
protected void checkRep() {
    assert name != null;
}

// Stellar.java
@Override
protected void checkRep() {
    super.checkRep();
    assert radius != null & mass != null;
    assert radius.compareTo(BigDecimal.ZERO) > 0 && mass.compareTo(BigDecimal.ZERO) > 0;
}

在 Stelllar 类中添加了新的字段后，提示需要生成一个调用父类构造器的方法，来为 name 字段进行赋值，于是我编写了两个类的构造器如下：

// AbstractCentralObject.java
public AbstractCentralObject(String name) {
    this.name = name;
    checkRep();
}

// Stellar.java
public Stellar(String name, BigDecimal radius, BigDecimal mass) {
    super(name);
    this.radius = radius;
    this.mass = mass;
    checkRep();
}

此时 IDEA 检查表示没有错误，当编译运行时，出现了 AssertionError，经过检查发现是 checkRep() 当中抛出了异常。但是 Stellar 的构造器明明对于每一个字段都进行了赋值，这是令人非常困惑的。对代码进行调试，发现是父类的 checkRep() 发现了 radius 字段是空指针导致抛出了异常，这意味着当 Stellar 调用 super(name) 这条语句时，父类的构造方法调用了子类的 checkRep() 方法！

但是在继承语境下，对于重写的方法到底是如何调用的呢？经过对于网上资料的查询，发现 Java 的继承遵循“运行时看右侧”的规则，即对于一个被父类引用的子类，在父类的引用上调用一个被重写的方法，运行的仍然是子类的方法，这和 C++ 的非虚函数方法是不同的。味着在这个情况下，Stellar 在还没有初始化 radius 和 mass 字段的时候，就已经在父类的构造方法中进行了 Stallar 类的 checkRep()，而这显然是会出现问题的。

那么先初始化特有的字段再调用 super() 是否能行呢？很遗憾，Java 并不支持这种操作。这说明在 Java 中，在构造方法中调用一个可能被重写的方法是不可行的，因为这可能导致这个对象进入一种不确定的状态。因此，对于 checkRep() 进行一定的改写，就可以解决这个问题：

// AbstractCentralObject.java

private void checkRepCurrentClass() {
    assert name != null;
}

protected void checkRep() {
    checkRepCurrentClass();
}

public AbstractCentralObject(String name) {
    this.name = name;
    checkRepCurrentClass();
}

// Stellar.java

private void checkRepCurrentClass() {
    assert radius != null & mass != null;
    assert radius.compareTo(BigDecimal.ZERO) > 0 && mass.compareTo(BigDecimal.ZERO) > 0;
}

@Override
protected void checkRep() {
    super.checkRep();
    checkRepCurrentClass();
}

public Stellar(String name, BigDecimal radius, BigDecimal mass) {
    super(name);
    this.radius = radius;
    this.mass = mass;
    checkRepCurrentClass();
}

通过将 checkRep() 方法进行拆分，就可以实现构造方法中只调用不可以被覆写的方法的目的，从而避免上面的错误。

3. 对于 Java 多态的一点总结

本次的踩坑加深了我对于 Java 多态的理解，对于上面的两个问题总结如下：

1. instanceof 关键字用于判断一个类是否是指定类或者是它的子类，当父类实现 equals() 方法的时候，需要慎重判断。在必要的时候使用 getClass() 代替，可以实现只判断是否是同一个类的目的；
2. 构造器中不要调用可能被重写的方法，可能导致不必要的麻烦，必要时将这些方法进行拆分以避免违反上述的规则；
3. Java 的普通函数相当于 C++ 的虚函数，本身就具有多态性；
4. 对于父类引用的子类，其调用的函数是子类重写的函数（如果存在），需要特别注意这一点，和 C++ 的普通函数是不同的。

最初我以为 Java 是一门极度简化的语言，但是现在发现她的繁杂程度是超乎想象的，还有太多的特性需要我去探索。这也是修读《软件构造》这门课程的一个重大收获吧。