polimorfismo

Todos los lenguajes POO tendrán tres características:

Embalaje (haga clic para saltar)

Herencia (haga clic para saltar)

polimorfismo

Polimorfismo: cuando se ejecuta el código, cuando se pasan objetos de diferentes clases, se llamarán los métodos de las clases correspondientes.

Para lograr polimorfismo en Java, se deben cumplir las siguientes condiciones, todas las cuales son indispensables:

Debe estar bajo el sistema de herencia;
La subclase debe reescribir el método en la clase principal;
El método anulado se invoca mediante una referencia de la clase principal.

volver a escribir

Ya conocemos la herencia, por lo que la primera pregunta que enfrentamos es ¿qué es la reescritura?

Reescribir (anular): También conocido como cobertura. La reescritura es la subclase que reescribe el proceso de implementación de la modificación no estática, no privada, la modificación no final, el método no constructivo, etc. de la clase principal, y el valor de retorno (el tipo de retorno también puede satisfacer la relación padre-hijo ) y los parámetros formales no se pueden cambiar. Es decir, el caparazón permanece sin cambios, ¡pero el núcleo se reescribe!

La ventaja de reescribir es que las subclases pueden definir su propio comportamiento específico según sus necesidades. Es decir, la subclase puede implementar el método de la clase principal según sea necesario.

Nota: Evite llamar a métodos anulados en los constructores.

Reglas para la reescritura de métodos:

Cuando una subclase reescribe el método de la clase principal, generalmente debe ser coherente con el prototipo del método de la clase principal: el nombre del método y la lista de parámetros deben ser completamente consistentes ;

El tipo de valor de retorno del método anulado puede ser diferente, pero debe tener una relación padre-hijo ;

Los derechos de acceso no pueden ser inferiores a los derechos de acceso del método anulado en la clase principal . Por ejemplo: si el método de la clase principal se modifica mediante público, el método reescrito en la subclase no se puede declarar como protegido y los métodos y métodos de construcción de la clase principal modificados por estático y privado no se pueden reescribir ;

El método reescrito se puede especificar explícitamente usando la anotación @Override . Con esta anotación, puede ayudarnos a realizar algunas comprobaciones de legalidad. Por ejemplo, si accidentalmente escribió mal el nombre del método (como aet), el compilador encontrará que no hay ningún método aet en la clase principal, compilará e informará un error, lo que indica que no se puede reescribir.

En este punto nos hemos encontrado con dos puntos y nos falta el último punto. Y el tercer punto es llamar al método reescrito mediante la referencia de la clase principal. Para lograrlo es necesaria una transformación ascendente.

Transformación ascendente

La transformación ascendente consiste en darse cuenta de que el código llama al método reescrito a través de la referencia de la clase principal. La transformación ascendente es realmente muy simple.

Transformación ascendente: de hecho, consiste en crear un objeto de subclase y usarlo como objeto de clase principal.

Formato gramatical: nombre de objeto de tipo de clase principal = nuevo tipo de subclase ()

Utilice escenarios para una transformación ascendente:

Asignación directa (el ejemplo anterior es asignación directa)

parámetro del método

el método devuelve

Ventajas de la transformación ascendente : simplifica y flexibiliza la implementación del código. Defectos
de la transformación ascendente : no se pueden llamar métodos específicos de subclases.

Después de usar la transformación ascendente, se puede llamar al método anulado a través de la referencia de la clase principal, pero no se puede llamar al método anulado .

class Animal{
    public String name = "花花";
    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
}
class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println(this.name+"在吃狗粮");
    }
    public void a(){
        System.out.println("hhh");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();
        //打印花花在吃狗粮
        Animal dog2 = new Animal();
        dog2.eat();
        //打印花花正在吃饭
    }
}

Ejemplo de polimorfismo de clase:

class Animal{
    public String name = "花花";
    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
}
class Dog extends Animal{
    @Override
    public void eat(){
        System.out.println(this.name+"在吃狗粮");
    }
}
class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println(this.name+"在吃猫粮");
    }
}
public class Test {
    public static void fun(Animal arr){
        arr.eat();
    }
    public static void main(String[] args) {
        //数组的每个成员都会发生向上转型
        Animal[] arr = {new Dog(),
                        new Cat()};
    //此时就会发现调用同一个方法fun()会有两种结果
        fun(arr[0]);
        fun(arr[1]);
    }
}

Ventajas y desventajas del polimorfismo.

Puede reducir la "complejidad cíclica" del código y evitar el uso de una gran cantidad de if - else;

¿Qué es la "complejidad ciclomática"?

La complejidad ciclomática es una forma de describir qué tan complejo es un fragmento de código. Si un fragmento de código es sencillo, es relativamente simple y fácil de entender. Y si hay muchas ramas condicionales o declaraciones de bucle, se considera más complicado de entender;

Por lo tanto, podemos calcular de manera simple y aproximada el número de declaraciones condicionales y declaraciones de bucle en un fragmento de código, lo que se denomina "complejidad cíclica". Si la complejidad ciclomática de un método es demasiado alta, se debe considerar la refactorización.

Mayor escalabilidad;
Defecto polimórfico: se reduce la eficiencia de ejecución del código.

Polimorfismo de clase (JAVA)

polimorfismo

volver a escribir

Transformación ascendente

Ejemplo de polimorfismo de clase:

Ventajas y desventajas del polimorfismo.

Supongo que te gusta