Java Héritage Multiple

Vous pouvez créer des interfaces pour les classes d'animaux (classe dans le sens biologique), comme public interface Equidae pour les chevaux et les public interface Avialae pour les oiseaux (je ne suis pas biologiste, de sorte que les conditions trompe peut-être).

Alors vous pouvez toujours créer un

public class Bird implements Avialae {
}

et

public class Horse implements Equidae {}

et aussi

public class Pegasus implements Avialae, Equidae {}

---

L'ajout de commentaires:

Afin de réduire les répétitions de code, vous pouvez créer une classe abstraite qui contient la plupart des communes code des animaux que vous souhaitez mettre en place.

public abstract class AbstractHorse implements Equidae {}

public class Horse extends AbstractHorse {}

public class Pegasus extends AbstractHorse implements Avialae {}

---

Mise à jour

Je voudrais ajouter un plus de détail. Comme Brian remarques, c'est quelque chose que l'OP savait déjà.

Cependant, je tiens à souligner, que je suggère pour contourner le "multi-héritage" problème avec les interfaces et que je ne recommande pas d'utiliser des interfaces qui représentent déjà un type concret (comme les Oiseaux), mais plus d'un comportement (d'autres parlent de canard-typage, ce qui est bien aussi, mais je veux dire simplement: l'biologique de la classe des oiseaux, Avialae). Aussi, je ne recommande pas d'utiliser l'interface de noms commençant par un "I", comme IBird, qui ne dit rien au sujet de pourquoi vous avez besoin d'une interface. C'est la différence à la question: construire la hiérarchie d'héritage de l'utilisation d'interfaces, l'utilisation de classes abstraites lorsque c'est utile, la mise en place de classes nécessaires et à utiliser la délégation, le cas échéant.

J'ai une idée stupide:

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();
  }
}

Techniquement parlant, vous ne pouvez étendre une classe à la fois et d'implémenter plusieurs interfaces, mais lors de la pose des mains sur l'ingénierie du logiciel, je préfère suggérer un problème spécifique de la solution généralement pas de réponse. Par ailleurs, il est bon OO pratique, pas d'étendre les classes de béton/seulement d'étendre les classes abstraites pour éviter les comportement de l'héritage - il n'y a pas une telle chose comme un "animal" et pas de l'utilisation de l'animal objet, mais seulement en béton animaux.

Il est sûr de garder un cheval dans une écurie avec une demi la porte, comme un cheval ne peut pas obtenir plus d'un demi-porte. J'ai donc l'installation d'un cheval de service de logement qui accepte n'importe quel élément de type cheval et le met dans une étable avec une demi la porte.

Donc, c'est un cheval comme animal qui peut même voler un cheval?

Je pensais beaucoup au sujet de l'héritage multiple, mais maintenant que j'ai été la programmation depuis plus de 15 ans, je n'ai plus de soins sur l'implémentation de l'héritage multiple.

Plus souvent que pas, quand j'ai essayé de composer avec un design orienté vers l'héritage multiple, je dois venir plus tard à la libération que j'ai dû manquer compris le domaine du problème.

OU

Si elle ressemble à un canard et les charlatans comme un canard, mais il a besoin
batteries, vous avez probablement du mal à l'abstraction.

Je pense que tout dépend de vos besoins, et comment votre animal de classes sont à utiliser dans votre code.

Si vous voulez être en mesure de faire usage de méthodes et fonctions de votre Cheval et l'Oiseau implémentations à l'intérieur de votre Pegasus classe, alors vous pourriez mettre en œuvre Pegasus comme un composition d'un Oiseau et d'un Cheval:

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;
}
}
}

Une autre possibilité est d'utiliser un L'Entité Composant De Système D' au lieu de l'héritage de la définition de vos animaux. Bien sûr, cela signifie, que vous n'aurez pas de personne Java classes des animaux, mais ils ne sont définies que par leurs composants.

De pseudo-code d'une Entité Composant de Système d'approche pourrait ressembler à ceci:

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);
}

Euh, votre classe peut être la sous-classe pour seulement 1 d'autres, mais encore, vous pouvez avoir autant d'interfaces implémentées, comme vous le souhaitez.

Un Pegasus est en fait un cheval (c'est un cas particulier d'un cheval), qui est capable de voler (qui est la "compétence" de cette spéciale de cheval). D'autre part, vous pouvez dire, le Pegasus est un oiseau, qui est capable de marcher et est 4legged - tout dépend comment il est plus facile pour vous d'écrire le code.

Comme dans votre cas vous pouvez dire:

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
}
}

Que vous serez déjà au courant, l'héritage multiple de classes en Java n'est pas possible, mais c'est possible avec les interfaces. Vous pouvez aussi envisager d'utiliser la composition motif de conception.

J'ai écrit un article très complet sur la composition il y a quelques années...

https://codereview.stackexchange.com/questions/14542/multiple-inheritance-and-composition-with-java-and-c-updated

Pour réduire la complexité et de simplifier la langue, l'héritage multiple n'est pas prise en charge par java.

Envisager un scénario où A, B et C sont trois classes. La classe C hérite des classes A et B. Si des classes A et B ont la même méthode et vous appelez cela de l'enfant objet de classe, il y aura de l'ambiguïté à l'appel de la méthode A ou B de classe.

Depuis le moment de la compilation les erreurs sont mieux que d'erreurs à l'exécution, java rend erreur de compilation si vous héritez de 2 classes. Donc, si vous avez la même méthode ou différents, il y aura erreur de compilation maintenant.

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?  
}
}