我有一个父类，它定义了链表方法（返回“this”的方法）的集合。我想定义多个子类，这些子类包含自己的链式方法，但也“重写”父方法，以便返回子类的实例而不是父类。
我不想在每个子类中重复相同的方法，这就是为什么我有一个父类，其中包含所有子类共享的方法。谢谢
class Chain {
public Chain foo(String s){
...
return this;
}
}
class ChainChild extends Chain {
//I don't want to add a "foo" method to each child class
/*
public ChildChain foo(String s){
...
return this;
}
*/
public ChainChild bar(boolean b){
...
return this;
}
}
ChainChild child = new ChainChild();
child.foo().bar(); //compile error: foo() returns a "Chain" object which does not define the bar() method.
父类中返回this的方法仍将返回对子类对象的引用。您只能将其视为父类的对象（除非您强制转换它），但它实际上是其原始类型。
您可以考虑使用以下泛型：
// This seems a bit too contrived for my liking. Perhaps someone else will have a better idea.
public class Parent<T extends Parent<T>> {
T foo () {
return (T) this;
}
}
public class Child extends Parent<Child> {
public void bar () {
Child c = foo();
}
}
我根据您的需求使用泛型编写了这个示例。
class Parent {
public <T extends Parent> T foo() {
return (T)this;
}
}
class Child extends Parent {
}
class AnotherChild extends Parent {
}
public class Test {
public static void main(String[] args) {
Parent p = new Child();
System.out.println(p);
Child c = p.foo();
System.out.println(c);
//throws ClassCastException here since Child is not AnotherChild
AnotherChild ac = p.foo();
System.out.println(ac);
}
}
这里有一个对OldCurmujongs方法的改进：
public class Parent<This extends Parent<This>> {
@SuppressWarnings("unchecked")
private final This THIS = (This)this;
public This foo() {
//...
return THIS;
}
public This bar() {
//...
return THIS;
}
}
public class Child extends Parent<Child> {
// you can override super with covariant return type
@Override
public Child bar() {
super.bar();
return this;
}
}
Child child =
new Child()
.foo()
.bar();
改进是只进行一次未检查的强制转换，并将其保存为常量THIS，您可以将其重新用作方法链接的返回值。
这将删除每个方法中未经检查的强制转换，并使代码更清晰。
您可以通过返回Child而不是这个（协变返回类型）来重写父方法。
