¿Por qué usar polimorfismo?

Hola usuario de nuestra página, descubrimos la solución a tu interrogante, desplázate y la verás más abajo.

Solución:

En su ejemplo, el uso de polimorfismo no es increíblemente útil ya que solo tiene una subclase de FlyingMachine. El polimorfismo se vuelve útil si tiene múltiples tipos de FlyingMachine. Entonces podrías tener un método que acepte cualquier tipo de FlyingMachine y utiliza su fly() método. Un ejemplo podría ser testMaxAltitude(FlyingMachine).

Otra característica que solo está disponible con polimorfismo es la capacidad de tener un List y usarlo para almacenar Jet, Kiteo VerySmallPebbles.

Uno de los mejores casos que se pueden hacer para usar polimorfismo es la capacidad de referirse a interfaces en lugar de implementaciones.

Por ejemplo, es mejor tener un método que devuelva como List en lugar de un ArrayList. De esa manera, puedo cambiar mi implementación dentro del método a un LinkedList o un Stack sin romper ningún código que use mi método.

¿Cuál es la ventaja del polimorfismo cuando ambos flm.fly() y j.fly()
dame la misma respuesta?

La ventaja es que

FlyingMachines flm = new Jet();
flm.fly();

devoluciones

"Start, Taxi, Fly"

en lugar de

"No implementation"

Eso es polimorfismo. Llama fly() en un objeto de tipo FlyingMachine y todavía sabe que es de hecho un Jet y llama al apropiado fly() método en lugar del incorrecto que genera "No implementation".

Eso significa que puede escribir métodos que funcionan con objetos de tipo FlyingMachine y alimentarlo con todo tipo de subtipos como Jet o Helicopter y esos métodos siempre harán lo correcto, es decir, llamar al fly() método del tipo apropiado en lugar de hacer siempre lo mismo, es decir, generar "No implementation".

Polimorfismo

El polimorfismo no es útil en su ejemplo.

• a) Se vuelve útil cuando tiene diferentes tipos de objetos y puede escribir clases que pueden funcionar con todos esos tipos diferentes porque todos se adhieren a la misma API.

• b) También se vuelve útil cuando puedes agregar nuevos FlyingMachines a su aplicación sin cambiar nada de la lógica existente.

a) yb) son dos caras de la misma moneda.

Déjame mostrarte cómo.

ejemplo de código

import java.util.ArrayList;
import java.util.List;

import static java.lang.System.out;

public class PolymorphismDemo 

    public static void main(String[] args) 
        List machines = new ArrayList();
        machines.add(new FlyingMachine());
        machines.add(new Jet());
        machines.add(new Helicopter());
        machines.add(new Jet());

        new MakeThingsFly().letTheMachinesFly(machines);
    


class MakeThingsFly 
    public void letTheMachinesFly(List flyingMachines) 
        for (FlyingMachine flyingMachine : flyingMachines) 
            flyingMachine.fly();
        
    


class FlyingMachine 
    public void fly() 
        out.println("No implementation");
    


class Jet extends FlyingMachine 
    @Override
    public void fly() 
        out.println("Start, taxi, fly");
    

    public void bombardment() 
        out.println("Fire missile");
    


class Helicopter extends FlyingMachine 
    @Override
    public void fly() 
        out.println("Start vertically, hover, fly");
    

Explicación

a) El MakeThingsFly la clase puede trabajar con todo lo que es de tipo FlyingMachine.

b) El método letTheMachinesFly también funciona sin ningún cambio (!) cuando agrega una nueva clase, por ejemplo PropellerPlane:

public void letTheMachinesFly(List flyingMachines) 
        for (FlyingMachine flyingMachine : flyingMachines) 
            flyingMachine.fly();
        
    
}

Ese es el poder del polimorfismo. Puede implementar el principio abierto-cerrado con él.

La razón por la que usa polimorfismo es cuando crea marcos genéricos que toman un montón de objetos diferentes con la misma interfaz. Cuando crea un nuevo tipo de objeto, no necesita cambiar el marco para acomodar el nuevo tipo de objeto, siempre que siga las “reglas” del objeto.

Entonces, en su caso, un ejemplo más útil es crear un tipo de objeto “Aeropuerto” que acepte diferentes tipos de FlyingMachines. El aeropuerto definirá una función “AllowPlaneToLand”, similar a:

//pseudocode
void AllowPlaneToLand(FlyingMachine fm)

    fm.LandPlane();

Siempre que cada tipo de FlyingMachine defina un método LandPlane adecuado, puede aterrizar correctamente. El aeropuerto no necesita saber nada sobre FlyingMachine, excepto que para aterrizar el avión, necesita invocar LandPlane en FlyingMachine. Así que el Aeropuerto ya no necesita cambiar, y puede seguir aceptando nuevos tipos de Máquinas Voladoras, ya sea un planeador, un OVNI, un paracaídas, etc.

Entonces, el polimorfismo es útil para los marcos que se construyen alrededor de estos objetos, que pueden acceder de forma genérica a estos métodos sin tener que cambiar.

Tienes la posibilidad dar visibilidad a este tutorial si lograste el éxito.

---

---

Utiliza Nuestro Buscador