Polymorphisme JAVA introduit du superficiel au profond

Qu'est-ce que le polymorphisme ?

Le polymorphisme est divisé en deux types :

(1) Polymorphisme au moment de la compilation (polymorphisme au moment de la conception) : surcharge de méthode.

(2) Polymorphisme d'exécution : le système d'exécution JAVA décide quelle méthode appeler en fonction du type d'instance qui appelle la méthode, appelé polymorphisme d'exécution. (On parle généralement beaucoup de polymorphisme d'exécution, donc le polymorphisme fait principalement référence au polymorphisme d'exécution)

Il y a trois conditions nécessaires à l'existence du polymorphisme d'exécution :
Il doit y avoir un héritage (y compris l'implémentation de l'interface);
2. Une réécriture est requise
3. La référence de la classe parent pointe vers l'objet de la classe enfant.

------------------------------------------------------ ------ ------------------------------------

Explication détaillée :

Explication du polymorphisme d'exécution : a. Le polymorphisme d'exécution fait référence au type spécifique pointé par la variable de référence définie dans le programme et b L'appel de méthode émis via la variable de référence n'est pas déterminé lors de la programmation, mais lorsque. le programme est en cours d'exécution Il est déterminé pendant cette période qu'une variable de référence pointera vers un objet instance de quelle classe. L'appel de méthode émis par la variable de référence est une méthode implémentée dans quelle classe. Cela doit être déterminé lors de l'exécution du programme. .

1 .Le type spécifique pointé par la variable de référence définie dans le programme est incertain (c'est-à-dire vers quel objet d'instance de classe une variable de référence pointera).

Exemple :

méthode de conduite dans la classe de conducteur (véhicule de classe véhicule) {}

•oneDriver.drive( new car() )
•oneDriver.drive( new bus() )
La variable du véhicule ne peut pas déterminer quelle instance de sous-classe est utilisée.

1. L'appel de méthode émis via la variable de référence n'est pas déterminé lors de la programmation (l'appel de méthode émis par la variable de référence est une méthode implémentée dans quelle classe).

Exemple : La méthode Cut du chef, du jardinier et du barbier appelle .persion.cut().

----------------- - ------------------------------------------------- - ----------

Avantages du polymorphisme :

1. Le polymorphisme permet le remplacement du code existant. Par exemple, le polymorphisme fonctionne pour la classe Circle, mais il fonctionne également pour toute autre géométrie circulaire, comme un tore.

2. Extensibilité. Le polymorphisme rend le code extensible. L'ajout de nouvelles sous-classes n'affecte pas le polymorphisme, l'héritage et le fonctionnement des autres fonctionnalités des classes existantes. En fait, il est plus simple d’ajouter de nouvelles sous-classes pour obtenir des fonctions polymorphes. Par exemple, après avoir réalisé le polymorphisme des cônes, demi-cônes et hémisphères, il est facile d’ajouter le polymorphisme de classe sphère.

3. Capacité d'interface. Le polymorphisme est obtenu par la superclasse fournissant une interface commune aux sous-classes via des signatures de méthodes, et par les sous-classes la complétant ou la remplaçant. Comme le montre la figure 8.3. La super classe Shape dans la figure spécifie deux méthodes d'interface qui implémentent le polymorphisme, calculateArea() et calculateVolume(). Les sous-classes, telles que Circle et Sphere, améliorent ou remplacent ces deux méthodes d'interface afin d'obtenir le polymorphisme.

4. Flexibilité. Il incarne des opérations flexibles et diversifiées dans les applications et améliore l'efficacité de l'utilisation.

5. Simplicité. Le polymorphisme simplifie le processus d'écriture et de modification du code des logiciels d'application. Cette fonctionnalité est particulièrement importante et importante lorsqu'il s'agit de calculs et d'opérations sur un grand nombre d'objets.

Application pratique :

Combiné à l'utilisation de fichiers de configuration, contacter le framework Spring, utiliser la réflexion, appeler dynamiquement des classes, sans modifier le code source, ajouter directement de nouvelles classes et modifier les fichiers de configuration, pas besoin Le programme peut être étendu en redémarrant le serveur.

------------------------------------------------------ ------ ------------------------------------

Résumé :

Utilisez une référence du type de classe parent pour pointer vers l'objet de la sous-classe. La référence appelle les méthodes et les variables définies dans la classe principale. Les variables ne peuvent pas être remplacées (écrasées s'il s'agit d'une méthode dans la classe principale). la classe parent est remplacée dans la sous-classe, puis dans Lorsque cette méthode est appelée, la méthode de la sous-classe sera appelée

Faites attention aux circonstances particulières si la liste des paramètres de la méthode appelée par la classe parent fait référence. n'est pas défini, la classe parent de la classe parent sera appelée pour la trouver, si elle n'est pas encore trouvée, forcez la conversion du type vers le type de paramètre dans la liste des paramètres. La priorité spécifique de haut en bas est la suivante. :

this.show(O), super.show(O), this.show( (super)O), super.show((super)O).

------------------------------------------------------ ------ ------------------------------------

Classique écrit Questions de test (surcharge mixte et réécriture) :

(1) Classes associées

class A {
         public String show(D obj)...{
                return ("A and D");
         } 
         public String show(A obj)...{
                return ("A and A");
         } 
} 
class B extends A{
         public String show(B obj)...{
                return ("B and B");
         }
         public String show(A obj)...{
                return ("B and A");
         } 
}
class C extends B...{} 
class D extends B...{}

(2) Question : Quel est le résultat de sortie suivant ?

        A a1 = nouveau A();
        A a2 = nouveau B();
        B b = nouveau B();
        C c = nouveau C(); 
        D d = nouveau D(); 
        System.out.println(a1.show(b));   ①
        System.out.println(a1.show(c));   ②
        System.out.println(a1.show(d));   ③
        System.out.println(a2.show(b));   ④
        System.out.println(a2.show(c));   ⑤
        System.out.println(a2.show(d));   ⑥
        System.out.println(b.show(b));     ⑦
        System.out.println(b.show(c));     ⑧
        System.out.println(b.show(d));     ⑨   

（三）答案

              ①   A et A
              ②   A et A
              ③   A et D
              ④   B et A
              ⑤   B et A
              ⑥   A et D
              ⑦   B et B
              ⑧   B et B
               ⑨   A et D

（四）分析

        ①②③比较好理解，一般不会出错。④⑤就有点糊涂了，为什么输出的不是"B et B"呢？！！先来回顾一下多态性。

       运行时多态性是面向对象程序设计代码重用的一个"一个接口，多个方法"。Java态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。

        方法的重写Overriding是父类与子类之间多态性的一种表现，重载Surcharge子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同Surchargement同。

        当超类对象引用变量引用子类对象时，必须是在超类中定义过的，也就是说被子类覆盖的方法。超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）

        好了，先温习到这里，言归正传！实际上这里涉及方法调用的优先问题，优先级由高到低依次为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。是怎么工作的。

        比如④，a2.show(b)，a2是一个引用变量，类型为A，则this为a2，b是B的一个实例，于是它到类A里面找show(B obj)方法，没有找到，于是到Asuper(超类)找，而A没有超类，因此转到第三优先级this.show((super)O),this仍然是a2，这里O为B，(super)O即(super)B即A，因此它到类A里面找show(A obj)的方法，类A有这个方法，但是由于a2引用的是类B的一个对象，B覆盖了A的show(A obj)方法，因此最终锁定到类B的show(A obj)，输出为"B and A"。

Un autre exemple est ⑧, b.show(c), b est une variable de référence de type B, alors c'est b, et c est une instance de C, donc il va à la classe B pour trouver le show(C obj ), mais il n'y a pas de Found, puis allez dans la super classe A de B pour la rechercher. Il n'y a rien de tel dans A, donc nous passons également au troisième niveau de priorité this.show((super)O), c'est. b, O est C, (super)O est ( super)C est B, donc il recherche la méthode show(B obj) dans B et la trouve Puisque b fait référence à un objet de classe B, il est directement verrouillé sur. le show(B obj) de la classe B, et la sortie est "B et B".

En suivant la méthode ci-dessus, vous pouvez obtenir d'autres résultats correctement.

La question continue. Voyons maintenant comment le processus d'analyse ci-dessus reflète la connotation de la phrase en police bleue. Il dit : Lorsqu'une variable de référence d'objet de superclasse fait référence à un objet de sous-classe, le type de l'objet référencé plutôt que le type de la variable de référence détermine dont la méthode membre est appelée, mais la méthode appelée doit être définie dans la superclasse. , méthodes remplacées par les sous-classes. Prenons a2.show(b) comme exemple.

a2 est une variable de référence de type A. Elle fait référence à un objet de B, donc cette phrase signifie que B décide quelle méthode appeler. Par conséquent, le show(B obj) de B doit être appelé pour afficher "B et B". Mais pourquoi est-ce incompatible avec les résultats obtenus lors de l’analyse précédente ? ! Le problème est que nous ne devons pas ignorer la seconde moitié de la police bleue, qui indique spécifiquement : La méthode appelée doit être définie dans la super classe, c'est-à-dire une méthode remplacée par la sous-classe. Est-ce que show(B obj) dans B est défini dans la superclasse A ? Non! Sans parler d'être couvert. En fait, cette phrase cache un message : il est toujours déterminé en fonction de la priorité des appels de méthode. Il trouve show(A obj) dans la classe A. Si la sous-classe B ne remplace pas la méthode show(A obj), alors elle appelle show(A obj) de A (puisque B hérite de A, bien que cette méthode ne soit pas remplacée, cette méthode est hérité de la superclasse A. Dans un sens, B détermine toujours la méthode à appeler, mais la méthode est implémentée dans A); maintenant, la sous-classe B remplace show(A obj), donc elle se verrouille finalement sur show(A obj) de B. C'est ce que signifie cette déclaration.

Pour plus d'articles sur le polymorphisme JAVA introduits du superficiel au profond, veuillez faire attention au site Web PHP chinois !