Dieser Artikel fasst die Verwendung von JavaScript zum Erbschaft zusammen. Teilen Sie es für Ihre Referenz. Die Details sind wie folgt:
Beispiel:
Kopieren Sie den Code wie folgt:/**
* Implementierungsunterklassen erben die übergeordnete Klasse, generieren jedoch keine unnötigen Eigenschaften und Methoden
* @returns {function}
*/
Define (function () {
Rückgabefunktion (Subtyp, SuperType) {
var Proto = neues Objekt (SuperType.Prototyp);
proto.constructor = subtyp;
subtyp.Prototype = Proto;
};
});
// - - »~ ~ ~ ~ ~ ———————————————— demsss« ————————— demssst
Define (function () {
Funktion ostring (en)
{
this.str = s;
this.length = this.str.Length;
}
ostring.prototype.show = function () {
alarm (this.str);
};
Return Ostring;
});
// - - »~ ~ ~ ~ ~ ———————————————— demsss« ————————— demssst
Define (['inherit', 'ostring'], function (inherit, ostring) {
Funktion Wstring (s) {
// Ruf zum Konstruktor der Elternklasse verwenden
ostring.call (this, s);
this.chLength = 2 * S.Length;
}
// andere Attribute erben
Erbe (Wstring, Ostring);
wstring.prototype.add = Funktion (W)
{
alarm (this.str + w);
};
wstring zurückgeben;
});
Schauen Sie sich das Beispiel noch einmal an
1. Verwenden Sie die Funktion, um zu implementieren:
Kopieren Sie den Code wie folgt: Funktionsperson (Name) {
this.name = name;
}
Person.Prototype.getName = function () {
kehre diesen namennamen zurück;
}
Funktion Autor (Name, Bücher) {
this.inherit = Person;
this.inherit (name);
this.books = books;
}
var au = neuer Autor ("Dororo", "viel lernen");
Au.name
Oder gleichwertig:
Kopieren Sie den Code wie folgt: Funktionsperson (Name) {
this.name = name;
}
Person.Prototype.getName = function () {
kehre diesen namennamen zurück;
}
Funktion Autor (Name, Bücher) {
Person.call (this, Name);
this.books = books;
}
var au = neuer Autor ("Dororo", "viel lernen");
Au.getName
Da dies nur als Parameter annimmt, wird der Konstruktor der übergeordneten Klassenperson und die Zuweisung aller Domänen, die der übergeordneten Klasse zugewiesen werden, der Unterklasse der Autors zugewiesen, alle außerhalb des Konstruktors der Elternklassen definierten Domänen werden nicht geerbt. Im obigen Beispiel wird Au.getName nicht definiert (undefiniert), da GetName das Prototyp -Objekt der Person definiert ist.
Darüber hinaus muss der Konstruktor einer Unterklasse den Konstruktor der Elternklasse aufrufen, bevor er seine eigene Domäne definiert, um die Definition der Unterklasse durch die übergeordnete Klasse nicht zu überschreiben. Mit anderen Worten, der Autor definiert das Eigenschaftsbuch nach Person.Call, sonst wird es von der Eigenschaft persönlich überschrieben. Gleichzeitig ist es am besten, den Prototyp nicht zu verwenden, um die Funktionsdomäne der Unterklasse in Unterklassen zu definieren, da nach einer neuen und instanziierten Unterklasse der Prototyp ausgeführt werden muss und der Konstruktor der übergeordneten Klasse auch von den übergeordneten Klassenattributen leicht überschrieben werden kann.
2. Verwenden Sie den Prototyp zur Implementierung:
Kopieren Sie den Code wie folgt: Funktionsperson (Name) {
this.name = name;
}
Person.Prototype.getName = function () {
kehre diesen namennamen zurück;
}
Funktion Autor (Name, Bücher) {
this.books = books;
}
Autor.Prototype = new Person (Name);
Autor.Prototype.Constructor = Autor;
Author.Prototype.getbooks = function () {
Gibt dies zurück.
}
var au1 = neuer Autor ("Dororo1", "viel lernen");
var au2 = neuer Autor ("Dororo2", "Lernen");
alert (au1.getName ());
alert (au2.getName ());
Diese Methode vermeidet das Problem, dass der Prototyp nicht in der Funktionsimplementierung vererbt werden kann. Weil Author.Prototype = new Person (Name); neue Person () Instanz alle Eigenschaften von Person Construct und Prototypen nennt. Der Nachteil ist jedoch, dass der Autor.Prototyp instanziiert wurde. Wenn also Unterklassen instanziiert sind, sind alle Nicht-Basis-Datentypen Referenzkopien. Im obigen Beispiel ist der Wert, der mit Beispiel AU1 oder AU2 zurückgegeben wird, dororo1.
3.. Verwenden Sie "Hybrid", um zu erreichen
Kopieren Sie den Code wie folgt: Funktionsperson (Name) {
this.name = name;
}
Person.Prototype.getName = function () {
kehre diesen namennamen zurück;
}
Funktion Autor (Name, Bücher) {
this.base = New Person (Name);
für (var key in this.base) {
if (! Dies [Schlüssel]) {
dieses [Schlüssel] = this.base [Schlüssel];
}
}
this.book = books;
}
var au1 = neuer Autor ("Dororo1", "Arbeit");
var au2 = neuer Autor ("Dororo2", "Play");
alert (au1.getName ());
alert (au2.getName ());
Au1.Book;
AU2.Book;
Es gehört zu einer Erweiterung, kopieren Sie alle Domänen der übergeordneten Klasse in eine Unterklasse. Es gibt überhaupt keine Probleme in den oben genannten zwei Aspekten.
Parasitärer Kombinationsmodus)
Die JS -Vererbung umfasst die Vererbung von Attributen und Vererbung von Methoden, die durch verschiedene Methoden implementiert werden.
1. Vererbung von Attributen
Die Vererbung von Attributen wird erreicht, indem die Ausführungsumgebung der Funktion geändert wird. Die Ausführungsumgebung zur Änderung der Funktion kann mit zwei Methoden implementiert werden: call () und anwenden ().
Wir erstellen zunächst eine "Klasse" für tierische "Klasse" (weil es kein Konzept einer Klasse in JS gibt, hier ist nur ein Schein, es ist eigentlich nur ein Funktionsfunktionsobjekt).
Kopieren Sie den Code wie folgt: Funktion Animal (Typename) {
// Fügen Sie einen Eigenschaftstypennamen für die Ausführungsumgebung der aktuellen Methode hinzu (diese).
// Aber die Ausführungsumgebung (dies) muss ausgeführt werden, bevor sie bestimmt werden kann
this.typename = typename;
this.colors = ["rot", "während"];
}
// Ich möchte dem Prototyp der Funktion zwei (Objekt genutzte) Methoden hinzufügen
Animal.Prototype.hout = function () {alert ("Ich bin: -" + this.typename);};
Animal.Prototype.eat = function () {alert ("Ich bin: -" + this.typename)};
//-Definieren Sie einen Löwen-"Klasse" (eigentlich eine Funktion)
Funktion Löwe (tn) {
//-Führen Sie die Tiermethode aus und ändern Sie die Tierausführungsumgebung mit diesem Löwen durch den ersten Parameter anwenden
// In ähnlicher Weise muss Löwen ausgeführt werden, um festzustellen, wer es ist
Animal.
}
Lion.Prototype = Animal.Prototyp; // Erben Sie die übergeordnete Klassenmethode und erledigen Sie sie-aber dies ist nicht gut geschrieben. Wenn die untergeordnete Klasse eine Methode hinzufügt, hat die übergeordnete Klasse auch diese Methode. Dies ist eine Zeigerreferenz
Lion.Prototype.hunt = function () {
alarm ("Ich bin: Löwe, ich möchte jagen ~~ ・ ~");
}
var aminm = new Animal ();
Aminm.Hunt (); // --- Sie können auf die Unterklasse-Methode zugreifen, die nicht gut ist
// ----- Also, wie kann ich dieses Problem lösen? ? ? ? ? ?
// --- Lösung: Sie können dies schreiben, wenn Sie die Methode erben:
Lion.Prototype = new Animal (); // Erben Sie die übergeordnete Klassenmethode und weisen Sie dem Prototyp -Prototyp das Tierobjekt zu. Tatsächlich enthält es auch Attribute.
var lion = new Lion (); // Neben dem Erstellen des neuen Schlüsselworts wird auch die Ausführungsumgebung des Löwenobjekts an das Löwenobjekt selbst geändert
// --- Mit anderen Worten, nach Abschluss des Neuen ist dies in der Löwenfunktion die Löwenfunktion selbst, und dann wird die Löwenfunktion aufgerufen
Analysieren Sie die neuen Schlüsselwörter:
Das neue Schlüsselwort ist sehr großartig. Im vorherigen Code erledigt das neue Schlüsselwort die folgenden Aufgaben:
1) Öffnen Sie den Haufen Platz, um sich auf das Speichern von Löwenobjekten vorzubereiten
2) Ändern Sie die Ausführungsumgebung des Löwenobjekts selbst, so dass diese der Löwenfunktion auf das Löwenfunktionsobjekt selbst zeigt.
3) Nennen Sie den "Konstruktor" der Löwenklasse "und erstellen Sie ein Löwenobjekt
4) weisen Sie der Variablen L die Haufenadresse des Löwenfunktion Objekts zu und zeigt zu diesem Zeitpunkt L auf das Löwenfunktionsobjekt
Lion.Shout ();
lion.eat ();
Diese Vererbung hat jedoch einen Nachteil: Der Konstruktor der übergeordneten Klasse wird zweimal aufgerufen, einmal anrufen und dann erneut neu.
Ich hoffe, dieser Artikel wird für JavaScript -Programme aller hilfreich sein.