Conceptos básicos de herencia y síntesis
Herencia: se puede construir una nueva clase en función de una clase existente. Heredar las clases existentes puede reutilizar métodos y dominios de estas clases. Sobre esta base, se pueden agregar nuevos métodos y dominios para expandir las funciones de la clase.
Síntesis: la creación del objeto original en una nueva clase se llama síntesis. De esta manera, puede reutilizar el código existente sin cambiar su formulario.
1. Sintaxis hereditaria
La palabra clave extiende indica que la nueva clase se deriva de una clase existente. Una clase existente se llama clase principal o clase base, y una nueva clase se llama subclase o clase derivada. Por ejemplo:
El estudiante de clase extiende a la persona {}El estudiante de clase hereda la persona. La clase de persona se llama clase de padre o clase base, y la clase de estudiantes se llama clase de subclase o derivada.
2. Síntesis de síntesis
La síntesis es relativamente simple, que es crear una clase existente en una clase.
Estudiante de clase {perro perro;}Estilo ascendente
1. Conceptos básicos
El papel de la herencia radica en la reutilización del código. Dado que la herencia significa que todos los métodos de la clase principal también se pueden usar en subclases, los mensajes enviados a la clase principal también se pueden enviar a la clase de derivados. Si hay un método EAT en la clase de persona, entonces habrá este método en la clase de estudiante, lo que significa que el objeto estudiantil también es un tipo de persona.
Clase Persona {public void eat () {System.out.println ("eat");} static void show (persona p) {p.eat ();}} El estudiante de clase pública extiende la persona {public static void main (string [] args) {estudiante s = nuevo estudiante (); persona.show (s); //}}}【Resultados de la operación】:
comer
El método de espectáculo definido en persona se usa para recibir manijas de personas, pero en ① recibe una referencia al objeto del alumno. Esto se debe a que el objeto estudiantil también es un objeto de persona. En el método Show, el mango (referencia al objeto) que se pasa puede ser un objeto de persona y un objeto de clase derivado de la persona. Este comportamiento de convertir las manijas de los estudiantes en mangos de persona se convierte en un patrón ascendente.
2. ¿Por qué necesitas rastrear la forma?
¿Por qué quiere ignorar deliberadamente el tipo de objeto que lo llama al llamar a comer? Si hace que el método del programa simplemente obtenga el manejo del estudiante, parece más intuitivo y fácil de entender, pero eso hará que cada nueva clase se deriva de la clase de persona implementa su propio método de espectáculo:
Valor de clase {private int count = 1; private valor (int count) {this.count = count;} public static static Final Value v1 = New Value (1), v2 = New Value (2), v3 = New Value (3);} Class Persona {public void Eat (valor v) {System.out.println ("Person.eat ()");} Class Teacher Extends {Public Void Person {Value (Value V) {System.out.println ("maestro.eat ()");}} Estudiante de clase extiende a la persona {public void eat (valor v) {system.out.println ("student.eat ()");}} clase pública upcastingdemo {public static void show (student s) {s.eat.v1);} Public static show (maestro t) {t.eat (value.v1);} public static void show (persona p) {p.eat (value.v1);} public static void main (string [] args) {estudiante s = nuevo estudiante (); maestro t = nuevo maestro (); persona p = nueva persona (); show (s); show (t); show (p);}}Un defecto obvio en este enfoque es que es necesario definir métodos estrechamente relacionados con la clase de derivado de cada clase de persona, lo que resulta en mucho código duplicado. Por otro lado, si olvida la sobrecarga del método, no informará un error. Los tres métodos de exhibición en el ejemplo anterior se pueden fusionar en uno:
Public static void show (persona p) {p.eat (value.v1);} Vinculación dinámica
Al realizar Show (s), el resultado de la salida es Student.eat (). De hecho, este es el resultado deseado, pero no parece estar ejecutado en la forma que esperábamos. Echemos un vistazo al método del programa nuevamente:
Public static void show (persona p) {p.eat (value.v1);}Recibe un mango de una persona. Al realizar Show (s), ¿cómo sabe que la persona maneja apunta a un objeto de estudiante en lugar de un objeto de maestro? El compilador no tiene forma de saberlo, lo que implica el problema vinculante que se explicará a continuación.
1. Método de enlace de llamadas
Conectar un método y el mismo método Cuerpo juntos se llama enlace. Si la unión se realiza antes de ejecutar, se llama "encuadernación temprana". En el ejemplo anterior, cuando solo hay un mango de una persona, el compilador no sabe qué método llamar. Java implementa un mecanismo de llamadas de método que puede determinar el tipo de objeto durante la operación y luego llamar al método correspondiente. Este enlace basado en el tipo de objeto se llama enlace dinámico durante la operación. A menos que se declare un método final, todos los métodos en Java están dinámicamente unidos.
Use una imagen para representar la relación de herencia de la forma ascendente:
En código, se resume como:
Shapes=newShape();
Según la relación de herencia, es legal asignar el mango del objeto círculo creado a una forma, porque el círculo pertenece a una forma.
Cuando se llama uno de los métodos de clase básica:
Shapes=newShape();
En este momento, se llama circle.draw (), que se debe a la unión dinámica.
Clase Persona {void eat () {} void speak () {}} El niño de clase extiende a la persona {void eat () {System.out.println ("boy.eat ()");} void speak () {System.out.println ("boy.speak ()");}} class Girl Extends Person {void eat eat eat () {System.out.println ("girl.eat ()");}} personas de clase pública {public static persona randperson () {switch ((int) (math.random () * 2)) {predeterminado: caso 0: return new boy (); caso 1: return new Girl ();}} public estatic ooid main (string [] args) {persona [] p = nueva persona [4]; <p.length;Para todas las clases derivadas de la persona, la persona establece una interfaz general, y todas las clases derivadas tienen dos comportamientos: comer y hablar. La clase derivada anula estas definiciones y redefine ambos comportamientos. En la clase principal, Randperson selecciona aleatoriamente el mango del objeto persona. ** El estilo de apelación ocurre en la declaración de devolución. La declaración de retorno ** toma un mango de niño o niña y la devuelve como un tipo de persona. En este momento, no sé de qué tipo es, solo sé que es un mango de objeto de persona. En el método principal, llame al método Randperson para completar el objeto de la persona a la matriz, pero no conozca la situación específica. Cuando se llama el método EAT de cada elemento de la matriz, la función de la unión dinámica es ejecutar el método redefinido del objeto.
Sin embargo, la unión dinámica es un requisito previo, y el método de enlace debe existir en la clase base, de lo contrario no se compilará y pasará.
clase persona {void eat () {system.out.println ("persona.eat ()");}} class boy extiende persona {void eat () {system.out.println ("boy.eat ()");} void speak () {system.out.println ("boy.speak ()");} Persons de clase pública {público static static {Persona p = new boy (); p.eat (); p.speak (); // El método speak () está indefinido para la persona tipo}}Si no se define ningún método de anulación en la subclase, se llama el método en la clase principal:
Clase Persona {void eat () {System.out.println ("Person.eat ()");}} El niño de clase extiende a la persona {} personas de clase pública {public static void main (string [] args) {persona p = new boy (); p.eat ();}}}【Resultados de la operación】:
Person.eat ()
2. ANIA DE MÉTODOS ESTÁTICOS
Agregue la palabra clave estática a los métodos anteriores y conviértelos en métodos estáticos:
Persona de clase {static void eat () {system.out.println ("persona.eat ()");} static void speak () {system.out.println ("persona.speak ()");}} class boy extiende la persona {static void eat () {system.println ("boy.eat ()");}} void static void eat () {system.println ("boy.eat ()");}} void static void eat () {system.println ("boy.eat ()");}} void static void eat () {System.out.println ("boy.speak ()");}} La chica de la clase extiende a la persona {static void eat () {system.out.println ("girl.eat ()");} static void speak () {system.out.println ("girl.speak ()");} public class de clase PERSONS {PUBLIC STACITO PERSONS () {Switch () ((int) (math.random () * 2)) {predeterminado: caso 0: return new boy (); caso 1: return new girl ();}} public static void main (string [] args) {persona [] p = nueva persona [4]; for (int i = 0; i <p.length; i ++) {p [i] = randperson ();// boy al azar al azar o al azar p.length; 【Resultados de la operación】:
Person.eat ()
Person.eat ()
Person.eat ()
Person.eat ()
Resultados de observación: para los métodos estáticos, sin importar a qué objeto de subclase se refiera a la clase principal, se llama el método de la clase principal.
Fórmula mnemónica
- Método estático: el método estático analiza la clase principal
-Métodos no estáticos: los métodos no estatales analizan las subclases
Resumir
Lo anterior es todo el contenido de la interpretación detallada de este artículo del concepto de herencia Java, y espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!