Amélioration Java (8) ----- Implémentation de l'héritage multiple

L'héritage multiple signifie qu'une classe peut hériter des comportements et des caractéristiques de plusieurs classes parents en même temps. Cependant, nous savons que Java n'autorise qu'un seul héritage afin de garantir la sécurité des données. Parfois, nous pensons que si l'héritage multiple est nécessaire dans le système, c'est souvent une mauvaise conception. À l'heure actuelle, nous devons souvent réfléchir non pas à la manière d'utiliser l'héritage multiple, mais à la question de savoir s'il y a des problèmes avec votre conception. nous devons mettre en œuvre l'héritage multiple, et de telles situations existent réellement dans la vie réelle, comme l'héritage : nous héritons à la fois du comportement et des caractéristiques de notre père et du comportement et des caractéristiques de notre mère. Heureusement, Java est très gentil et compréhensif envers nous. Il nous offre deux façons d'obtenir un héritage multiple : les interfaces et les classes internes.

1. Interface

Lors de l'introduction des interfaces et des classes abstraites, nous avons appris que les sous-classes ne peuvent hériter que d'une seule classe parent, ce qui signifie qu'il ne peut y avoir qu'une seule classe parent. héritage unique, mais peut implémenter plusieurs interfaces, ce qui nous ouvre la voie à l'implémentation d'héritages multiples.

Pour les interfaces, cela représente parfois plus qu'une simple classe abstraite plus pure. L'interface n'a pas d'implémentation spécifique, c'est-à-dire qu'il n'y a pas de stockage lié à l'interface, elle ne peut donc pas combiner plusieurs interfaces. est bloqué.

interface CanFight {  
    void fight();  
}  
  
interface CanSwim {  
    void swim();  
}  
  
  
interface CanFly {  
    void fly();  
}  
  
public class ActionCharacter {  
    public void fight(){  
          
    }  
}  
  
public class Hero extends ActionCharacter implements CanFight,CanFly,CanSwim{  
  
    public void fly() {  
    }  
  
    public void swim() {  
    }  
  
    /** 
     * 对于fight()方法，继承父类的，所以不需要显示声明 
     */  
}

2. Classes internes

L'utilisation ci-dessus d'interfaces pour implémenter l'héritage multiple est une manière plus réalisable et courante Lors de l'introduction des classes internes, nous avons expliqué comment les classes internes permettent l'héritage multiple. . L'implémentation est devenue plus parfaite et il est également clair que si la classe parent est une classe abstraite ou une classe concrète, alors je ne peux implémenter l'héritage multiple que via des classes internes. Comment utiliser des classes internes pour implémenter l'héritage multiple, veuillez consulter l'exemple suivant : comment un fils utilise l'héritage multiple pour hériter des excellents gènes de son père et de sa mère.

Premièrement, Père et Mère :

public class Father {  
    public int strong(){  
        return 9;  
    }  
}  
  
public class Mother {  
    public int kind(){  
        return 8;  
    }  
}

Le point culminant est ici, Fils :

public class Son {  
      
    /** 
     * 内部类继承Father类 
     */  
    class Father_1 extends Father{  
        public int strong(){  
            return super.strong() + 1;  
        }  
    }  
      
    class Mother_1 extends  Mother{  
        public int kind(){  
            return super.kind() - 2;  
        }  
    }  
      
    public int getStrong(){  
        return new Father_1().strong();  
    }  
      
    public int getKind(){  
        return new Mother_1().kind();  
    }  
}

Procédure de test :

public class Test1 {  
  
    public static void main(String[] args) {  
        Son son = new Son();  
        System.out.println("Son 的Strong：" + son.getStrong());  
        System.out.println("Son 的kind：" + son.getKind());  
    }  
  
}  
----------------------------------------  
Output:  
Son 的Strong：10  
Son 的kind：6

Le fils a hérité de son père et est devenu plus fort que son père. Il a également hérité de sa mère, mais son indice de douceur a chuté. Deux classes internes sont définies ici. Elles héritent respectivement de la classe Father et de la classe Mother, et toutes deux peuvent obtenir très naturellement le comportement de leurs classes parentes respectives. Il s'agit d'une caractéristique importante de la classe interne : la classe interne peut en hériter. classe externe. Les classes non pertinentes assurent l'indépendance des classes internes. C'est sur cette base que l'héritage multiple devient possible.

Ce qui précède est le contenu de l'amélioration Java (8) ----- Implémentation de l'héritage multiple Pour plus de contenu connexe, veuillez prêter attention au site Web PHP chinois (www. .php.cn) !