Herança Múltipla de Java

Na tentativa de entender completamente como resolver os vários problemas de herança do Java, tenho uma pergunta clássica que preciso ser esclarecida.

Vamos dizer que eu tenho classe Animalisto tem subclasses Birde Horsee eu preciso fazer uma classe Pegasusque se estende a partir Birde Horseuma vez Pegasusé ao mesmo tempo um pássaro e um cavalo.

Eu acho que esse é o problema clássico dos diamantes. Pelo que entendi, a maneira clássica de resolver isso é criar as interfaces Animal, Birde Horseclasses e implementar a Pegasuspartir delas.

Fiquei me perguntando se havia outra maneira de resolver o problema em que ainda posso criar objetos para pássaros e cavalos. Se houvesse uma maneira de criar animais, isso seria ótimo, mas não necessário.

Você pode criar interfaces para classes de animais (classe no significado biológico), como public interface Equidaepara cavalos e public interface Avialaepássaros (não sou biólogo, portanto os termos podem estar errados).

Então você ainda pode criar um

public class Bird implements Avialae {
}

e

public class Horse implements Equidae {}

e também

public class Pegasus implements Avialae, Equidae {}

Adicionando a partir dos comentários:

Para reduzir o código duplicado, você pode criar uma classe abstrata que contenha a maior parte do código comum dos animais que você deseja implementar.

public abstract class AbstractHorse implements Equidae {}

public class Horse extends AbstractHorse {}

public class Pegasus extends AbstractHorse implements Avialae {}

Atualizar

Eu gostaria de adicionar mais um detalhe. Como Brian observa , isso é algo que o OP já sabia.

No entanto, quero enfatizar que sugiro ignorar o problema da "herança múltipla" com interfaces e que não recomendo o uso de interfaces que já representem um tipo concreto (como Bird), mas mais um comportamento (outras se referem a digitação de pato, o que também é bom, mas quero dizer apenas: a classe biológica dos pássaros, Avialae). Também não recomendo o uso de nomes de interface que começam com um 'I' maiúsculo, como, por exemplo IBird, que não diz nada sobre o motivo de você precisar de uma interface. Essa é a diferença para a pergunta: construa a hierarquia de herança usando interfaces, use classes abstratas quando útil, implemente classes concretas quando necessário e use delegação, se apropriado.

Existem duas abordagens fundamentais para combinar objetos:

• O primeiro é a herança . Como você já identificou as limitações da herança, significa que você não pode fazer o que precisa aqui.
• O segundo é composição . Como a herança falhou, você precisa usar a composição.

A maneira como isso funciona é que você tem um objeto Animal. Nesse objeto, você adiciona outros objetos que fornecem as propriedades e comportamentos necessários.

Por exemplo:

• Pássaro estende implementos animais IFlier
• Cavalo estende implementos animais IHerbivore, IQuadruped
• Pegasus estende implementos animais IHerbivore, IQuadruped, IFlier

Agora, IFlierfica assim:

 interface IFlier {
     Flier getFlier();
 }

Então Birdé assim:

 class Bird extends Animal implements IFlier {
      Flier flier = new Flier();
      public Flier getFlier() { return flier; }
 }

Agora você tem todas as vantagens da herança. Você pode reutilizar o código. Você pode ter uma coleção de IFliers e pode usar todas as outras vantagens do polimorfismo, etc.

No entanto, você também tem toda a flexibilidade do Composition. Você pode aplicar quantas interfaces diferentes e classe de apoio composto desejar para cada tipo de Animal- com o controle necessário sobre a configuração de cada bit.

Padrão estratégico Estratégia de abordagem alternativa à composição

Uma abordagem alternativa, dependendo do que e como você está fazendo, é fazer com que a Animalclasse base contenha uma coleção interna para manter a lista de comportamentos diferentes. Nesse caso, você acaba usando algo mais próximo do padrão de estratégia. Isso oferece vantagens em termos de simplificação do código (por exemplo, Horsenão é necessário saber nada sobre Quadrupedou Herbivore), mas se você também não faz a abordagem da interface, perde muitas das vantagens do polimorfismo, etc.

Eu tenho uma ideia estúpida:

public class Pegasus {
    private Horse horseFeatures; 
    private Bird birdFeatures; 

   public Pegasus(Horse horse, Bird bird) {
     this.horseFeatures = horse;
     this.birdFeatures = bird;
   }

  public void jump() {
    horseFeatures.jump();
  }

  public void fly() {
    birdFeatures.fly();
  }
}

Posso sugerir o conceito de digitação de pato ?

Muito provavelmente você tenderia a fazer o Pegasus estender uma interface Bird e Horse, mas a digitação de pato na verdade sugere que você deve herdar um comportamento . Como já foi dito nos comentários, um pégaso não é um pássaro, mas pode voar. Portanto, seu Pegasus deve herdar uma Flyableinterface e digamos umGallopable interface.

Esse tipo de conceito é utilizado no Padrão de Estratégia . O exemplo dado realmente mostra como um pato herda o FlyBehavioure QuackBehavioure ainda pode haver patos, por exemplo, o RubberDuckque não pode voar. Eles também poderiam ter Duckestendido a Birdclasse -classe, mas teriam desistido de alguma flexibilidade, porque todos Duckseriam capazes de voar, até os pobres RubberDuck.

Tecnicamente falando, você pode estender apenas uma classe de cada vez e implementar várias interfaces, mas ao colocar a mão na engenharia de software, prefiro sugerir uma solução específica para um problema que geralmente não é responsável. A propósito, é uma boa prática OO, não estender classes concretas / apenas estender classes abstratas para evitar comportamentos indesejados de herança - não existe um "animal" e nenhum uso de um objeto animal, mas apenas animais concretos.

No Java 8, que ainda está na fase de desenvolvimento em fevereiro de 2014, você pode usar métodos padrão para obter uma espécie de herança múltipla semelhante a C ++. Você também pode dar uma olhada neste tutorial, que mostra alguns exemplos que devem ser mais fáceis de começar a trabalhar do que a documentação oficial.

É seguro manter um cavalo em um estábulo com meia porta, pois um cavalo não pode passar de meia porta. Por isso, montei um serviço de alojamento para cavalos que aceita qualquer item do tipo cavalo e o coloco em um estábulo com meia porta.

Então, um cavalo é como um animal que pode voar até um cavalo?

Eu costumava pensar muito em herança múltipla, mas agora que programa há mais de 15 anos, não me importo mais em implementar herança múltipla.

Freqüentemente, quando tentei lidar com um design que apontava para várias heranças, mais tarde cheguei à conclusão de que não entendi o domínio do problema.

OU

Se parece um pato e grasna como um pato, mas precisa de baterias, você provavelmente tem a abstração errada .

Java não tem um problema de herança múltipla, pois não possui herança múltipla. Isso ocorre por design, a fim de resolver o problema real de herança múltipla (O problema do diamante).

Existem diferentes estratégias para mitigar o problema. O mais imediatamente possível é o objeto Composite que Pavel sugere (essencialmente como o C ++ lida com ele). Não sei se a herança múltipla via linearização C3 (ou similar) está nos cartões para o futuro do Java, mas duvido.

Se sua pergunta é acadêmica, a solução correta é que Pássaro e Cavalo são mais concretos e é falso supor que um Pegasus é simplesmente um Pássaro e um Cavalo combinados. Seria mais correto dizer que um Pegasus tem certas propriedades intrínsecas em comum com Pássaros e Cavalos (ou seja, eles talvez tenham ancestrais comuns). Isso pode ser suficientemente modelado como aponta a resposta de Moritz.

Eu acho que depende muito das suas necessidades e de como suas classes de animais devem ser usadas no seu código.

Se você quiser usar métodos e recursos de suas implementações de cavalos e aves em sua classe Pegasus, poderá implementar o Pegasus como uma composição de um pássaro e um cavalo:

public class Animals {

    public interface Animal{
        public int getNumberOfLegs();
        public boolean canFly();
        public boolean canBeRidden();
    }

    public interface Bird extends Animal{
        public void doSomeBirdThing();
    }
    public interface Horse extends Animal{
        public void doSomeHorseThing();
    }
    public interface Pegasus extends Bird,Horse{

    }

    public abstract class AnimalImpl implements Animal{
        private final int numberOfLegs;

        public AnimalImpl(int numberOfLegs) {
            super();
            this.numberOfLegs = numberOfLegs;
        }

        @Override
        public int getNumberOfLegs() {
            return numberOfLegs;
        }
    }

    public class BirdImpl extends AnimalImpl implements Bird{

        public BirdImpl() {
            super(2);
        }

        @Override
        public boolean canFly() {
            return true;
        }

        @Override
        public boolean canBeRidden() {
            return false;
        }

        @Override
        public void doSomeBirdThing() {
            System.out.println("doing some bird thing...");
        }

    }

    public class HorseImpl extends AnimalImpl implements Horse{

        public HorseImpl() {
            super(4);
        }

        @Override
        public boolean canFly() {
            return false;
        }

        @Override
        public boolean canBeRidden() {
            return true;
        }

        @Override
        public void doSomeHorseThing() {
            System.out.println("doing some horse thing...");
        }

    }

    public class PegasusImpl implements Pegasus{

        private final Horse horse = new HorseImpl();
        private final Bird bird = new BirdImpl();


        @Override
        public void doSomeBirdThing() {
            bird.doSomeBirdThing();
        }

        @Override
        public int getNumberOfLegs() {
            return horse.getNumberOfLegs();
        }

        @Override
        public void doSomeHorseThing() {
            horse.doSomeHorseThing();
        }


        @Override
        public boolean canFly() {
            return true;
        }

        @Override
        public boolean canBeRidden() {
            return true;
        }
    }
}

Outra possibilidade é usar um sistema de componentes de entidade abordagem de vez de herança para definir seus animais. Obviamente, isso significa que você não terá classes Java individuais dos animais, mas elas serão definidas apenas por seus componentes.

Algum pseudocódigo para uma abordagem de sistema de componentes de entidade pode ser assim:

public void createHorse(Entity entity){
    entity.setComponent(NUMER_OF_LEGS, 4);
    entity.setComponent(CAN_FLY, false);
    entity.setComponent(CAN_BE_RIDDEN, true);
    entity.setComponent(SOME_HORSE_FUNCTIONALITY, new HorseFunction());
}

public void createBird(Entity entity){
    entity.setComponent(NUMER_OF_LEGS, 2);
    entity.setComponent(CAN_FLY, true);
    entity.setComponent(CAN_BE_RIDDEN, false);
    entity.setComponent(SOME_BIRD_FUNCTIONALITY, new BirdFunction());
}

public void createPegasus(Entity entity){
    createHorse(entity);
    createBird(entity);
    entity.setComponent(CAN_BE_RIDDEN, true);
}

você pode ter uma hierarquia de interface e depois estender suas classes a partir de interfaces selecionadas:

public interface IAnimal {
}

public interface IBird implements IAnimal {
}

public  interface IHorse implements IAnimal {
}

public interface IPegasus implements IBird,IHorse{
}

e defina suas classes conforme necessário, estendendo uma interface específica:

public class Bird implements IBird {
}

public class Horse implements IHorse{
}

public class Pegasus implements IPegasus {
}

Ehm, sua classe pode ser a subclasse de apenas 1 outra, mas ainda assim, você pode ter quantas interfaces implementadas, conforme desejar.

Um Pegasus é de fato um cavalo (é um caso especial de cavalo), capaz de voar (que é a "habilidade" deste cavalo especial). Por outro lado, você pode dizer que o Pegasus é um pássaro, que pode andar e tem 4 patas - tudo depende de como é mais fácil escrever o código.

Como no seu caso, você pode dizer:

abstract class Animal {
   private Integer hp = 0; 
   public void eat() { 
      hp++; 
   }
}
interface AirCompatible { 
   public void fly(); 
}
class Bird extends Animal implements AirCompatible { 
   @Override
   public void fly() {  
       //Do something useful
   }
} 
class Horse extends Animal {
   @Override
   public void eat() { 
      hp+=2; 
   }

}
class Pegasus extends Horse implements AirCompatible {
   //now every time when your Pegasus eats, will receive +2 hp  
   @Override
   public void fly() {  
       //Do something useful
   }
}

As interfaces não simulam herança múltipla. Os criadores de Java consideraram a herança múltipla incorreta, portanto não existe tal coisa em Java.

Se você deseja combinar a funcionalidade de duas classes em uma composição de objeto de uso único. Ou seja,

public class Main {
    private Component1 component1 = new Component1();    
    private Component2 component2 = new Component2();
}

E se você deseja expor certos métodos, defina-os e deixe-os delegar a chamada ao controlador correspondente.

Aqui, as interfaces podem ser úteis - se Component1implementa interface Interface1e Component2implementa Interface2, você pode definir

class Main implements Interface1, Interface2

Para que você possa usar objetos de forma intercambiável onde o contexto permitir.

Então, no meu ponto de vista, você não pode entrar no problema dos diamantes.

Como você já deve saber, a herança múltipla de classes em Java não é possível, mas é possível com interfaces. Você também pode considerar o uso do padrão de design da composição.

Eu escrevi um artigo muito abrangente sobre composição há alguns anos ...

/codereview/14542/multiple-inheritance-and-composition-with-java-and-c-updated

1. Defina interfaces para definir os recursos. Você pode definir várias interfaces para vários recursos. Esses recursos podem ser implementados por animais ou aves específicos .
2. Usar herança para estabelecer relacionamentos entre classes, compartilhando dados / métodos não estáticos e não públicos.
3. Use Decorator_pattern para adicionar recursos dinamicamente. Isso permitirá reduzir o número de classes e combinações de herança.

Dê uma olhada no exemplo abaixo para entender melhor

Quando usar o padrão do decorador?

Para reduzir a complexidade e simplificar o idioma, a herança múltipla não é suportada em java.

Considere um cenário em que A, B e C são três classes. A classe C herda as classes A e B. Se as classes A e B tiverem o mesmo método e você o chamar de objeto de classe filho, haverá ambiguidade para chamar o método da classe A ou B.

Como os erros em tempo de compilação são melhores que os erros em tempo de execução, o java renderiza o erro em tempo de compilação se você herdar 2 classes. Então, se você tem o mesmo método ou diferente, haverá um erro de tempo de compilação agora.

class A {  
    void msg() {
        System.out.println("From A");
    }  
}

class B {  
    void msg() {
        System.out.println("From B");
    }  
}

class C extends A,B { // suppose if this was possible
    public static void main(String[] args) {  
        C obj = new C();  
        obj.msg(); // which msg() method would be invoked?  
    }
} 

Para resolver o problema da herança múltipla em Java → a interface é usada

Notas do J2EE (JAVA principal) do Sr. KVR Página 51

Dia - 27

1. As interfaces são basicamente usadas para desenvolver tipos de dados definidos pelo usuário.
2. Com relação às interfaces, podemos alcançar o conceito de múltiplas heranças.
3. Com interfaces, podemos alcançar o conceito de polimorfismo, ligação dinâmica e, portanto, podemos melhorar o desempenho de um programa JAVA em turnos de espaço na memória e tempo de execução.

Uma interface é uma construção que contém a coleção de métodos puramente indefinidos ou uma interface é uma coleção de métodos puramente abstratos.

[...]

Dia - 28:

Sintaxe-1 para reutilizar os recursos da (s) interface (s) na classe:

[abstract] class <clsname> implements <intf 1>,<intf 2>.........<intf n>
{
    variable declaration;
    method definition or declaration;
};

Na sintaxe acima, clsname representa o nome da classe que está herdando os recursos do número 'n' de interfaces. 'Implementa' é uma palavra-chave usada para herdar os recursos da (s) interface (s) para uma classe derivada.

[...]

Sintaxe-2 herdando 'n' número de interfaces para outra interface:

interface <intf 0 name> extends <intf 1>,<intf 2>.........<intf n>
{     
    variable declaration cum initialization;
    method declaration;
};

[...]

Sintaxe-3:

[abstract] class <derived class name> extends <base class name> implements <intf 1>,<intf 2>.........<intf n>
{
  variable declaration;
  method definition or declaration;
};