Il existe trois caractéristiques principales de l'objet: l'encapsulation, l'héritage et le polymorphisme. Dans une certaine perspective, l'encapsulation et l'héritage sont presque tous préparés au polymorphisme. C'est notre dernier concept et le point de connaissance le plus important.
1. Définition:
Polymorphisme: fait référence à l'autorisation d'objets de différents types de répondre au même message. Autrement dit, le même message peut adopter une variété de comportements différents selon les différents objets envoyés. (L'envoi d'un message est un appel de fonction)
2. La technologie pour implémenter le polymorphisme est appelée: liaison dynamique, qui fait référence à la jugement du type réel de l'objet référencé pendant l'exécution et à l'appel de sa méthode correspondante en fonction de son type réel.
3. Fonction: Éliminez la relation de couplage entre les types.
4. En réalité, il existe d'innombrables exemples de polymorphisme. Par exemple, en appuyant sur la touche F1, si le document d'aide AS3 est actuellement apparu sous l'interface flash; Si l'aide du mot est actuellement apparue sous le mot; Si l'aide Windows est actuellement apparue sous la Windows Aide et support. Le même événement se produit sur différents objets et produit des résultats différents.
5. Vous trouverez ci-dessous trois conditions nécessaires à l'existence polymorphe, qui nécessitent que tout le monde le mémorise en rêvant!
Trois conditions nécessaires au polymorphisme
1. Il doit y avoir l'héritage;
2. Il doit y avoir une réécriture;
3. La référence de la classe parent pointe vers l'objet de classe enfant.
6. Avantages du polymorphisme:
1) Substitutabilité: Le polymorphisme a une interchangeabilité au code existant. Par exemple, le polymorphisme fonctionne sur la classe Circle Circle, et fonctionne également sur toute autre géométrie circulaire, comme un cercle.
2) Extensibilité: le polymorphisme est extensible au code. L'ajout de nouvelles sous-classes n'affecte pas le fonctionnement et le fonctionnement des polymorphismes, l'héritage et d'autres caractéristiques des classes existantes. En fait, il est plus facile d'obtenir des fonctions polymorphes en ajoutant de nouvelles sous-classes. Par exemple, sur la base de la réalisation du polymorphisme des cônes, des semi-objets et des hémisphères, il est facile d'ajouter des polymorphismes des sphères.
3) Interface-Capacité: Le polymorphisme est obtenu par des superclasses par le biais de signatures de méthode, fournissant une interface commune aux sous-classes, et les sous-classes sont implémentées en les améliorant ou en les écrasant. Comme le montre la figure 8.3. Dans la figure, la forme de super classe spécifie deux méthodes d'interface qui implémentent le polymorphisme, composeArea () et ComputeVolume (). Les sous-classes, telles que le cercle et la sphère, améliorent ou remplacent ces deux méthodes d'interface afin d'atteindre le polymorphisme.
4) Flexibilité: il reflète des opérations flexibles et diverses dans l'application 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, en particulier lorsqu'il s'agit d'opérations et d'opérations d'un grand nombre d'objets, cette fonctionnalité est particulièrement importante et importante.
Code de cas de chat et de chien
Class Animal {public void Eat () {System.out.println ("manger");} public void sleep () {System.out.println ("sleep");}} Class Dog étend Animal {public void Eat () {System.out.println ("chien mange de la viande");} public Void Sleep () {System.out.out.trint Println ("Dog SleepS"); étend l'animal {public void Eat () {System.out.println ("chat mange du poisson");} public void sleep () {System.out.println ("Cat Sleens sur son ventre");}} Class Pig étend Animal {public void Eat () {System.out.out.println ("Pig Eats Cabbage");} public Void Sleep () {System.out.println ("Pig Dorns sur le côté");}} // classe d'outils pour la classe d'opérations animales AnimalTool {private animalTool () {} / * // appelant la fonction du chat public static void usecat (chat c) {c.eat (); C.Sleep (); } // Appel de la fonction du chien public static void usedog (chien d) {d.eat (); D.Sleep (); } // Appel de la fonction de porc public static void usepig (pig p) {p.eat (); P.Sleep (); } * / public static void UseanImal (animal a) {a.eat (); a.sleep ();} // classe toutes les possibilités en animaux} classe duotaidemo2 {public static void main (String [] args) {// j'aime les chats, donc j'ai un chat c = new cat (); c.eat (); c.sleep (); // j'aime les chats c = new Cat (); Cat (); c2.eat (); c2.sleep (); // j'aime les chats en particulier et j'ai un autre chat c3 = new Cat (); c3.eat (); c3.sleep (); // ... System.out.println ("--------------------" "); // Le problème est, j'ai soulevé beaucoup de chats, et il est acceptable de créer un objet chaque fois // mais quoi? Appelez la méthode, ne pensez-vous pas que c'est très similaire? C'est juste que les noms d'objets sont différents. // Nous prévoyons d'utiliser des méthodes pour améliorer // Invoquer la méthode pour améliorer la version // usecat (c); // usecat (c2); // usecat (c3); // animaltool.usecat (c); // animaltool.usecat (c2); // animaltool.usecat (c2); // animaltool.usecat ( c3); animaltool.Useanimal (c2); animaltool.Useanimal (c2); animaltool.Useanimal (c3); System.out.println ("------------------------"); // i comme chiens chien d = nouveau chien (); chien d2 = nouveau chien (); chien d3 = nouveau Dog (); // animaltool.usedog (d); // animaltool.usedog (d2); // animaltool.usedog (d3); animaltool.useanimal (d); animaltool.useanimal (d2); animaltool.Useanimal ( d2); animaltool.useanimal (d3); System.out.println ("---------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Pig (); // animaltool.usepig (p); // animaltool.usepig (p2); // animaltool.usepig (p3); animaltool.useanimal (p2); animaltool.useanimal (p2); animaltool.useanimal (p3); System.out.println ("----------------------------------"); Léopard ... // Définissez la classe correspondante, héritez de l'animal, fournissez la méthode correspondante et ajoutez des appels de méthode à la classe d'outils // les premiers doivent être écrits, je n'ai pas d'objection //, la classe d'outils est modifiée à chaque fois, ne vous inquiétez pas // Public Static Void Usecat (Cat C) {C.Eat ();7. Méthode d'implémentation du polymorphisme en Java: implémentation d'interface, héritage de la classe parent pour la réécriture de la méthode et des méthodes de surcharge dans la même classe.
8. Classification des polymorphismes en Java:
En Java, les polymorphismes peuvent être à peu près divisés dans les situations suivantes:
1) La personne est la classe parentale et l'élève est la classe infantile. Alors: personP = newStudent ();
2) Fliable est une interface et l'oiseau est une classe qui implémente l'interface, donc: fliablef = newbird ();
3) Fliable est une classe abstraite, l'oiseau est une classe qui hérite de fliable, donc: fliablef = newbird ();
Lorsque le polymorphisme, il est nécessaire de dire que P déclare comme référence à la classe parent, mais c'est en fait une référence à la classe infantile. Mais il ne peut appeler que des méthodes dans la classe parent. Si la méthode de la sous-classe remplace la méthode de la classe parent, la méthode de la classe parent (Méthode Virtual Call) sera appelée. Il en va de même pour le polymorphisme d'interface. Peut-être que vous demanderez, si F veut appeler sa propre méthode, cela ne ferait-il pas une erreur? En fait, il s'agit également d'une couverture de méthode, car la sous-classe implémentant l'interface implémentera certainement les méthodes de l'interface, donc dans ce cas, la méthode d'oiseau est appelée. Mais si l'oiseau a une méthode qui n'est pas définie dans l'interface, alors F ne peut pas être appelé.
9.Instance de l'opérateur:
Le mécanisme polymorphe du langage Java fait que le type de déclaration de la variable de référence est incompatible avec le type de l'objet de référence réel. Combiné avec les règles d'appel de méthode virtuelle, nous pouvons conclure que deux variables de référence déclarées comme le même type peuvent également avoir des comportements différents lors de l'appel de la même méthode. L'opérateur d'instance OFF est introduit ici.
Donc, si je déclare PersonP = newStudent (); Puis-je convertir P à Student? Bien sûr, cela peut être fait, mais il doit être forcé (le fils veut être père et il viendra directement, mais si le père veut être un fils, il sera forcé).
Habituellement, l'instance est ajoutée lors de la coulée.
if (pinstanceofstudent) {étudiants = (étudiant) p;}
Le polymorphisme traverse l'ensemble de l'apprentissage Java. Par exemple, lors de la rédaction d'instructions de capture lors de la gestion des exceptions, nous stipulons que les exceptions de sous-classe doivent être écrites dans la classe avant et la classe parent, les exceptions doivent être écrites à l'arrière. Pourquoi? La raison en est le polymorphisme. Notre format de déclaration de capture: Catch (exception). Lorsqu'une exception est générée, un programme Java générera automatiquement un objet d'exception. Si une exception de classe d'enfants est générée en premier et que l'exception de la classe parent est écrite devant, cette instruction CATCH sera certainement exécutée en fonction du polymorphisme, et elle sautera après avoir exécuté une déclaration de capture.
10. Exemple:
Bien que je ne comprenne pas très bien le polymorphisme de Java, l'exemple suivant me fait comprendre certains:
classe A {public String show (d obj) .. {return ("a and d");} public string show (a obj) .. {return ("a and a");}} classe B étend une chaîne publique show (b obj) .. {return ("b et b");} public string show (a obj) .. {return ("b et a");}} class C {} classe b et a "b et a");}} B {} class e {public static void main (string [] args) {a a1 = new a (); a a2 = new b (); b b = new b (); c c = new C (); d d = new 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)); // ⑨}}(Iii) Répondre
① 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
**** Il y a une bonne réponse d'une personne ****
Il y a deux points clés à ce problème:
L'un est la relation entre la sous-classe et la classe parent, et l'autre est le problème d'appeler des méthodes surchargées.
Les objets de sous-classe peuvent être utilisés directement comme objets parents, mais sinon, ils ne le peuvent pas. Par exemple, les gens sont la classe parentale et les élèves sont la sous-classe des gens, donc les objets étudiants doivent avoir les attributs des objets humains, mais les objets humains n'ont pas nécessairement les caractéristiques des objets étudiants. Par conséquent, les objets étudiants peuvent être utilisés comme objets humains, mais les objets humains ne peuvent pas être utilisés comme objets étudiants. Notez que lors de l'utilisation de l'objet sous-classe comme objet parent, l'objet sous-classe perdra toutes les caractéristiques de sous-classe et ne conservera que des attributs et des méthodes avec le même nom que la classe parent (la même méthode de nom n'est pas seulement le même nom de fonction, mais aussi le type de paramètre doit être le même, sinon il ne sera pas conservé).
Si une méthode surchargée est définie dans une classe, le système sélectionnera et appellera automatiquement la méthode appropriée en fonction du type de paramètre lors de l'appel de la méthode.
1) a1.shows (b), il n'y a pas de méthode contenant des paramètres de classe B dans A, mais une méthode contenant des paramètres de classe A est appelée selon le principe selon lequel la classe parent de l'objet sous-classe est disponible, donc la méthode est appelée.
publicStringshow(Aobj)...{return("AandA");}
2) A1.Show (C), la classe C est une sous-classe de classe B, et la classe B est une sous-classe de la classe A, de sorte que les objets de classe C peuvent être utilisés comme objet de classe A. Le résultat est le même que ci-dessus.
3) A1.show (d), appelez directement la méthode dans A selon le type de paramètre
publicStringshow(Dobj)...{
return("AandD");}
4) A2.Show (b), A2 était à l'origine un objet B, mais il a été attribué à la classe A de la classe A, donc A2 ne conserve que des propriétés et des méthodes avec le même nom que la classe parent A. A2.Show (b) appelle la méthode réservée dans la classe B avec le même nom que la classe parent et le même paramètre que la classe parentale
public String show(A obj)...{
return ("B and A");
}
5) A2.show (c), la méthode réservée de la classe B n'a pas de méthodes de paramètres de classe C, mais il existe des méthodes de paramètre de la classe B de la parent B qui contient C, donc la méthode appelée
public String show(A obj)...{
return ("B and A");
}
Je pense que cette explication est plus raisonnable: A2 était à l'origine un objet de classe B, mais la valeur a été attribuée à la classe A, C est une sous-classe de B, et B est une sous-classe de A, donc A2 conserve les propriétés et les méthodes de la classe B avec le même nom que A.
6) A2.show (d), l'appel provient de la classe A
public String show(D obj)...{
return ("A and D");
}
7) b.show (b), appelez le
public String show(B obj)...{
return ("B and B");
}
8) b.show (c), il n'y a pas de méthode avec le paramètre C dans la classe B, mais il existe une méthode avec le paramètre B, donc la méthode est appelée
public String show(B obj)...{
return ("B and B");
}
9) B.Show (d), l'explication est la même que 8
Résumer
Ce qui précède est le contenu complet du résumé de cet article du polymorphisme Java, et j'espère que cela sera utile à tout le monde. Si vous avez des questions, veuillez laisser un message à tout moment et attendez avec impatience vos précieux commentaires!