Es gibt drei Hauptmerkmale von objektorientiertem: Einkapselung, Vererbung und Polymorphismus. Aus einer bestimmten Perspektive sind die Kapselung und Vererbung fast alle auf Polymorphismus vorbereitet. Dies ist unser letztes Konzept und der wichtigste Wissenspunkt.
1. Definition:
Polymorphismus: Bezieht sich darauf, Objekte verschiedener Typen auf dieselbe Nachricht zu reagieren. Das heißt, dieselbe Nachricht kann eine Vielzahl verschiedener Verhaltensweisen entsprechend den verschiedenen gesendeten Objekten annehmen. (Senden einer Nachricht ist ein Funktionsaufruf)
2. Die Technologie zur Implementierung des Polymorphismus wird als dynamische Bindung bezeichnet, die sich auf die Beurteilung des tatsächlichen Typs des referenzierten Objekts während der Ausführung bezieht und die entsprechende Methode gemäß ihrem tatsächlichen Typ aufruft.
3. Funktion: Beseitigen Sie die Kopplungsbeziehung zwischen Typen.
4. In Wirklichkeit gibt es unzählige Beispiele für Polymorphismus. Wenn Sie beispielsweise die F1 -Taste drücken, wird derzeit unter der Flash -Schnittstelle das AS3 -Hilfsdokument aufgetaucht. Wenn das Wort Hilfe derzeit unter dem Wort aufgetaucht ist; Wenn die Windows -Hilfe derzeit unter der Windows -Hilfe und Unterstützung aufgetaucht ist. Das gleiche Ereignis tritt an verschiedenen Objekten auf und führt zu unterschiedlichen Ergebnissen.
5. Nachfolgend sind drei notwendige Bedingungen für die polymorphe Existenz aufgeführt, bei denen jeder sie beim Träumen auswendig lernte!
Drei notwendige Bedingungen für Polymorphismus
1. Es muss Erbschaft geben;
2. Es muss neu schreiben;
3. Die übergeordnete Klassenreferenz weist auf das Objekt der untergeordneten Klasse auf.
6. Vorteile des Polymorphismus:
1) Substituierbarkeit: Polymorphismus hat die Austauschbarkeit für vorhandene Code. Zum Beispiel wirkt der Polymorphismus in der Kreisklasse und arbeitet auch in jeder anderen kreisförmigen Geometrie wie einem Kreis.
2) Erweiterbarkeit: Der Polymorphismus ist zum Code erweiterbar. Das Hinzufügen neuer Unterklassen beeinflusst keinen Einfluss auf den Betrieb und den Betrieb der Polymorphismen der bestehenden Klassen, der Vererbung und anderer Eigenschaften. Tatsächlich ist es einfacher, polymorphe Funktionen durch Hinzufügen neuer Unterklassen zu erhalten. Zum Beispiel ist es auf der Grundlage der Realisierung des Polymorphismus von Zapfen, Semikonen und Hemisphären leicht, Polymorphismen von Kugeln hinzuzufügen.
3) Grenzflächenfähigkeit: Polymorphismus wird durch Superklassen durch Methodensignaturen erreicht, wodurch Unterklassen eine gemeinsame Schnittstelle bereitgestellt werden, und Unterklassen werden durch Verbesserung oder Überschreiben implementiert. Wie in Abbildung 8.3 gezeigt. In der Abbildung gibt die Superklassenform zwei Grenzflächenmethoden an, die Polymorphismus implementieren, CompumneArea () und ComputeneVolume (). Unterklassen wie Kreis und Kugel verbessern oder überschreiben diese beiden Grenzflächenmethoden, um Polymorphismus zu erreichen.
4) Flexibilität: Es spiegelt flexible und vielfältige Operationen in der Anwendung wider und verbessert die Nutzungseffizienz.
5) Einfachheit: Polymorphismus vereinfacht den Code -Schreib- und Änderungsprozess der Anwendungssoftware, insbesondere wenn es sich um Operationen und Operationen einer großen Anzahl von Objekten handelt. Diese Funktion ist besonders prominent und wichtig.
Katzen- und Hundefallcode
Klasse Animal {public void eat () {system.out.println ("eat");} public void sleep () {System.out.println ("schlaf");}} Klasse Dog erweitert Tier {public void Eat () {System.out.Out.println ("Hund Eat Fleisch"); erweitert Tier {public void eat () {System.out.println ("Cat its fishs"); Sleeps auf seiner Seite ");}} // Werkzeugklasse für Tieroperationen Klasse AnimalTool {private AnimalTool () {}/* // Cat's Function Public statische void Usecat (kat c) {c.eat (); c.sleep (); } // Hundefunktion public static void gebraucht (Hund d) {d.eat (); d.sleep (); } // Pig's Funktion public static void usepig (pig p) {p.eat (); p.sleep (); } */public static void useanimal (Tier a) {a.eat (); a.sleep ();} // Klasse alle Möglichkeiten in Tiere} Klasse Duotaidemo2 {public static void main (String [] args) {// Ich mag Katzen, also habe ich eine Katze c = new Cat (). Cat (); c2.eat (); c2.Seep (); // Ich mag Katzen insbesondere und habe eine andere Katzen c3 = new cat (); c3.eat (); Glaubst du nicht, dass es sehr ähnlich ist? Es ist nur so, dass die Objektnamen unterschiedlich sind. // Wir planen, Methoden zur Verbesserung der Methode zu verwenden, um die Version zu verbessern // usecat (c); // usecat (c2); // usecat (c3); // Animaltool.Usecat (c); // AnimalTool.Usecat (C2); // AnimalTool.Usecat (C2); // Animaltool.Usecat (ussecat ( C3); AnimalTool.USeanimal (C2); AnimalTool.Useanimal (C2); AnimalTool.USeanimal (C3); System.out.println ("------------------------"); // i wie Hunde Hund D = neuer Hund (); Hund D2 = neuer Hund (); Hund D3 = neu Dog (); // Animaltool.Usedog (d); // Animaltool.Usedog (d2); // Animaltool.Usedog (d3); AnimalTool.Useanimal (d); Animaltool.USeanimal (D2); AnimalTool.USeanimal ((usanimal 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). Leopard ... // Die entsprechende Klasse erben, die entsprechende Methode zur Umschreibung der Werkzeugklasse hinzufügen. public void usecat (kat c) {c.eat ();7. Implementierungsmethode des Polymorphismus in Java: Implementierung der Schnittstelle, Erben der übergeordneten Klasse für die Umschreibung und Überladungsmethoden in derselben Klasse.
8. Klassifizierung von Polymorphismen in Java:
In Java können Polymorphismen grob in die folgenden Situationen unterteilt werden:
1) Person ist die Elternklasse und Schüler ist die Kinderklasse. Dann: personp = newstudent ();
2) fliable ist eine Schnittstelle und Vogel ist eine Klasse, die die Schnittstelle implementiert, also: fliablef = newbird ();
3) fliable ist eine abstrakte Klasse, Vogel ist eine Klasse, die fliable erbt, also: fliablef = newbird ();
Wenn Polymorphismus, ist es notwendig zu sagen, dass P als Verweis auf die übergeordnete Klasse deklariert wird, aber tatsächlich ein Hinweis auf die untergeordnete Klasse ist. Aber er kann nur Methoden in der Elternklasse aufrufen. Wenn die Methode in der Unterklasse die übergeordnete Klassenmethode überschreibt, wird die übergeordnete Klassenmethode (Virtual Method Call) aufgerufen. Gleiches gilt für Grenzflächenpolymorphismus. Vielleicht werden Sie fragen, ob F, wenn F seine eigene Methode anrufen möchte, nicht einen Fehler machen würde? Tatsächlich ist dies auch eine Methodenabdeckung, da die Unterklasse, die die Schnittstelle implementiert, die Methoden in der Schnittstelle definitiv implementiert. In diesem Fall wird die Methode in Vogel aufgerufen. Aber wenn Bird eine Methode hat, die in der Schnittstelle nicht definiert ist, kann F nicht aufgerufen werden.
9.Instance of Operator:
Der polymorphe Mechanismus der Java -Sprache führt dazu, dass der Deklarationstyp der Referenzvariablen mit dem Typ des tatsächlichen Referenzobjekts nicht übereinstimmt. In Kombination mit der virtuellen Methode, die Regeln aufruft, können wir zu dem Schluss kommen, dass zwei Referenzvariablen, die als derselbe Typ deklariert sind, auch unterschiedliche Verhaltensweisen haben, wenn sie dieselbe Methode aufrufen. Der Instanzoperator wird hier vorgestellt.
Also, wenn ich personpe = newstudent () deklare; Kann ich P in den Studenten umwandeln? Natürlich kann es getan werden, aber es muss gezwungen werden (der Sohn will Vater sein und er wird direkt kommen, aber wenn der Vater ein Sohn sein will, wird er gezwungen).
Normalerweise wird Instanz des Gießens hinzugefügt.
if (pinstanceOfStudent) {students = (student) p;}
Der Polymorphismus durchläuft das gesamte Java -Lernen. Wenn wir beispielsweise beim Abwickeln von Ausnahmen ein Schreiben von Anweisungen schreiben, müssen wir feststellen, dass die Ausnahmen von Unterklassen vorne geschrieben werden müssen, und die Ausnahmen der Elternklasse müssen auf der Rückseite geschrieben werden. Warum? Der Grund ist Polymorphismus. Unser Catch -Statement -Format: Catch (Ausnahme). Wenn eine Ausnahme generiert wird, generiert ein Java -Programm automatisch ein Ausnahmebobjekt. Wenn eine Ausnahmeklassenausnahme zuerst generiert und die Ausnahmeklassenausnahme vor dem Polymorphismus definitiv ausgeführt wird und nach der Ausführung einer Catch -Anweisung herausgeführt wird.
10. Beispiel:
Obwohl ich Javas Polymorphismus nicht sehr gut verstehe, lässt ich das folgende Beispiel einige verstehen:
Klasse A {public String show (d obj) .. {return ("a und d");} public String show (a obj) .. {return ("a und a");}} Klasse B erweitert eine {public String show (b obj). B {} Klasse E {public static void main (String [] args) {a a1 = new a (); a2 = new b (); b b = new b (); c c = new C (); d d = neu 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.how(d)////// ⑥System.out.println (b.show (b)); // ⑦System.out.println (b.show (c)); // ⑧System.out.println (b.show (d)); // ⑨}}(Iii) Antwort
① a und a ② a und a ③ a und d ④ b und a ⑤ b und a ⑥ a und d ⑦ b und b ⑧ b und b ⑨ a und d
**** Es gibt die Antwort eines guten Menschen ****
Es gibt zwei wichtige Punkte zu diesem Problem:
Eine ist die Beziehung zwischen der Unterklasse und der übergeordneten Klasse, und das andere ist das Problem der Aufruf überlasteter Methoden.
Subklassenobjekte können direkt als übergeordnete Objekte verwendet werden, aber ansonsten können sie nicht. Zum Beispiel sind Menschen die Elternklasse und Schüler die Unterklasse von Menschen, daher müssen Schülerobjekte die Attribute menschlicher Objekte haben, aber menschliche Objekte haben möglicherweise nicht unbedingt die Eigenschaften von Studentenobjekten. Daher können Studentenobjekte als menschliche Objekte verwendet werden, aber menschliche Objekte können jedoch nicht als Studentenobjekte verwendet werden. Beachten Sie, dass das Subklassenobjekt bei Verwendung des Subklassenobjekts als übergeordnetes Objekt alle Merkmale der Unterklasse verliert und nur Attribute und Methoden mit demselben Namen wie der übergeordneten Klasse beibehält (dieselbe Namensmethode ist nicht nur der gleiche Funktionsname, sondern auch der Parametertyp muss derselbe sein, andernfalls wird es nicht beibehalten).
Wenn in einer Klasse eine überladene Methode definiert ist, wählt das System automatisch die entsprechende Methode gemäß dem Typ des Parameters beim Aufrufen der Methode aus und ruft automatisch auf.
1) A1.Shows (b) Es gibt keine Methode, die Parameter der Klasse B in A enthält, aber eine Methode, die die Parameter der Klasse A enthält, wird nach dem Prinzip aufgerufen, dass die übergeordnete Klasse des Subklassenobjekts verfügbar ist, sodass die Methode aufgerufen wird.
publicStringshow(Aobj)...{return("AandA");}
2) A1.Show (c), Klasse C ist eine Unterklasse der Klasse B und Klasse B ist eine Unterklasse der Klasse A, sodass Objekte der Klasse C als Objekt der Klasse A verwendet werden können. Das Ergebnis ist das gleiche wie oben.
3) A1.Show (d), rufen Sie die Methode direkt in a gemäß dem Parametertyp auf
publicStringshow(Dobj)...{
return("AandD");}
4) A2.Show (b) war A2 ursprünglich ein B -Objekt, aber es wurde der Variablen der Klasse A zugewiesen, so
public String show(A obj)...{
return ("B and A");
}
5) A2.Show (c), die reservierte Methode der Klasse B enthält keine Parametermethoden der Klasse C, es gibt jedoch Parametermethoden der übergeordneten Klasse B, die C enthält, sodass die Methode aufgerufen wurde
public String show(A obj)...{
return ("B and A");
}
Ich denke, diese Erklärung ist vernünftiger: A2 war ursprünglich ein Objekt der Klasse B, aber der Wert wurde der Klasse A zugewiesen, C ist eine Unterklasse von B und B ist eine Unterklasse von A, sodass A2 die Eigenschaften und Methoden in Klasse B mit demselben Namen wie A behält. A.
6) A2.Show (d), der Anruf stammt aus der Klasse A.
public String show(D obj)...{
return ("A and D");
}
7) B.Show (b), rufen Sie die an
public String show(B obj)...{
return ("B and B");
}
8) B.Show (c) gibt es in der Klasse B keine Methode mit dem C -Parameter, aber es gibt eine Methode mit B -Parameter, daher wird die Methode aufgerufen
public String show(B obj)...{
return ("B and B");
}
9) B.Show (d), Erklärung ist die gleiche wie 8
Zusammenfassen
Das oben genannte ist der gesamte Inhalt der Zusammenfassung des Java -Polymorphismus dieses Artikels, und ich hoffe, dass es für alle hilfreich sein wird. Wenn Sie Fragen haben, hinterlassen Sie bitte eine Nachricht und freuen Sie sich auf Ihre wertvollen Kommentare!