No hace falta decir que este método es relativamente fácil de entender, llamando al constructor de la clase principal en la subclase. Además, una de las mayores ventajas de este método es que la construcción de la herencia puede lograr múltiples herencias. Revise este código:
La copia del código es la siguiente:
función a ()
{}
función b ()
{}
función c ()
{
this.father = a;
this.father ();
Eliminar esto.
this.father = b;
this.father ();
Eliminar esto.
}
Pero este método también tiene este y esa desventaja:
Si está familiarizado con los objetos orientados, veamos este código C#:
La copia del código es la siguiente:
programa de clases
{
staticvoid main (string [] args)
{
B b = newb ();
bool temp = (typeof (a)). isinstanceOfType (b);
Console.writeLine (temp);
}
}
clase
{
público a ()
{
}
}
ClassB: A
{
Público B ()
{
}
}
¿Cuál es el resultado? B es, por supuesto, un ejemplo de A:
Sin embargo, hacemos esta prueba en la sección anterior del código JavaScript heredado usando construcciones:
La copia del código es la siguiente:
función a ()
{}
función b ()
{}
función c ()
{
this.father = a;
this.father ();
Eliminar esto.
this.father = b;
this.father ();
Eliminar esto.
}
var c = new C ();
alerta (c instancia de a);
Pero los resultados no son lo que imaginamos:
De hecho, es fácil de explicar: la herencia construida es solo una propiedad de la clase principal copiada llamando al método de construcción de la clase principal. No se realizan otras búsquedas, por lo que muchos materiales no llaman a esta herencia del método de herencia.
Al ver las deficiencias, recuerde las ventajas: apoyar más herencia.
Cuando observamos la herencia de C#, descubrimos que hay dos diferencias más típicas de esta herencia: C# no admite la herencia múltiple y las desventajas de la herencia constructiva que mencioné anteriormente. Entonces se creó un nuevo método de herencia, y nos convertimos en la herencia prototipo.
Cuando ve el nombre, puede comprender aproximadamente que la herencia prototipo es usar las características de los prototipos para lograr la herencia. Esta es la forma de herencia más popular en JavaScript. Si no comprende el prototipo, preste atención a otro artículo mío: "Jugar con el prototipo - Prototipo".
Veamos primero el código. Aquí, dibujaré un código de "The Return of the King of JavaScript":
La copia del código es la siguiente:
Punto de función (dimensional)
{
this.dimensional = dimensional;
this.test = function () {
alerta ("éxito");
}
}
punto de función2d (x, y)
{
this.x = x;
this.y = y;
}
Punto2d.prototype = nuevo punto (2);
var p = nuevo punto2d (3,4);
p.test ();
La prueba pasó. Esto muestra que Point2D ha heredado el método de clase principal y luego mire la instancia.
alerta (instancia P de punto);
¡éxito! Ok, analicemos la herencia prototipo:
No hablaré sobre las ventajas de la herencia prototipo. La estructura es simple, fácil de entender, y se puede instancia. Pero sus deficiencias también son significativas. ¿Recuerdas mi ejemplo anterior sobre animales, personas y niñas? Utilizamos la herencia prototipo para implementar lo siguiente:
La copia del código es la siguiente:
función animal ()
{
this.run = function () {alert ("puedo ejecutar");};
}
Función de personas (nombre)
{
this.say = function () {alerta ("Mi nombre es"+this.name);}
}
People.prototype = new Animal ();
Function Girl (nombre, edad)
{
this.age = edad;
this.IntrOduce = function () {alert ("Mi nombre es"+this.name+". I Am"+this.age);};
}
Girl.Prototype = New People (???);
Preste atención a la línea de código en mi parte roja en negrita. La gente es el prototipo de la niña. Entonces, cuando inicializamos a las personas, debemos pasar en el parámetro de nombre, pero el nombre de cada niña es diferente, por lo que no hay uso de la herencia prototipo: en la etapa de herencia prototipo, no puede determinar qué parámetros usar para inicializar el objeto de clase principal. Ocasión 2: es muy simple. Cada clase solo puede tener un prototipo, por lo que es, la herencia prototipo no puede usarse para la herencia múltiple. Esto es algo bueno y malo. porque:
En idiomas orientados a objetos, como Java y C#, no se admite la herencia múltiple, y se cree que la herencia múltiple es incompatible con los objetos orientados a los objetos
¡No se pueden implementar múltiples interfaces!
Bien, eso es todo lo que he escrito hoy. Para resumir, la herencia prototipo resuelve algunos problemas de herencia de construcción e introduce algunos problemas nuevos. En general, la herencia prototipo es el método de herencia más utilizado, ¡y también es la forma de implementar realmente la herencia en la gramática de JavaScript!