关于java：方法链接+继承不能很好地一起玩吗？

Method chaining + inheritance don’t play well together?

这个问题是在C++环境中提出的，但我对Java很好奇。对虚拟方法的关注并不适用(我认为)，但是如果您遇到这种情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

abstract class Pet
{
private String name;
public Pet setName(String name) { this.name = name; return this; }
}

class Cat extends Pet
{
public Cat catchMice() {
System.out.println("I caught a mouse!");
return this;
}
}

class Dog extends Pet
{
public Dog catchFrisbee() {
System.out.println("I caught a frisbee!");
return this;
}
}

class Bird extends Pet
{
public Bird layEgg() {
...
return this;
}
}

{
Cat c = new Cat();
c.setName("Morris").catchMice(); // error! setName returns Pet, not Cat
Dog d = new Dog();
d.setName("Snoopy").catchFrisbee(); // error! setName returns Pet, not Dog
Bird b = new Bird();
b.setName("Tweety").layEgg(); // error! setName returns Pet, not Bird
}

在这种类层次结构中，是否有任何方法可以返回this，而不(有效地)向上转换对象类型？

相关讨论

如果希望避免编译器发出未选中的强制转换警告(并且不希望@suppresswarnings("unchecked")，则需要执行以下操作：

首先，您对宠物的定义必须是自引用的，因为宠物总是一个通用类型：

1	abstract class Pet <T extends Pet<T>>

其次，setname中的(T) this强制转换也未选中。要避免这种情况，请使用安吉丽卡·兰格的《优秀仿制药常见问题解答》中的"getthis"技术：

The"getThis" trick provides a way to
recover the exact type of the this
reference.

这将导致下面的代码编译并运行，而不发出警告。如果您想扩展子类，那么该技术仍然有效(尽管您可能需要将中间类泛型化)。

产生的代码是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class TestClass {

static abstract class Pet <T extends Pet<T>> {
private String name;

protected abstract T getThis();

public T setName(String name) {
this.name = name;
return getThis(); }
}

static class Cat extends Pet<Cat> {
@Override protected Cat getThis() { return this; }

public Cat catchMice() {
System.out.println("I caught a mouse!");
return getThis();
}
}

static class Dog extends Pet<Dog> {
@Override protected Dog getThis() { return this; }

public Dog catchFrisbee() {
System.out.println("I caught a frisbee!");
return getThis();
}
}

public static void main(String[] args) {
Cat c = new Cat();
c.setName("Morris").catchMice();
Dog d = new Dog();
d.setName("Snoopy").catchFrisbee();
}
}

相关讨论

这个老把戏怎么样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

abstract class Pet<T extends Pet>
{
private String name;
public T setName(String name) { this.name = name; return (T) this; }
}

class Cat extends Pet<Cat>
{
/* ... */
}

class Dog extends Pet<Dog>
{
/* ... */
}

相关讨论

不，不是真的。您可以通过使用协变返回类型来解决这个问题(感谢McDowell提供正确的名称)：

1
2
3
4
5

@Override
public Cat setName(String name) {
super.setName(name);
return this;
}

(协变返回类型仅在Java 5和以上，如果这是您的关注点)。

这有点复杂，但是你可以用泛型来实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

abstract class Pet< T extends Pet > {
private String name;

public T setName( String name ) {
this.name = name;
return (T)this;
}

public static class Cat extends Pet< Cat > {
public Cat catchMice() {
System.out.println("I caught a mouse!" );
return this;
}
}

public static class Dog extends Pet< Dog > {
public Dog catchFrisbee() {
System.out.println("I caught a frisbee!" );
return this;
}
}

public static void main (String[] args){
Cat c = new Cat();
c.setName("Morris" ).catchMice(); // error! setName returns Pet, not Cat
Dog d = new Dog();
d.setName("Snoopy" ).catchFrisbee(); // error! setName returns Pet, not Dog
}

}

1
2
3
4
5
6
7

public class Pet<AnimalType extends Pet> {

private String name;
public AnimalType setName(String name) {
this.name = name; return (AnimalType)this;
}
}

和

1
2
3
4
5
6
7

public class Cat extends Pet<Cat> {

public Cat catchMice() {return this;}

public static void main(String[] args) {
Cat c = new Cat().setName("bob").catchMice();
}

}

相关讨论