Inutile de dire que cette méthode est relativement facile à comprendre, 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 la construction de l'héritage peut réaliser un héritage multiple. Passez en revue ce code:
La copie de code est la suivante:
fonction a ()
{}
fonction b ()
{}
fonction c ()
{
this.fher = a;
this.fher ();
Supprimer ce que le père;
this.father = b;
this.fher ();
Supprimer ce que le père;
}
Mais cette méthode a également ceci et ce désavantage:
Si vous êtes familier avec les objets, regardons ce code C #:
La copie de code est la suivante:
programme de classe
{
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 un exemple de a:
Cependant, nous faisons ce test sur la section ci-dessus du code JavaScript hérité à l'aide de constructions:
La copie de code est la suivante:
fonction a ()
{}
fonction b ()
{}
fonction c ()
{
this.fher = a;
this.fher ();
Supprimer ce que le père;
this.father = b;
this.fher ();
Supprimer ce que le père;
}
var c = new C ();
alerte (C instance de a);
Mais les résultats ne sont pas ce que nous avons imaginé:
En fait, il est facile à expliquer: l'hérédité construite n'est qu'une propriété de la classe parent copiée en appelant la méthode de construction de la classe parent. Aucune autre recherche n'est effectuée, donc de nombreux matériaux n'appellent pas cette méthode d'héritage.
Tout en voyant les lacunes, rappelez-vous les avantages: soutenir plus d'héritage.
Lorsque nous regardons l'héritage de C #, nous avons constaté qu'il existe deux différences les plus typiques de cet héritage: C # ne prend pas en charge l'héritage multiple et les inconvénients de l'héritage constructif que j'ai mentionné ci-dessus. Ainsi, une nouvelle méthode d'héritage a été créée et nous sommes devenus un prototype d'hérédité.
Lorsque vous voyez le nom, vous pouvez à peu près comprendre que l'héritage du prototype consiste à utiliser les caractéristiques des prototypes pour atteindre l'héritage. C'est la façon la plus populaire d'héritage en JavaScript. Si vous ne comprenez pas le prototype, veuillez prêter attention à un autre article: "Jouer avec le prototype - prototype".
Regardons d'abord le code. Ici, je vais tirer sur un morceau de code de "The Return of the King of Javascript":
La copie de code est la suivante:
Point de fonction (dimension)
{
this.dimensional = dimensional;
this.test = function () {
alerte ("succès");
}
}
Function Point2d (x, y)
{
this.x = x;
this.y = y;
}
Point2d.prototype = nouveau point (2);
var p = new Point2d (3,4);
P.Test ();
Le test a réussi. Cela montre que Point2d a hérité de la méthode de la classe parent, puis examine l'instance.
alert (p point de vue);
succès! Ok, analysons l'héritage du prototype:
Je ne parlerai pas des avantages de l'héritage prototype. La structure est simple, facile à comprendre et peut être instanciée. Mais ses lacunes sont également importantes. Vous souvenez-vous de mon exemple précédent sur les animaux, les gens et la fille? Nous utilisons l'héritage du prototype pour implémenter les éléments suivants:
La copie de code est la suivante:
fonction Animal ()
{
this.run = function () {alert ("je peux exécuter");};
}
fonction des gens (nom)
{
this.say = function () {alert ("mon nom est" + this.name);}
}
People.prototype = New Animal ();
Fonction Girl (nom, âge)
{
this.age = âge;
this.introduce = function () {alert ("mon nom est" + this.name + ". je suis" + this.age);};
}
Girl.prototype = de nouvelles personnes (???);
Veuillez faire attention à la ligne de code dans ma partie audacieuse rouge. Les gens sont le prototype de la fille. Ainsi, lorsque nous initialisons les gens, nous devons passer dans le paramètre de nom, mais le nom de chaque fille est différent, il n'y a donc pas d'utilisation de l'héritage prototype: dans l'étape de l'héritage prototype, vous ne pouvez pas déterminer les paramètres à utiliser pour initialiser l'objet de classe parent. Occasion 2: C'est très simple. Chaque classe ne peut avoir qu'un seul prototype, c'est donc que l'héritage du prototype ne peut pas être utilisé pour l'héritage multiple. C'est une bonne chose et une mauvaise chose. parce que:
Dans les langues orientées objet telles que Java et C #, l'héritage multiple n'est pas pris en charge, et l'hérédité multiple est incompatible avec
Plusieurs interfaces ne peuvent pas être implémentées!
D'accord, c'est tout ce que j'ai écrit aujourd'hui. Pour résumer, l'héritage du prototype résout certains problèmes d'hérédité de construction et introduit de nouveaux problèmes. Dans l'ensemble, l'héritage du prototype est la méthode d'héritage la plus largement utilisée, et c'est aussi la façon de vraiment mettre en œuvre l'héritage dans la grammaire JavaScript!