Javascript joue avec l'héritage (2)_compétences javascript

Inutile de dire que cette méthode est plus facile à comprendre, en appelant le constructeur de la classe parent dans la sous-classe. De plus, l'un des plus grands avantages de cette méthode est que l'héritage structurel peut réaliser un héritage multiple. Consultez ce code :

.

Copier le code Le code est le suivant :

fonction A()
{ }
function B()
{ }
function C()
{
this.father=A;
this.father();
delete this.father;
this .father=B;
this.father();
supprimer this.father;
}

Mais cette méthode a aussi des défauts de ceci et de cela :
Pour ceux qui sont familiers avec l'orienté objet, jetons un coup d'œil à ce morceau de code C# :

Copier le code Le code est le suivant :

classProgram
{
staticvoid Main(string [] args)
{
B b=newB();
bool temp = (typeof(A)).IsInstanceOfType(b);
Console.WriteLine(temp);
}
}
classA
{
public A()
{

}
}
classB : A
{
public B( )
{

}
}

Quel est le résultat ? b est bien sûr une instance de A :

Cependant, faisons ce test sur le code Javascript ci-dessus qui utilise l'héritage structurel :

Copier le code Le code est le suivant :

fonction A()
{ }
function B()
{ }
function C()
{
this.father=A;
this.father();
delete this.father;
this .father=B;
this.father();
delete this.father;
>
var c=new C();
alert(c instanceof A);

Mais le résultat n'était pas celui que nous avions imaginé :

En fait, c'est facile à expliquer : l'héritage structurel ne copie les attributs de la classe parent qu'en appelant la méthode constructeur de la classe parent, et ne fait rien d'autre, donc de nombreux matériaux n'appellent pas cette méthode d'héritage héritage.

Tout en voyant les inconvénients, rappelez-vous également les avantages : prend en charge l'héritage multiple.

Examinons l'héritage en C# et constatons qu'il existe deux différences les plus typiques avec cet héritage : C# ne prend pas en charge l'héritage multiple et les lacunes de l'héritage structurel que j'ai mentionnées ci-dessus. Une nouvelle méthode d’héritage est donc apparue, que nous avons appelée héritage prototypique.

En voyant le nom, vous pouvez à peu près comprendre que l'héritage prototypique utilise les caractéristiques du prototype pour réaliser l'héritage. Il s'agit de la méthode d'héritage la plus populaire en Javascript. Si vous ne comprenez pas les prototypes, veuillez suivre mon autre article : "Jouer avec les prototypes - Prototype".
Regardons d'abord le code. Ici, j'emprunte un morceau de code à "The Return of the Javascript King" :

Copier le code Le code est le suivant :

fonction Point(dimension)
{
this.dimension=dimension;
this.Test=function(){
alert("Success");
}
}
function Point2D(x,y)
{
this.x=x;
this.y=y;
}
Point2D.prototype=new Point(2);
var p=new Point2D(3,4) ;
p.Test();

Test réussi. Cela montre que Point2D a hérité des méthodes de la classe parent. Regardons à nouveau l'instance.

alerte(p instanceof Point);

Succès ! Bon, analysons l'héritage prototypique :

Je n'entrerai pas dans les détails sur les avantages de l'héritage prototypique. La structure est simple, facile à comprendre et elle peut être instanciée. Mais ses défauts sont tout aussi évidents. Vous souvenez-vous encore de l’exemple d’Animal, People, Girl dans mon dernier article ? Nous utilisons l'héritage prototypique pour y parvenir :

Copier le code Le code est le suivant :

function Animal()
{
this.Run=function(){alert("Je peux courir");}
}
function People(name) {
this.Say=function(){alert("Je m'appelle " this.name);}
}
People.prototype=new Animal();
function Girl(nom, age)
{
this.age=age;
this.Introduce=function(){alert("Je m'appelle " this.name ". Je suis " this.age);}; >}
Girl.prototype=nouvelles personnes(???);

Veuillez faire attention à la ligne de code dans ma partie rouge en gras. People est le prototype de Girl, nous devons donc passer le paramètre name lors de l'initialisation de People, mais le nom de chaque Girl est différent, donc héritage du prototype Occasion 1. lorsqu'il n'est pas utilisé : lors de la phase d'héritage du prototype, vous ne pouvez pas déterminer les paramètres à utiliser pour initialiser l'objet de classe parent. Occasion 2 : Très simple, chaque classe ne peut avoir qu'un seul prototype, ce qui signifie que l'héritage prototypique ne peut pas être utilisé pour un héritage multiple. C'est une bonne et une mauvaise chose. Parce que : Les langages orientés objet tels que Java et C# ne prennent pas en charge à l'origine l'héritage multiple, et l'héritage multiple est considéré comme incompatible avec l'héritage orienté objet

Impossible d'implémenter plusieurs interfaces !

D'accord, c'est tout pour aujourd'hui. Pour résumer, l'héritage prototype résout certains problèmes d'héritage structurel et introduit de nouveaux problèmes. D'une manière générale, l'héritage prototypique est la méthode d'héritage la plus largement utilisée, et c'est aussi le véritable moyen d'implémenter l'héritage dans la grammaire Javascript !