Detaillierte Erläuterung der Js-Klassenkonstruktion und Vererbungsfälle

1. neues Objekt: Eigenschaften und Methoden dynamisch definieren nach dem Erstellen eines Objekts var Car = neues Objekt;
Auto.Farbe = "rot";
Auto.showColor = Funktion(){
	Konsole.log(diese.Farbe);
}
//Wenn Sie erben möchten, müssen Sie zuerst ein leeres Objekt erstellen und dann die Prototypkette __proto__ zum Erben verwenden var Car1 = neues Objekt; //oder = {}
Car1.__proto__ = Auto;

1. Factory-Funktion: Erzeugen Sie eine Klasse innerhalb einer Funktion. Der Vorteil besteht darin, dass Sie kein leeres Objekt konstruieren + die Prototypenkette erben müssen und direkt eine Kopie des Objekts zurückgeben, ähnlich der Konstruktorfunktion createCar(){ // Sie können dieser Funktion auch den Parameter creatCar(color) übergeben
	lass Auto = neues Objekt;
	auto.farbe = "rot"; // Parameter übergeben: auto.farbe = Farbe
	auto.showColor = Funktion(){
		Konsole.log(diese.Farbe);
	}
	Auto zurückgeben;
}

var newCar = createCar(); // Parameter übergeben: createCar("red")
//Wenn Sie jedoch die Factory-Funktion verwenden, erstellen Sie bei jeder Erstellung einer Funktion die Methode showColor, was nicht kosteneffizient ist. //Sie können also vor der Factory-Funktion der Klasse eine Methode zur Vererbung für alle Klassen definieren. function showColor(){
	Konsole.log(diese.Farbe);
}
Funktion erstelleAuto(){
...
	auto.showColor = Farbe anzeigen;
...
}

2. Konstruktormethode: Verwenden Sie die Konstruktormethode ähnlich der Factory-Funktionsmethode. Der Unterschied besteht darin, dass das Attribut im Konstruktor nur this.attr sein kann.
Funktion Auto (Farbe, Anzahl) {
	diese.farbe = Farbe;
	diese.num = num;
	diese.showColor = Funktion(){
		Konsole.log(diese.Farbe);
	}
	diese.Treiber = neues Array("mike");
}
var car1 = new Car("red",1); //Beachten Sie, dass auf die Eigenschaften und Methoden von Car selbst derzeit nicht zugegriffen werden kann. Auf sie kann erst nach der Instanziierung zugegriffen werden. //Beispiel: console.log(new Car("red",1).color)
					 //Das bedeutet, dass der Konstruktor eigentlich ein klassenähnlicher Konstruktor und kein instantiiertes Objekt ist und dass js //auch Objekte im herkömmlichen Sinn und nicht nur Funktionsobjekte hat. //Wie bei Methode 1 wird die Funktion showColor in der Klasse Car bei jeder Erstellung neu erstellt und nimmt dabei unnötigen Platz ein. var car2 = new Car("green",1);
car1.drivers.push("kiki");
console.log(car2.drivers); //Es gibt kein Phänomen der Referenzierung desselben Arrays 3. Prototypmethode: Ähnlich wie bei der Objektableitung wird eine auf dem Objekt basierende Prototypkette gebildet und anschließend werden Methoden und Eigenschaften gebunden function Car(){};
Auto.Prototyp.Farbe = "rot";
Auto.Prototyp.ShowColor = Funktion(){
		Konsole.log(diese.Farbe);
}
//Car.prototyoe = { //Füge mehrere gebundene Funktionen in eine anonyme Klasse ein, um // mathod1:function(){...} zu schreiben;
// mathod2:funktion(){...};
//}
Auto.Prototyp.Treiber = neues Array("Mike", "Jhon");
var car1 = new Car(); //Sie müssen eine Instanz erstellen, um Methoden zum Zugriff auf Eigenschaften aufzurufen. var car2 = new Car();
car1.drivers.push("Rechnung");
Konsole.log(Auto1.Farbe);
Konsole.log(Auto2.Treiber);
//Auf diese Weise zeigen alle Attribute des gebundenen Arrays auf dasselbe Array-Objekt und sind Referenzen. Wenn Sie die Farbe einer Instanz ändern, ändern sich alle Farben zusammen.

1. Konstruktor + Prototyp: Der Konstruktor erstellt nur Eigenschaften und Arrays innerhalb der Klasse und verwendet den Prototyp, um Funktionen innerhalb der Klasse zu deklarieren function Car(color){
	diese.farbe = Farbe;
	diese.Treiber = neues Array("mike");
}
Auto.Prototyp.ShowColor = Funktion(){
	Konsole.log(diese.Farbe);
}
var car1 = new Car(); //Sie müssen eine Instanz erstellen, um Methoden zum Zugriff auf Eigenschaften aufzurufen. var car2 = new Car();
car1.drivers.push("Rechnung");
console.log(car2.drivers); // Vermeidet die Nachteile der Prototypmethode 2. Verwenden Sie das Schlüsselwort „class“, um eine Klasse zu definieren: Sie können Eigenschaften nicht direkt außerhalb der Klasse definieren und müssen weiterhin die Prototypmethode verwenden, um Funktionsobjekte außerhalb der Klasse zu binden.
Klasse Auto{
           Konstruktor(Farbe) {
                diese.farbe = Farbe;
           }
           Treiber = neues Array("Mike", "Jhon");
           hallo = function(){
           		gib "Di Di"+diese.Farbe zurück; 
           }
           
        }

Car.prototype.hello = function (){ //Bindungsmethode außerhalb der Klasse return "Di Di";
}

var auto1 = neues Auto("rot");
var auto2 = neues Auto("grün");
car1.drivers.push("kiki");
Konsole.log(Auto1.Farbe);
Konsole.log(car2.hallo());

1. Vererbung vortäuschen: Erben Sie die Klasse als Konstruktor der neuen Klasse. Das ist ein bisschen magisch. In js kann die Klasse als seltsame Eigenschaft des Funktionsobjekts betrachtet werden. Funktion Car1(Farbe){
	diese.farbe = Farbe;
	diese.showColor = Funktion(){
		console.log("dieses Auto hat "+diese Farbe);
	}
	diese.Treiber = neues Array("mike");
}

Funktion Car2(){
	dies.makeSound = Funktion(){
		console.log("Di Di");
	}
}

Funktion Car3(Farbe){
	this.newConstruct = Car1; //Als Konstruktor übergeben this.newConstruct(color); //Konstruktor aufrufen delete this.newConstruct;
	this.newConstruct2 = Car2; //Mehrfachvererbung, aber aufgrund des Closure-Mechanismus müssen unterschiedliche Konstruktornamen verwendet werden this.newConstruct2(); 
	lösche this.newConstruct2;
}//In ähnlicher Weise kann bei gefälschter Vererbung auch .prototype verwendet werden, um den Konstruktor var car1 = new Car3("red"); zu binden.
var Auto2 = neues Auto3("grün");
car1.drivers.push("kiki");
Konsole.log(Auto1.Farbe);
auto1.farbezeigen();
auto1.makeSound();
Konsole.log(Auto2.Treiber);

2. Verwenden Sie den Methodenaufruf der übergeordneten Klasse und wenden Sie ihn auf die Erbfunktion Car1(color){ an.
	diese.farbe = Farbe;
	diese.showColor = Funktion(){
		console.log("dieses Auto ist"+diese.Farbe);
	}
}
Funktion Car2(num){
	diese.num = num;
	dies.makeSound = Funktion(){
		console.log("Di Di");
	}
}

Funktion Car3(Farbe,Anzahl){
	Car1.call(diese, Farbe);
	Car2.apply(this, augments); //augments ist ein Array, das die erforderlichen Parameter enthält}

var Auto1 = neues Auto3("rot",1);
var Auto2 = neues Auto3("grün",2);
Konsole.log(Auto1.Farbe);
Konsole.log(car2.num);
auto1.farbezeigen();
auto1.makeSound();

//Sie können .apply und .call auch außerhalb der Klasse schreiben, aber sie können nur auf Instanzen angewendet werden und können nicht zum Erstellen von Klassen verwendet werden. 3. Verwenden Sie eine Prototypenkette für die Vererbung: Verwenden Sie __proto__ und .prototype, um eine Prototypenkette zu erstellen. Der Nachteil besteht darin, dass keine Mehrfachvererbung erreicht werden kann. Mehrfachvererbung kann nur erreicht werden, indem sie in einen Konstruktor eingebunden oder mehrere Klassen erstellt werden, die verkettet vererbt werden. Funktion Car1 (Farbe) {
	diese.farbe = Farbe;
	diese.showColor = Funktion(){
		console.log("dieses Auto ist"+diese.Farbe);
	}
}
Funktion Car3(){};
Car3.prototype = neues Car1();

4. Mit class...extends... können Sie auch Vererbung implementieren, aber keine Mehrfachvererbung. Sie können Mehrfachvererbung nur implementieren, indem Sie mehrere Klassen als Knoten verwenden, wie die Prototypenkette. Dies ist eine Funktion von ES6. ES6 führte auch die Schlüsselwörter let, public, private und protected ein, kann jedoch keine Mehrfachvererbung implementieren und es gibt kein Konzept von Paketen, was auch ziemlich seltsam ist. class Car2 extends Car1{
           Konstruktor(Farbe) {
                super(); //Ähnlich wie in Java kann super selbst die übergeordnete Klasse darstellen. Hier wird es verwendet, um die übergeordnete Klasse darzustellen. //Konstruktor this.color = color;
           }
           Treiber = neues Array("Mike", "Jhon");
           hallo = function(){
           		gib "Di Di"+diese.Farbe zurück; 
           }  
        }