Hay tres características principales de los objetos: encapsulación, herencia y polimorfismo. Desde una cierta perspectiva, la encapsulación y la herencia están casi todos preparados para el polimorfismo. Este es nuestro último concepto y el punto de conocimiento más importante.
1. Definición:
Polimorfismo: se refiere a permitir que los objetos de diferentes tipos respondan al mismo mensaje. Es decir, el mismo mensaje puede adoptar una variedad de comportamientos diferentes de acuerdo con los diferentes objetos enviados. (Enviar un mensaje es una llamada de función)
2. La tecnología para implementar el polimorfismo se llama: enlace dinámico, que se refiere a juzgar el tipo real del objeto referenciado durante la ejecución y llamar a su método correspondiente de acuerdo con su tipo real.
3. Función: elimine la relación de acoplamiento entre los tipos.
4. En realidad, hay innumerables ejemplos de polimorfismo. Por ejemplo, presionando la tecla F1, si el documento de ayuda AS3 se encuentra actualmente en la interfaz flash; Si la palabra ayuda actualmente se presenta bajo la palabra; Si la ayuda de Windows se encuentra actualmente bajo la ayuda y el soporte de Windows. El mismo evento ocurre en diferentes objetos y produce resultados diferentes.
5. A continuación se muestran tres condiciones necesarias para la existencia polimórfica, que requieren que todos lo memoricen al soñar.
Tres condiciones necesarias para el polimorfismo
1. Debe haber herencia;
2. Debe haber reescritura;
3. La clase de referencia de la clase principal al objeto de clase infantil.
6. Beneficios del polimorfismo:
1) Sustitutabilidad: el polimorfismo tiene intercambiabilidad para el código existente. Por ejemplo, el polimorfismo funciona en la clase Circle Circle y también funciona en cualquier otra geometría circular, como un círculo.
2) Extensibilidad: el polimorfismo es extensible para el código. Agregar nuevas subclases no afecta la operación y el funcionamiento de los polimorfismos, la herencia y otras características de las clases existentes. De hecho, es más fácil obtener funciones polimórficas agregando nuevas subclases. Por ejemplo, sobre la base de realizar el polimorfismo de conos, semiconas y hemisferios, es fácil agregar polimorfismos de esferas.
3) La capacidad de interfaz: el polimorfismo se logra mediante superclase a través de firmas de métodos, proporcionando una interfaz común para las subclases, y las subclases se implementan mejorando o sobrescribiendo. Como se muestra en la Figura 8.3. En la figura, la forma de súper clase especifica dos métodos de interfaz que implementan polimorfismo, computearea () y computeVolume (). Las subclases, como el círculo y la esfera, mejoran o anulan estos dos métodos de interfaz para lograr el polimorfismo.
4) Flexibilidad: refleja operaciones flexibles y diversas en la aplicación y mejora la eficiencia del uso.
5) Simplicidad: el polimorfismo simplifica el proceso de escritura y modificación de código del software de aplicación, especialmente cuando se trata de operaciones y operaciones de una gran cantidad de objetos, esta característica es particularmente prominente e importante.
Código de casos de gato y perro
class animal {public void eat () {System.out.println ("Eat");} public void sleep () {System.out.println ("Sleep");}} La clase Dog extiende animal {public void eat () {System.out.println ("perra comer carne");} public void sleep () {System.out.println ("" "dent sleeps"; extiende animal {public void eat () {System.out.println ("Cat Eats Fish");} public void sleep () {System.out.println ("Cat duerme en su abdomino");}} Class Pig extiende animal {public void eat () {System.out.println ("Eats Cabbag Duerme de lado ");}} // clase de herramientas para la clase de operaciones de animales animaltool {private animalTool () {}/* // llamando a la función de gato public static void useCat (cat c) {c.eat (); c.sleep (); } // Llamar a la función del perro public static void usedog (perro d) {d.eat (); d.sleep (); } // Llamando a la función de cerdo public static void usePig (cerdo p) {p.eat (); p.sleep (); } */public static void useAnimal(Animal a) {a.eat();a.sleep();}//Class all possibilities into animals}class DuoTaiDemo2 {public static void main(String[] args) {//I like cats, so I have a Cat c = new Cat();c.eat();c.sleep();//I like cats very much, so I have another Cat c2 = new Cat (); c2.eat (); c2.sleep (); // Me gustan los gatos en particular y tengo otro cat c3 = new Cat (); c3.eat (); c3.sleep (); // ... system.out.println ("-----------------------------"); // El problema es, ¿he aumentado muchos gatos y es aceptable crear un objeto // pero qué pasa? Llamando al método, ¿no crees que es muy similar? Es solo que los nombres de objetos son diferentes. // Estamos planeando usar métodos para mejorar // Invocar el método para mejorar la versión // usecat (c); // usecat (c2); // usecat (c3); // animaltool.usecat (c); // animaltool.usecat (c2); // animaltool.usecat (c2); // animaltool.usecat ( c3); animaltool.Useanimal (C2); animaltool.Useanimal (c2); animaltool.useanimal (c3); system.out.println ("------------------------"); // i como perros perros d = new dog (); perro d2 = nuevo perro (); perro d3 = nuevo Perro (); // animaltool.usedog (d); // animaltool.usedog (d2); // animaltool.usedog (d3); animaltool.useanimal (d); animaltool.useanimal (d2); animaltool.Useanimal ( d2); animalTool.Useanimal (d3); system.out.println ("-------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------- Pig (); // animaltool.usepig (p); // animaltool.usepig (p2); // animaltool.usepig (p3); animaltool.useanimal (p2); animaltool.useanimal (p2); animaltool.useanimal (p3); system.println ("--------------------------------") ")"); Leopard .../Defina la clase correspondiente, heredar el animal, proporcionar un método correspondiente y agregar llamadas de método a la clase de herramientas // los primeros deben ser escritos, no tengo objeciones //, sin embargo, la clase de herramientas se cambia cada vez, no se preocupe, ¿no puede cambiarlo //? Public static void usecat (cat c) {c.eat ();7. Método de implementación del polimorfismo en Java: implementación de la interfaz, heredando la clase principal para la reescritura del método y los métodos de sobrecarga en la misma clase.
8. Clasificación de polimorfismos en Java:
En Java, los polimorfismos se pueden dividir aproximadamente en las siguientes situaciones:
1) La persona es la clase de padres y el estudiante es la clase infantil. Entonces: Personp = NewStudent ();
2) Flable es una interfaz y el pájaro es una clase que implementa la interfaz, entonces: Fliablef = NewBird ();
3) Flable es una clase abstracta, el pájaro es una clase que hereda flable, por lo que: flablef = newBird ();
Cuando el polimorfismo, es necesario indicar que P declara como referencia a la clase principal, pero en realidad es una referencia a la clase infantil. Pero solo puede llamar a los métodos en la clase principal. Si el método en la subclase anula el método de clase principal, se llamará al método de clase principal (llamada de método virtual). Lo mismo es cierto para el polimorfismo de la interfaz. Tal vez pregunte, si F quiere llamar a su propio método, ¿no cometería eso un error? De hecho, esta también es una cobertura de método, porque la subclase que implementa la interfaz definitivamente implementará los métodos en la interfaz, por lo que en este caso se llama el método en Bird. Pero si Bird tiene un método que no se define en la interfaz, entonces no se puede llamar a F.
9. Instance de operador:
El mecanismo polimórfico del lenguaje Java hace que el tipo de declaración de la variable de referencia sea inconsistente con el tipo de objeto de referencia real. Combinado con las reglas de llamadas del método virtual, podemos concluir que dos variables de referencia declaradas como el mismo tipo también pueden tener comportamientos diferentes al llamar al mismo método. La instancia del operador se introduce aquí.
Entonces, si declaro Personp = NewStudent (); ¿Puedo convertir P al estudiante? Por supuesto, se puede hacer, pero tiene que ser forzado (el hijo quiere ser padre y él vendrá directamente, pero si el padre quiere ser un hijo, será forzado).
Por lo general, se agrega instancia al lanzamiento.
if (pinstanceofstudent) {standers = (estudiante) p;}
El polimorfismo atraviesa todo el aprendizaje de Java. Por ejemplo, al escribir declaraciones de captura al manejar excepciones, estipulamos que las excepciones de subclase deben escribirse en las excepciones de clase delantera y principal deben escribirse en la parte posterior. ¿Por qué? La razón es el polimorfismo. Nuestro formato de declaración de captura: Catch (Exceptione). Cuando se genera una excepción, un programa Java generará automáticamente un objeto de excepción. Si primero se genera una excepción de clase infantil y la excepción de la clase principal se escribe en el frente, esta declaración de captura definitivamente se ejecutará de acuerdo con el polimorfismo, y saltará después de ejecutar una declaración de captura.
10. Ejemplo:
Aunque no entiendo muy bien el polimorfismo de Java, el siguiente ejemplo me hace entender algo:
Clase A {public String Show (D obj) .. {return ("a and d");} public string show (a obj) .. {return ("a y a");}} La clase B extiende una {show public String show (b obj) .. {return ("b y b");} show public string show (A obj) .. {return ("b and a");}}}} class c extiende B {} clase E {public static void main (string [] args) {a a1 = new a (); a a2 = new b (); b b = new b (); c c = new c (); d d = new D (); system.out.println (a1.show (b)); // ①system.out.println (a1.show (c)); // ②system.out.println (a1.show (d)); //③system.out.println(a2.show(b)) ;//④system.out.println(a2.show(c)) ;//⑤system.out.println(a2.show(d))/// ⑥system.out.println (B.Show (b)); // ⑦system.out.println (B.Show (c)); // ⑧system.out.println (B.Show (d)); // ⑨}}(Iii) Respuesta
① A y A ② A y A ③ A y D ④ B y A ⑤ B y A ⑥ A y D ⑦ B y B ⑧ B y B ⑨ A y D
**** Hay una buena respuesta de la persona ****
Hay dos puntos clave para este problema:
Una es la relación entre la subclase y la clase principal, y la otra es el problema de llamar a métodos sobrecargados.
Los objetos de subclase se pueden usar directamente como objetos principales, pero de lo contrario, no pueden. Por ejemplo, las personas son la clase de padres y los estudiantes son la subclase de las personas, por lo que los objetos de los estudiantes deben tener los atributos de los objetos humanos, pero los objetos humanos pueden no necesariamente tener las características de los objetos de los estudiantes. Por lo tanto, los objetos de los estudiantes pueden usarse como objetos humanos, pero los objetos humanos no pueden usarse como objetos estudiantiles. Tenga en cuenta que al usar el objeto de subclase como objeto principal, el objeto de subclase perderá todas las características de la subclase y solo retendrá atributos y métodos con el mismo nombre que la clase principal (el mismo método de nombre no es solo el mismo nombre de función, sino que también el tipo de parámetro debe ser el mismo, de lo contrario no se retirará).
Si se define un método sobrecargado en una clase, el sistema seleccionará automáticamente y llamará al método apropiado de acuerdo con el tipo de parámetro al llamar al método.
1) A1.Shows (b), no existe un método que contenga parámetros de clase B en A, pero se llama un método que contiene parámetros de clase A de acuerdo con el principio de que la clase principal del objeto de subclase está disponible, por lo que se llama el método.
publicStringshow(Aobj)...{return("AandA");}
2) A1.show (c), la clase C es una subclase de la clase B, y la clase B es una subclase de la clase A, por lo que los objetos de clase C se pueden usar como un objeto de clase A. El resultado es el mismo que el anterior.
3) A1.show (d), llame directamente al método en un tipo de parámetro
publicStringshow(Dobj)...{
return("AandD");}
4) A2.Show (b), A2 era originalmente un objeto B, pero se asignó a la variable de Clase A, por lo que A2 solo conserva propiedades y métodos con el mismo nombre que la clase principal A. A2.Show (b) llama al método reservado en la clase B con el mismo nombre que la clase principal y el mismo parámetro que la clase principal que la clase principal
public String show(A obj)...{
return ("B and A");
}
5) A2.Show (c), el método reservado de la clase B no tiene métodos de parámetros de clase C, pero existen métodos de parámetros de clase B de los padres que contienen C, por lo que el método llamado
public String show(A obj)...{
return ("B and A");
}
Creo que esta explicación es más razonable: A2 fue originalmente un objeto de la clase B, pero el valor se asignó a la Clase A, C es una subclase de B, y B es una subclase de A, por lo que A2 conserva las propiedades y métodos en la Clase B con el mismo nombre A.
6) A2.show (d), la llamada es de la clase A
public String show(D obj)...{
return ("A and D");
}
7) B.Show (b), llame al
public String show(B obj)...{
return ("B and B");
}
8) B.Show (c), no hay un método con el parámetro C en la clase B, pero hay un método con el parámetro B, por lo que se llama al método
public String show(B obj)...{
return ("B and B");
}
9) B.Show (d), la explicación es la misma que 8
Resumir
Lo anterior es todo el contenido del resumen de este artículo del polimorfismo de Java, y espero que sea útil para todos. Si tiene alguna pregunta, deje un mensaje en cualquier momento y espere sus valiosos comentarios.