Como evitar o downcasting?

Minha pergunta é sobre um caso especial da super classe Animal.

1. Minha Animallata moveForward()e eat().
2. Sealse estende Animal.
3. Dogse estende Animal.
4. E há uma criatura especial que também se estende Animalchamada Human.
5. Humanimplementa também um método speak()(não implementado por Animal).

Em uma implementação de um método abstrato que aceite, Animaleu gostaria de usar o speak()método. Isso parece impossível sem fazer um downcast. Jeremy Miller escreveu em seu artigo que um downcast cheira.

Qual seria uma solução para evitar o downcasting nessa situação?

Se você possui um método que precisa saber se a classe específica é do tipo Humanpara fazer algo, está quebrando alguns princípios do SOLID , particularmente:

• Princípio aberto / fechado - se, no futuro, você precisar adicionar um novo tipo de animal que possa falar (por exemplo, um papagaio) ou fazer algo específico para esse tipo, seu código existente precisará ser alterado
• Princípio de segregação de interface - parece que você está generalizando demais. Um animal pode cobrir um amplo espectro de espécies.

Na minha opinião, se seu método espera um tipo de classe específico, para chamá-lo de método específico, altere esse método para aceitar apenas essa classe, e não sua interface.

Algo assim :

public void MakeItSpeak( Human obj );

e não assim:

public void SpeakIfHuman( Animal obj );

O problema não é que você está fazendo downcast - é para onde está fazendo downcast Human. Em vez disso, crie uma interface:

public interface CanSpeak{
    void speak();
}

public abstract class Animal{
    //....
}

public class Human extends Animal implements CanSpeak{
    public void speak(){
        //....
    }
}

public void mysteriousMethod(Animal animal){
    //....
    if(animal instanceof CanSpeak){
        ((CanSpeak)animal).speak();
    }else{
        //Throw exception or something
    }
    //....
}

Dessa forma, a condição não é que o animal seja Human- a condição é que ele possa falar. Isso significa que mysteriousMethodpode trabalhar com outras subclasses não humanas Animal, desde que sejam implementadas CanSpeak.

Você pode adicionar o Communicate to Animal. Cachorro late, Humano fala, Selo .. uhh ... Eu não sei o que selo faz.

Mas parece que seu método foi desenvolvido para if (Animal is Human) Speak ();

A pergunta que você pode querer fazer é: qual é a alternativa? É difícil dar uma sugestão, pois não sei exatamente o que você deseja alcançar. Existem situações teóricas em que downcasting / upcasting é a melhor abordagem.

Nesse caso, a implementação padrão de speak()na AbstractAnimalclasse seria:

void speak() throws CantSpeakException {
  throw new CantSpeakException();
}

Nesse ponto, você tem uma implementação padrão na classe Abstract - e ela se comporta corretamente.

try {
  thingy.speak();
} catch (CantSeakException e) {
  System.out.println("You can't talk to the " + thingy.name());
}

Sim, isso significa que você tem try-catchs espalhados pelo código para lidar com todos speak, mas a alternativa é if(thingy is Human)envolver todas as conversas.

A vantagem da exceção é que, se você tiver outro tipo de coisa em algum momento que fala (um papagaio), não precisará reimplementar todos os seus testes.

Às vezes, o downcasting é necessário e apropriado. Em particular, geralmente é apropriado nos casos em que se possui objetos que podem ou não ter alguma habilidade, e se deseja usá-la quando existe enquanto manipula objetos sem essa habilidade de alguma maneira padrão. Como um exemplo simples, suponha que Stringse pergunte a se é igual a algum outro objeto arbitrário. Para que um Stringseja igual ao outro String, ele deve examinar o comprimento e a matriz de caracteres de apoio da outra sequência. Se a Stringé perguntado se é igual a Dog, no entanto, ele não pode acessar o comprimento de Dog, mas não deveria; em vez disso, se o objeto ao qual Stringse supostamente se comparar não for umString, a comparação deve usar um comportamento padrão (relatando que o outro objeto não é igual).

O momento em que o downcasting deve ser considerado o mais duvidoso é quando o objeto que está sendo transmitido é "conhecido" como sendo do tipo apropriado. Em geral, se um objeto é conhecido como a Cat, deve-se usar uma variável do tipo Cat, em vez de uma variável do tipo Animal, para se referir a ele. Há momentos em que isso nem sempre funciona, no entanto. Por exemplo, uma Zoocoleção pode conter pares de objetos em slots de matriz pares / ímpares, com a expectativa de que os objetos em cada par possam agir um contra o outro, mesmo que não possam agir sobre os objetos em outros pares. Nesse caso, os objetos em cada par ainda teriam que aceitar um tipo de parâmetro não específico, de forma que eles pudessem, sintaticamente , passar os objetos de qualquer outro par. Assim, mesmo se Cat'splayWith(Animal other)O método só funcionaria quando otherfosse a Cat, Zooseria necessário transmitir a ele um elemento de um Animal[], portanto, seu tipo de parâmetro teria que ser em Animalvez de Cat.

Nos casos em que o downcasting é legitimamente inevitável, deve-se usá-lo sem receio. A questão-chave é determinar quando é possível evitar sensivelmente o downcasting e evitá-lo quando possível.

Em uma implementação de um método abstrato que aceita Animals, eu gostaria de usar o método speak ().

Você tem poucas escolhas:

• Use reflexão para chamar, speakse existir. Vantagem: sem dependência Human. Desvantagem: agora existe uma dependência oculta do nome "speak".

• Introduzir uma nova interface Speakere fazer downcast na interface. Isso é mais flexível do que depende de um tipo específico de concreto. Tem a desvantagem que você precisa modificar Humanpara implementar Speaker. Isso não funcionará se você não puder modificarHuman

• Downcast para Human. Isso tem a desvantagem de que você precisará modificar o código sempre que desejar que outra subclasse fale. Idealmente, você deseja estender aplicativos adicionando código sem voltar e alterar repetidamente o código antigo.