Descripción general del polimorfismo
- El polimorfismo es la tercera característica de la orientación a objetos después de la encapsulación y la herencia.
- Para conocer el significado práctico y la comprensión personal del polimorfismo:
- Polimorfismo: la misma referencia llama al mismo método pero hace cosas diferentes.
- Las cosas reales a menudo reflejan muchas formas, como los estudiantes, los estudiantes pertenecen a la categoría de personas y un compañero específico, Zhang San, pertenece tanto a la categoría de estudiantes como a la de personas, es decir, hay múltiples formas. Esto es lo real Polimórfico.
- Como lenguaje orientado a objetos, Java también puede describir múltiples formas de una cosa. Si la clase Student hereda la clase People, el objeto de un Student es Student y People.
-
El polimorfismo se refleja en la variable de referencia de la clase principal que puede apuntar al objeto de la clase secundaria.
Nota: Cuando se utiliza la variable de referencia de la clase principal polimórfica para llamar al método, se llamará al método reescrito de la subclase. -
Definición y formato de uso del polimorfismo
定义格式：父类类型 变量名=new 子类类型(); -
comprensión:
多态是同一个行为具有多个不同表现形式或形态的能力。 多态就是同一个接口，使用不同的实例而执行不同操作。
6. Algunas ventajas del polimorfismo:
Interfaz, el polimorfismo es que la superclase proporciona una interfaz común a la subclase a través de firmas de métodos, y la subclase la completa o anula para lograrlo;
reemplazabilidad, el polimorfismo puede reemplazar el código existente;
escalabilidad, el polimorfismo puede agregar nuevas subclases sin afectar el funcionamiento y funcionamiento del polimorfismo, herencia y otras características de las clases existentes;
flexibilidad, el polimorfismo es muy flexible;
quinto, simplicidad, también simplifica el proceso de escritura y modificación de códigos de software de aplicación. .
Características de los miembros polimórficos
class People{
private int num=6;
int vis=666;
public void eat() {
System.out.println("米饭");
}
public void getNum() {
System.out.println(num);
}
}
class Student extends People{
private int num=10;
int vis=66;
public void eat() {
System.out.println("炸鸡");
}
public void study() {
System.out.println("good good study");
}
public void getNum() {
System.out.println(num);
}
}
public static void main(String[] args) {
People p=new Student();
System.out.println(p.vis);//
p.eat();
p.getNum();
//输出
//666
//炸鸡
//10
- Variables miembro polimórficas:
solo se puede obtener el valor de la variable de la clase principal - Método de miembro polimórfico:
llame al método anulado por la subclase, pero debe ser un método en la clase principal
Transformación ascendente
Formato de uso: nombre de variable de tipo padre = nuevo tipo de subtipo ();
Escenario aplicable: cuando no hay necesidad de enfrentarse al tipo de subtipo, la operación correspondiente se puede completar mejorando la extensibilidad o utilizando la función de la clase padre.
** Comprensión: ** Use el método en la clase principal, pero llame al método anulado por la subclase
Alicaído
Formato de uso: tipo de subclase nombre de variable = (tipo de subclase) variable del tipo principal;
** Escenario aplicable: cuando desee utilizar la función única de la subclase. **
** Comprensión: ** Use subcategorías para resolver problemas
Visualización de muestra de código
package ParentAndBase;
class People{
private int num=6;
public void eat() {
System.out.println("米饭");
}
public void getNum() {
System.out.println(num);
}
}
class Student extends People{
private int num=10;
public void eat() {
System.out.println("炸鸡");
}
public void study() {
System.out.println("good good study");
}
public void getNum() {
System.out.println(num);
}
}
class Teacher extends People{
public void eat() {
System.out.println("拉面");
}
public void study() {
System.out.println("day day up");
}
}
public class Demo {
public static void main(String[] args) {
People p=new Student();//向上转型
p.eat();
p.getNum();
Student stu=(Student)p;//向下转型
stu.study();
stu.eat();
People pp=new Teacher();
pp.eat();
}
}
para resumir:
Java实现多态有三个必要条件：继承、重写、向上转型。
继承：在多态中必须存在有继承关系的子类和父类。
重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。
向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。
只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。
对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。