Js クラスの構築と継承のケースの詳細な説明

1.新しいオブジェクト: オブジェクトを作成した後、プロパティとメソッドを動的に定義します。var Car = new Object;
車の色 = "赤";
Car.showColor = 関数(){
	コンソールにログ出力します。
}
//継承する場合は、まず空のオブジェクトを作成し、次に__proto__プロトタイプチェーンを使用して継承する必要があります。var Car1 = new Object; //または = {}
Car1.__proto__ = 車;

1. ファクトリ関数: 関数内でクラスを生成します。利点は、空のオブジェクトを構築したり、プロトタイプチェーンを継承したりする必要がなく、コンストラクター関数 createCar(){ と同様に、オブジェクトのコピーを直接返すことです // この関数にパラメータ creatCar(color) を渡すこともできます
	車 = 新しいオブジェクト;
	car.color = "red"; // パラメータを渡す: car.color = color
	car.showColor = 関数(){
		コンソールにログ出力します。
	}
	車を返却する;
}

var newCar = createCar(); // パラメータを渡す: createCar("red")
//ただし、ファクトリ関数を使用すると、関数を構築するたびに showColor メソッドを構築することになり、コスト効率が悪くなります。 //したがって、クラスのファクトリ関数の前に、すべてのクラスの継承メソッドを定義できます。 function showColor(){
	コンソールにログ出力します。
}
関数createCar(){
...
	car.showColor = showColor;
...
}

2. コンストラクター メソッド: ファクトリー関数メソッドと同様に、コンストラクター メソッドを使用します。違いは、コンストラクタ内の属性はthis.attrのみであることです。
関数Car(色,数値){
	this.color = 色;
	this.num = num;
	this.showColor = 関数(){
		コンソールにログ出力します。
	}
	this.drivers = 新しい配列("mike");
}
var car1 = new Car("red",1); //Car 自体のプロパティとメソッドには現時点ではアクセスできないことに注意してください。インスタンス化後にのみアクセスできます。 //例: console.log(new Car("red",1).color)
					 //これは、コンストラクターがインスタンス化されたオブジェクトではなく、実際にはクラスのようなコンストラクターであり、js には関数オブジェクトだけでなく従来の意味でのオブジェクトもあることを意味します。//方法 1 と同様に、Car クラスの showColor 関数は構築されるたびに構築され、不要なスペースを占有します。var car2 = new Car("green",1);
car1.drivers.push("キキ");
console.log(car2.drivers); //同じ配列を参照する現象はありません 3. プロトタイプ方式: オブジェクトの派生と同様に、オブジェクトに基づいてプロトタイプ チェーンを形成し、メソッドとプロパティをバインドします function Car(){};
Car.prototype.color = "赤";
Car.prototype.showColor = 関数(){
		コンソールにログ出力します。
}
//Car.prototyoe = { // 複数のバインドされた関数を匿名クラスに入れて記述します // mathod1:function(){...};
// mathod2:function(){...};
//
Car.prototype.drivers = 新しい配列("mike","jhon");
var car1 = new Car(); //プロパティにアクセスするためのメソッドを呼び出すにはインスタンスを作成する必要があります var car2 = new Car();
car1.drivers.push("請求書");
コンソールにログ出力します。
コンソールにログ出力します。
//このように、バインドされた配列のすべての属性は同じ配列オブジェクトを指し、参照になります。 1 つのインスタンスの色を変更すると、すべての色が同時に変更されます。

1. コンストラクタ + プロトタイプ: コンストラクタはプロパティとクラス内配列のみを構築し、プロトタイプを使用してクラス内関数を宣言します。function Car(color){
	this.color = 色;
	this.drivers = 新しい配列("mike");
}
Car.prototype.showColor = 関数(){
	コンソールにログ出力します。
}
var car1 = new Car(); //プロパティにアクセスするためのメソッドを呼び出すにはインスタンスを作成する必要があります var car2 = new Car();
car1.drivers.push("請求書");
console.log(car2.drivers); //プロトタイプ メソッド 2 の欠点を回避します。クラス キーワードを使用してクラスを定義します。クラスの外部でプロパティを直接定義することはできず、クラス外部の関数オブジェクトをバインドするにはプロトタイプ メソッドを使用する必要があります。
クラスCar{
           コンストラクタ(色) {
                this.color = 色;
           }
           ドライバー = 新しい配列 ("mike","jhon");
           こんにちは = 関数(){
           		"Di Di"+ this.color を返します。 
           }
           
        }

Car.prototype.hello = function (){ //クラスバインディングメソッドの外側 return "Di Di";
}

var car1 = 新しい車("赤");
var car2 = new Car("green");
car1.drivers.push("キキ");
コンソールにログ出力します。
コンソールにログ出力します。

1. 継承を装う: クラスを新しいクラスのコンストラクターとして継承します。これは少し魔法のようです。js では、クラスは関数オブジェクトの奇妙なプロパティと見なすことができます。function Car1(color){
	this.color = 色;
	this.showColor = 関数(){
		console.log("この車は "+this.color);
	}
	this.drivers = 新しい配列("mike");
}

関数Car2(){
	this.makeSound = 関数(){
		console.log("ディディ");
	}
}

関数Car3(色){
	this.newConstruct = Car1; // コンストラクターとして渡す this.newConstruct(color); // コンストラクターを呼び出す delete this.newConstruct;
	this.newConstruct2 = Car2; // 多重継承ですが、クロージャ メカニズムのため、異なるコンストラクタ名を使用する必要があります this.newConstruct2(); 
	this.newConstruct2 を削除します。
}//同様に、偽の継承でも .prototype を使用してコンストラクターをバインドできます var car1 = new Car3("red");
var car2 = new Car3("緑");
car1.drivers.push("キキ");
コンソールにログ出力します。
car1.showColor();
car1.makeSound();
コンソールにログ出力します。

2. 親クラスのメソッド呼び出しを使用して、関数Car1(color){を継承します。
	this.color = 色;
	this.showColor = 関数(){
		console.log("この車は"+this.color);
	}
}
関数Car2(数値){
	this.num = num;
	this.makeSound = 関数(){
		console.log("ディディ");
	}
}

関数Car3(色,数値){
	Car1.call(これ、色);
	Car2.apply(this, augments); //augmentsは必要なパラメータを含む配列です}

var car1 = new Car3("赤",1);
var car2 = new Car3("green",2);
コンソールにログ出力します。
console.log(車2の番号);
car1.showColor();
car1.makeSound();

// .apply と .call をクラスの外に書くこともできますが、これらはインスタンスに対してのみ動作し、クラスの構築には使用できません。 3. 継承にプロトタイプ チェーンを使用する: __proto__ と .prototype を使用してプロトタイプ チェーンを構築します。欠点は、多重継承が実現できないことです。多重継承は、コンストラクターにバインドするか、複数のクラスを作成して連鎖的に継承することによってのみ実現できます。 function Car1(color){
	this.color = 色;
	this.showColor = 関数(){
		console.log("この車は"+this.color);
	}
}
関数 Car3(){};
Car3.プロトタイプ = 新しい Car1();

4. class...extends... を使用すると継承も実装できますが、多重継承は実装できません。プロトタイプチェーンのように複数のクラスをノードとして使用することでのみ多重継承を実装できます。これは ES6 の機能です。 ES6ではlet、public、private、protectedキーワードも導入されましたが、多重継承を実装できず、パッケージの概念もありません。これもかなり奇妙です。class Car2 extends Car1{
           コンストラクタ(色) {
                super(); //Java と同様に、super 自体が親クラスを表すことができます。ここでは、親クラスを表すために使用されます。//コンストラクター this.color = color;
           }
           ドライバー = 新しい配列 ("mike","jhon");
           こんにちは = 関数(){
           		"Di Di"+ this.color を返します。 
           }  
        }