所以我有几个像这样定义的继承类.

class Base {
    public Base chainedMethodA() {
        // some stuff
        return this;
    }
}

class Derived extends Base {
    public Derived chainedMethodB() {
        // some stuff
        return this;
    }
}

现在,以下代码有效：

Derived obj = new Derived();
obj.chainedMethodB().chainedMethodA();

但这不会(注意函数调用的切换顺序)：

Derived obj = new Derived();
obj.chainedMethodA().chainedMethodB();

编译器在chainedMethodB()函数调用上给出错误.我可以理解这是因为当你运行chainedMethodA()时,它返回一个Base类型的对象,它没有定义chainedMethodB.

我可以想到这个问题的一些解决方案：

>链式方法,同时注意顺序(首先调用Derived的方法,然后调用Base的方法).这看起来像一个非常脆弱的解决方案.
>在Derived中覆盖chainedMethodA,以便返回Derived而不是Base的实例.这看起来像是对遗产的浪费.

这个问题有什么优雅的方法吗？也许某些构造会神奇地更改chainedMethodA,以便在Derived类型的对象调用时返回Derived实例,而不会在Derived中显式覆盖.

解决方法:

Override chainedMethodA in Derived so it returns an instance of
Derived instead of Base. This looks like a waste of inheritance.

你错了.你不是在浪费遗产.

覆盖技术就是做专门的方法.当返回的类型相同或者在超类中的原始重写方法中声明的返回类型的子类型时,可以执行覆盖.所以在这种情况下,你什么都没有违反.

有关覆盖的更多信息,请阅读here.

这里示例1 :(调用超类方法)

public class Derived extends Base {
    @Override
    public Derived chainedMethodA(){

         super.chainedMethodA();
         //some stuff
        return this;
    }

    public Derived chainedMethodB() {
        // some stuff
        return this;
    }
}

这里的例子2 :(改变它完整)

public class Derived extends Base {
    @Override
    public Derived chainedMethodA(){
        //some stuff
        return this;
    }

    public Derived chainedMethodB() {
        // some stuff
        return this;
    }
    }