Método encadeamento + herança não jogam bem juntos?
-
21-08-2019 - |
Pergunta
Esta pergunta foi feita em um C ++ contexto, mas eu estou curioso sobre Java. As preocupações sobre métodos virtuais não se aplicam (eu acho), mas se você tem essa situação:
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
}
Neste tipo de hierarquia de classes, há alguma maneira de voltar this
de uma forma que não faz (efetivamente) upcast o tipo de objeto?
Solução
Se você quer evitar os avisos elenco desmarcada do seu compilador (não e fazer querer @SuppressWarnings ( "não verificadas")), então você precisa fazer um pouco mais:
Em primeiro lugar, a sua definição de Pet deve ser auto-referencial, porque Pet é sempre um tipo genérico:
abstract class Pet <T extends Pet<T>>
Em segundo lugar, o elenco (T) this
em setName também está desmarcada. Para evitar isso, use a técnica "getThis" no excelente Generics FAQ por Angelika Langer :
O "getThis" truque fornece uma maneira de recuperar o tipo exato do presente referência.
Isso resulta no código abaixo, que compila e é executado sem avisos. Se você deseja estender suas subclasses, em seguida, a técnica ainda detém (embora você provavelmente vai precisar genericise suas classes intermediárias).
O código resultante é:
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();
}
}
Outras dicas
Como sobre este velho truque:
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>
{
/* ... */
}
Não, não realmente. Você poderia trabalhar em torno dele usando tipos de retorno covariantes (graças a McDowell para o nome correto):
@Override
public Cat setName(String name) {
super.setName(name);
return this;
}
(tipos de retorno covariantes são apenas em Java 5 e acima, se isso é uma preocupação para você.)
É um pouco complicado, mas você pode fazer isso com os genéricos:
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
}
}
public class Pet<AnimalType extends Pet> {
private String name;
public AnimalType setName(String name) {
this.name = name; return (AnimalType)this;
}
}
e
public class Cat extends Pet<Cat> {
public Cat catchMice() {return this;}
public static void main(String[] args) {
Cat c = new Cat().setName("bob").catchMice();
}
}