¿Qué es el polimorfismo, para qué sirve y cómo se usa?

https://stackoverflow.com/questions/1031273

06-07-2019
|

Pregunta

Solución

Si piensa en las raíces griegas del término, debería ser obvio.

Poly = many: polygon = muchos lados, poliestireno = muchos estirenos ^(a), polyglot = muchos idiomas, etc.
Morph = cambio o forma: morfología = estudio de la forma biológica, Morpheus = el dios griego de los sueños capaz de tomar cualquier forma.

Entonces, el polimorfismo es la capacidad (en programación) de presentar la misma interfaz para diferentes formas subyacentes (tipos de datos).

Por ejemplo, en muchos idiomas, los enteros y flotantes son implícitamente polimórficos, ya que puede sumar, restar, multiplicar, etc., independientemente del hecho de que los tipos son diferentes. Raramente se consideran objetos en el término habitual.

Pero, de la misma manera, una clase como BigDecimal o Rational o Imaginary también puede proporcionar esas operaciones, aunque operen en diferentes tipos de datos.

El ejemplo clásico es la clase Shape y todas las clases que pueden heredar de ella (cuadrado, círculo, dodecaedro, polígono irregular, splat, etc.).

Con polimorfismo, cada una de estas clases tendrá datos subyacentes diferentes. Una forma de punto solo necesita dos coordenadas (suponiendo que esté en un espacio bidimensional, por supuesto). Un círculo necesita un centro y radio. Un cuadrado o rectángulo necesita dos coordenadas para las esquinas superior izquierda e inferior derecha y (posiblemente) una rotación. Un polígono irregular necesita una serie de líneas.

Al hacer que la clase sea responsable de su código y sus datos, puede lograr el polimorfismo. En este ejemplo, cada clase tendría su propia función Draw () y el código del cliente simplemente podría hacer:

shape.Draw()

para obtener el comportamiento correcto para cualquier forma.

Esto contrasta con la antigua forma de hacer cosas en las que el código estaba separado de los datos, y habría tenido funciones como drawSquare () y drawCircle () .

La orientación a objetos, el polimorfismo y la herencia son conceptos estrechamente relacionados y son vitales para conocer. Ha habido muchas '' balas de plata '' durante mi larga carrera, que básicamente se esfumó, pero el paradigma OO ha resultado ser bueno. Aprende, entiéndelo, ámalo, te alegrarás de haberlo hecho :-)

^(a) Originalmente escribí eso como una broma, pero resultó ser correcto y, por lo tanto, no tan divertido. El momomer estireno está hecho de carbono e hidrógeno, C₈H₈ , y el poliestireno está hecho de grupos de eso, (C ₈ H ₈) _n .

Tal vez debería haber dicho que un pólipo se produjo muchas veces en la letra p aunque, ahora que tuve que explicar el chiste, incluso eso tampoco parece gracioso.

A veces, deberías dejar de fumar mientras estás detrás :-)

Otros consejos

El polimorfismo es cuando puedes tratar un objeto como una versión genérica de algo, pero cuando accedes a él, el código determina qué tipo exacto es y llama al código asociado.

Aquí hay un ejemplo en C #. Cree cuatro clases dentro de una aplicación de consola:

public abstract class Vehicle
{
    public abstract int Wheels;
}

public class Bicycle : Vehicle
{
    public override int Wheels()
    {
        return 2;
    }
}

public class Car : Vehicle
{
    public override int Wheels()
    {
        return 4;
    }
}

public class Truck : Vehicle
{
    public override int Wheels()
    {
        return 18;
    }
}

Ahora cree lo siguiente en el Main () del módulo para la aplicación de consola:

public void Main()
{
    List<Vehicle> vehicles = new List<Vehicle>();

    vehicles.Add(new Bicycle());
    vehicles.Add(new Car());
    vehicles.Add(new Truck());

    foreach (Vehicle v in vehicles)
    {
        Console.WriteLine(
            string.Format("A {0} has {1} wheels.",
                v.GetType().Name, v.Wheels));
    }
}

En este ejemplo, creamos una lista de la clase base Vehículo, que no sabe cuántas ruedas tiene cada una de sus subclases, pero sí sabe que cada subclase es responsable de saber cuántas ruedas tiene .

Luego agregamos una bicicleta, automóvil y camión a la lista.

A continuación, podemos recorrer cada Vehículo en la lista y tratarlos a todos de manera idéntica, sin embargo, cuando accedemos a cada propiedad 'Ruedas' de Vehículos, la clase Vehículo delega la ejecución de ese código a la subclase relevante.

Se dice que este código es polimórfico, ya que el código exacto que se ejecuta está determinado por la subclase a la que se hace referencia en tiempo de ejecución.

Espero que esto te ayude.

De Comprensión y aplicación del polimorfismo en PHP , gracias Steve Guidetti.

Polimorfismo es una palabra larga para un concepto muy simple.

El polimorfismo describe un patrón en la programación orientada a objetos en el que las clases tienen una funcionalidad diferente mientras comparten una interfaz común.

La belleza del polimorfismo es que el código que trabaja con las diferentes clases no necesita saber qué clase está usando, ya que todas se usan de la misma manera.   Una analogía del mundo real para el polimorfismo es un botón. Todo el mundo sabe cómo usar un botón: simplemente le aplicas presión. Qué hace un botón & # 8220; & # 8221; sin embargo, depende de a qué está conectado y al contexto en el que se usa & # 8212; pero el resultado no afecta cómo se usa. Si su jefe le dice que presione un botón, ya tiene toda la información necesaria para realizar la tarea.

En el mundo de la programación, el polimorfismo se usa para hacer que las aplicaciones sean más modulares y extensibles. En lugar de declaraciones condicionales desordenadas que describen diferentes cursos de acción, crea objetos intercambiables que selecciona según sus necesidades. Ese es el objetivo básico del polimorfismo.

Si alguien dice CORTE a estas personas

El cirujano
El estilista
El actor

¿Qué pasará?

El cirujano comenzaría a hacer una incisión.
El estilista comenzaría a cortar el cabello de alguien.
El actor dejaría de actuar abruptamente fuera de la escena actual, en espera de orientación de dirección.

Entonces, la representación anterior muestra Qué es el polimorfismo (mismo nombre, comportamiento diferente) en OOP.

Si vas a una entrevista y el entrevistador te pide que digas / muestres un ejemplo en vivo de polimorfismo en la misma habitación en la que estamos sentados, di-

Respuesta - Puerta / Windows

¿Te preguntas cómo?

A través de la puerta / ventana: puede venir una persona, puede entrar aire, puede llegar la luz, puede venir la lluvia, etc.

Para entenderlo mejor y de una manera simple, utilicé el ejemplo anterior. Si necesita una referencia para el código, siga las respuestas anteriores.

Explicación simple por analogía

El presidente de los Estados Unidos emplea polimorfismo. ¿Cómo? Bueno, tiene muchos asesores:

Asesores militares
Asesores legales
Físicos nucleares (como asesores)
Asesores médicos
etc. etc.

Todos deberían ser responsables de una sola cosa: Ejemplo:

El presidente no es un experto en recubrimiento de zinc o física cuántica. No sabe muchas cosas, pero solo sabe una: cómo manejar el país.

Es un poco lo mismo con el código: las preocupaciones y responsabilidades se deben separar a las clases / personas relevantes. De lo contrario, haría que el presidente supiera literalmente todo en el mundo: toda la Wikipedia. Imagine tener toda la wikipedia en una clase de su código: sería una pesadilla mantenerla.

¿Por qué es una mala idea que un presidente sepa todas estas cosas específicas?

Si el presidente le dijera específicamente a la gente qué hacer, eso significaría que el presidente debe saber exactamente qué hacer. Si el presidente necesita saber cosas específicas por sí mismo, eso significa que cuando necesite hacer un cambio, deberá hacerlo en dos lugares, no solo en uno.

Por ejemplo, si la EPA cambia las leyes de contaminación, cuando eso suceda: tendría que hacer un cambio en la Clase de la EPA y también la clase del Presidente. Cambiar el código en dos lugares en lugar de uno puede ser peligroso, porque es mucho más difícil de mantener.

¿Existe un mejor enfoque?

Hay un mejor enfoque: el presidente no necesita conocer los detalles de nada; puede exigir el mejor consejo de las personas específicamente encargadas de hacer esas cosas.

Puede usar un enfoque polimórfico para administrar el país.

Ejemplo - de usar un enfoque polimórfico:

Todo lo que hace el presidente es pedirle a la gente que lo asesore, y eso es lo que realmente hace en la vida real, y eso es lo que debe hacer un buen presidente. todos sus asesores responden de manera diferente, pero todos saben lo que quiere decir el presidente con: Asesorar (). Tiene cientos de personas entrando en su oficina. En realidad no importa quiénes son. Todo lo que el presidente sabe es que cuando les pide "asesorar" saben cómo responder en consecuencia :

public class MisterPresident
{
    public void RunTheCountry()
    {
        // assume the Petraeus and Condi classes etc are instantiated.
        petraeus.Advise(); // # Petraeus says send 100,000 troops to Fallujah
        condolezza.Advise(); // # she says negotiate trade deal with Iran
        healthOfficials.Advise(); // # they say we need to spend $50 billion on ObamaCare
    }
}

Este enfoque permite al presidente dirigir el país literalmente sin saber nada sobre asuntos militares, ni sobre atención médica o diplomacia internacional: los detalles se dejan a los expertos. Lo único que el presidente necesita saber es esto: " Advise () " ;.

Lo que NO quieres:

public class MisterPresident
{
    public void RunTheCountry()
    {
        // people walk into the Presidents office and he tells them what to do
        // depending on who they are.

        // Fallujah Advice - Mr Prez tells his military exactly what to do.
        petraeus.IncreaseTroopNumbers();
        petraeus.ImproveSecurity();
        petraeus.PayContractors();

        // Condi diplomacy advice - Prez tells Condi how to negotiate

        condi.StallNegotiations();
        condi.LowBallFigure();
        condi.FireDemocraticallyElectedIraqiLeaderBecauseIDontLikeHim();

        // Health care

        healthOfficial.IncreasePremiums();
        healthOfficial.AddPreexistingConditions();
    }
}

¡NO! ¡NO! ¡NO! En el escenario anterior, el presidente está haciendo todo el trabajo: sabe sobre el aumento del número de tropas y las condiciones preexistentes. Esto significa que si las políticas de Oriente Medio cambian, entonces el presidente tendría que cambiar sus comandos, y también la clase Petraeus. Solo deberíamos tener que cambiar la clase de Petraeus, porque el presidente no debería verse empantanado en ese tipo de detalles. No necesita saber sobre los detalles. Todo lo que necesita saber es que si hace un pedido, todo se encargará. Todos los detalles deben dejarse a los expertos.

Esto le permite al presidente hacer lo que mejor sabe hacer: establecer una política general, verse bien y jugar golf: P.

Cómo se implementa realmente: a través de una clase base o una interfaz común

Eso en efecto es polimorfismo, en pocas palabras. ¿Cómo se hace exactamente? A través de "implementar una interfaz común" o utilizando una clase base (herencia): consulte las respuestas anteriores que detallan esto más claramente. (Para comprender más claramente este concepto, necesita saber qué es una interfaz, y deberá comprender qué es la herencia. Sin eso, podría tener dificultades).

En otras palabras, Petraeus, Condi y HealthOfficials serían todas clases que "implementan una interfaz". - Llamémoslo la interfaz IAdvisor que solo contiene un método: Advise () . Pero ahora nos estamos adentrando en los detalles.

Esto sería ideal

    public class MisterPresident
    {
            // You can pass in any advisor: Condi, HealthOfficials,
            //  Petraeus etc. The president has no idea who it will 
            // be. But he does know that he can ask them to "advise" 
            // and that's all Mr Prez cares for.

        public void RunTheCountry(IAdvisor governmentOfficer)
        {             
            governmentOfficer.Advise();              
        }
    }


    public class USA
    {
        MisterPresident president;

        public USA(MisterPresident president)
        {
            this.president = president;
        }

        public void ImplementPolicy()
        {
            IAdvisor governmentOfficer = getAdvisor(); // Returns an advisor: could be condi, or petraus etc.
            president.RunTheCountry(governmentOfficer);
        }
    }

Resumen

Todo lo que realmente necesita saber es esto:

El presidente no necesita conocer los detalles; estos se dejan a otros.
Todo lo que el presidente necesita saber es preguntar quién entra por la puerta para asesorarlo, y sabemos que sabrán absolutamente qué hacer cuando se les solicite asesoramiento (porque en realidad todos son asesores (o asesores de IA: ))

Realmente espero que te ayude. Si no comprende nada, publique un comentario e intentaré nuevamente.

El polimorfismo es la capacidad de tratar una clase de objeto como si fuera la clase principal.

Por ejemplo, supongamos que hay una clase llamada Animal, y una clase llamada Perro que hereda de Animal. El polimorfismo es la capacidad de tratar cualquier objeto Perro como un objeto Animal así:

Dog* dog = new Dog;
Animal* animal = dog;

Polimorfismo:

Es el concepto de programación orientada a objetos. La capacidad de diferentes objetos para responder, cada uno a su manera, a mensajes idénticos se llama polimorfismo.

El polimorfismo resulta del hecho de que cada clase vive en su propio espacio de nombres. Los nombres asignados dentro de una definición de clase no entran en conflicto con los nombres asignados en cualquier lugar fuera de ella. Esto es cierto tanto para las variables de instancia en la estructura de datos de un objeto como para los métodos del objeto:

Así como los campos de una estructura C están en un espacio de nombres protegido, así son las variables de instancia de un objeto.
Los nombres de los métodos también están protegidos. A diferencia de los nombres de las funciones de C, los nombres de métodos no son símbolos globales. El nombre de un método en uno la clase no puede entrar en conflicto con los nombres de métodos en otras clases; dos clases muy diferentes pueden implementar métodos con nombres idénticos.

Los nombres de los métodos son parte de la interfaz de un objeto. Cuando se envía un mensaje solicitando que un objeto haga algo, el mensaje nombra el método que debe realizar el objeto. Debido a que diferentes objetos pueden tener métodos con el mismo nombre, el significado de un mensaje debe entenderse en relación con el objeto particular que recibe el mensaje. El mismo mensaje enviado a dos objetos diferentes puede invocar dos métodos distintos.

El principal beneficio del polimorfismo es que simplifica la interfaz de programación. Permite establecer convenciones que se pueden reutilizar en clase tras clase. En lugar de inventar un nuevo nombre para cada nueva función que agregue a un programa, se pueden reutilizar los mismos nombres. La interfaz de programación puede describirse como un conjunto de comportamientos abstractos, aparte de las clases que los implementan.

Ejemplos :

Ejemplo-1: Aquí hay un ejemplo simple escrito en Python 2.x .

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Dog('Lassie')]

for animal in animals:
    print animal.name + ': ' + animal.talk()

Ejemplo-2: El polimorfismo se implementa en Java usando el método sobrecarga y el método anulando conceptos.

Consideremos el ejemplo de Car para discutir el polimorfismo. Tome cualquier marca como Ford, Honda, Toyota, BMW, Benz, etc., todo es de tipo automóvil.

Pero cada uno tiene sus propias características avanzadas y tecnología más avanzada involucrada en su comportamiento de movimiento.

Ahora creemos un tipo básico de Coche

Car.java

public class Car {

    int price;
    String name;
    String color;

    public void move(){
    System.out.println("Basic Car move");
    }

}

Implementemos el ejemplo de Ford Car.

Ford extiende el tipo Car para heredar todos sus miembros (propiedades y métodos).

Ford.java

public class Ford extends Car{
  public void move(){
    System.out.println("Moving with V engine");
  }
}

La clase Ford anterior amplía la clase Car y también implementa el método move (). Aunque el método de movimiento ya está disponible para Ford a través de la Herencia, Ford aún lo ha implementado a su manera. Esto se llama anulación de método.

Honda.java

public class Honda extends Car{
  public void move(){
    System.out.println("Move with i-VTEC engine");
  }
}

Al igual que Ford, Honda también extiende el tipo de automóvil e implementa el método de movimiento a su manera.

La anulación del método es una característica importante para habilitar el polimorfismo. Usando la anulación de métodos, los tipos Sub pueden cambiar la forma en que funcionan los métodos que están disponibles a través de la herencia.

PolymorphismExample.java

public class PolymorphismExample {
  public static void main(String[] args) {
    Car car = new Car();
    Car f = new Ford();
    Car h = new Honda();

    car.move();
    f.move();
    h.move();

  }
}

Salida de ejemplo de polimorfismo:

En el método principal de la clase PolymorphismExample, he creado tres objetos: Car, Ford y Honda. Los tres objetos se refieren por el tipo de automóvil.

Tenga en cuenta un punto importante aquí que un tipo de superclase puede referirse a un tipo de objeto de subclase pero no es posible el viceversa. La razón es que todos los miembros de la superclase están disponibles para la subclase usando la herencia y durante el tiempo de compilación, el compilador intenta evaluar si el tipo de referencia que estamos usando tiene el método al que está intentando acceder.

Entonces, para las referencias car, f y h en el Ejemplo de polimorfismo, el método de movimiento existe desde el tipo Car. Entonces, el compilador pasa el proceso de compilación sin ningún problema.

Pero cuando se trata de la ejecución en tiempo de ejecución, la máquina virtual invoca los métodos en los objetos que son subtipos. Entonces, el método move () se invoca desde sus respectivas implementaciones.

Por lo tanto, todos los objetos son del tipo Car, pero durante el tiempo de ejecución, la ejecución depende del objeto en el que ocurre la invocación. Esto se llama polimorfismo.

Por lo general, esto se refiere a la capacidad de un objeto de tipo A de comportarse como un objeto de tipo B. En la programación orientada a objetos, esto generalmente se logra por herencia. Algunos enlaces de wikipedia para leer más:

EDITAR: enlaces rotos fijos.

El polimorfismo es esto:

class Cup {
   int capacity
}

class TeaCup : Cup {
   string flavour
}

class CoffeeCup : Cup {
   string brand
}

Cup c = new CoffeeCup();

public int measure(Cup c) {
    return c.capacity
}

puede pasar solo una Copa en lugar de una instancia específica. Esto ayuda en general porque no tiene que proporcionar una instancia de measure () específica para cada tipo de taza

Sé que esta es una pregunta anterior con muchas buenas respuestas, pero me gustaría incluir una respuesta de una oración:

Tratar un tipo derivado como si fuera su tipo base.

Hay muchos ejemplos anteriores que muestran esto en acción, pero creo que esta es una buena respuesta concisa.

(Estaba buscando otro artículo sobre algo completamente diferente ... y apareció el polimorfismo ... Ahora pensé que sabía lo que era el Polimorfismo ... pero aparentemente no de esta hermosa manera explicada ... Quería escribirlo en algún lugar ... mejor aún lo compartiré ...)

http: //www.eioba. com / a / 1htn / how-i-explicó-rest-to-my-wife

sigue leyendo desde esta parte:

..... polimorfismo. Esa es una manera geek de decir que a diferentes sustantivos se les puede aplicar el mismo verbo.

El término polimorfismo proviene de:

poly = many

morfismo = la capacidad de cambiar

En programación, el polimorfismo es una " técnica " que te permite "mirar" en un objeto como ser más de un tipo de cosa. Por ejemplo:

Un objeto de estudiante también es un objeto de persona. Si usted "mira" (es decir, emitir) al alumno, probablemente pueda solicitar la identificación del alumno. No siempre se puede hacer eso con una persona, ¿verdad? (una persona no es necesariamente un estudiante, por lo tanto, podría no tener una identificación de estudiante). Sin embargo, una persona probablemente tiene un nombre. Un estudiante también lo hace.

Línea inferior, " mirando " en el mismo objeto desde diferentes ángulos puede darle diferentes '' perspectivas '' (es decir, diferentes propiedades o métodos)

Entonces, esta técnica le permite construir cosas que se pueden "mirar" desde diferentes ángulos.

¿Por qué usamos polimorfismo? Para empezar ... abstracción. En este punto, debería haber suficiente información :)

En términos generales, es la capacidad de interactuar con varios tipos diferentes de objetos usando la misma API o una API superficialmente similar. Hay varias formas:

Sobrecarga de funciones: definición de múltiples funciones con el mismo nombre y diferentes tipos de parámetros, como sqrt (float), sqrt (double) y sqrt (complex). En la mayoría de los idiomas que permiten esto, el compilador seleccionará automáticamente el correcto para el tipo de argumento que se le pasa, por lo tanto, este es un polimorfismo en tiempo de compilación.
Métodos virtuales en OOP: un método de una clase puede tener varias implementaciones adaptadas a los detalles de sus subclases; Se dice que cada uno de ellos anula la implementación dada en la clase base. Dado un objeto que puede ser de la clase base o cualquiera de sus subclases, la implementación correcta se selecciona sobre la marcha, por lo tanto, este es el polimorfismo en tiempo de ejecución.
Plantillas: una característica de algunos lenguajes OO mediante la cual una función, clase, etc. puede ser parametrizada por un tipo. Por ejemplo, puede definir una " lista genérica " clase de plantilla, y luego instanciarlo como "lista de enteros", "lista de cadenas", tal vez incluso "lista de listas de cadenas" o similar. Generalmente, escribe el código una vez para una estructura de datos de tipo de elemento arbitrario, y el compilador genera versiones de él para los distintos tipos de elementos.

Usemos una analogía. Para un guión musical dado, cada músico que lo toca le da su propio toque en la interpretación.

El músico se puede abstraer con interfaces, el género al que pertenece el músico puede ser una clase abstracta que define algunas reglas globales de interpretación y cada músico que toca se puede modelar con una clase concreta.

Si eres un oyente de la obra musical, tienes una referencia al guión, p. 'Fuga and Tocata' de Bach y cada músico que lo interpreta lo hace polimórficamente a su manera.

Esto es solo un ejemplo de un posible diseño (en Java):

public interface Musician {
  public void play(Work work);
}

public interface Work {
  public String getScript();
}

public class FugaAndToccata implements Work {
  public String getScript() {
    return Bach.getFugaAndToccataScript();
  }
}

public class AnnHalloway implements Musician {
  public void play(Work work) {
    // plays in her own style, strict, disciplined
    String script = work.getScript()
  }
}

public class VictorBorga implements Musician {
  public void play(Work work) {
    // goofing while playing with superb style
    String script = work.getScript()
  }
}

public class Listener {
  public void main(String[] args) {
    Musician musician;
    if (args!=null && args.length > 0 && args[0].equals("C")) {
      musician = new AnnHalloway();
    } else {
      musician = new TerryGilliam();
    }
    musician.play(new FugaAndToccata());
}

He proporcionado una descripción general de alto nivel del polimorfismo para otra pregunta:

Polimorfismo en c ++

Espero que ayude. Un extracto ...

... ayuda comenzar con una prueba simple y una definición de [polimorfismo]. Considere el código:

Type1 x;
Type2 y;

f(x);
f(y);

Aquí, f () es realizar alguna operación y se le están dando los valores x y y como entradas. Para ser polimórfico, f () debe poder operar con valores de al menos dos tipos distintos (por ejemplo, int y double ), encontrar y ejecutando código apropiado para el tipo.

(continúa en Polimorfismo en c ++ )

El polimorfismo es una habilidad del objeto que puede tomarse de muchas formas. Por ejemplo, en la clase humana, un hombre puede actuar de muchas formas cuando hablamos de relaciones. EX: Un hombre es padre de su hijo y él es esposo de su esposa y él es maestro de sus alumnos.

El polimorfismo es la capacidad de un objeto de adoptar muchas formas. El uso más común del polimorfismo en OOP ocurre cuando una referencia de clase primaria se usa para referirse a un objeto de clase secundaria. En este ejemplo que está escrito en Java, tenemos tres tipos de vehículos. Creamos tres objetos diferentes e intentamos ejecutar su método de ruedas:

public class PolymorphismExample {

    public static abstract class Vehicle
    {
        public int wheels(){
            return 0;
        }
    }

    public static class Bike extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 2;
        }
    }

    public static class Car extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 4;
        }
    }

    public static class Truck extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 18;
        }
    }

    public static void main(String[] args)
    {
        Vehicle bike = new Bike();
        Vehicle car = new Car();
        Vehicle truck = new Truck();

        System.out.println("Bike has "+bike.wheels()+" wheels");
        System.out.println("Car has "+car.wheels()+" wheels");
        System.out.println("Truck has "+truck.wheels()+" wheels");
    }

}

El resultado es:

Para obtener más información, visite https: // github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java . Espero que ayude.

El polimorfismo es la capacidad del programador para escribir métodos del mismo nombre que hacen cosas diferentes para diferentes tipos de objetos, dependiendo de las necesidades de esos objetos. Por ejemplo, si estaba desarrollando una clase llamada Fraction y una clase llamada ComplexNumber , ambos podrían incluir un método llamado display () , pero cada uno de ellos implementaría ese método de manera diferente. En PHP, por ejemplo, puede implementarlo así:

//  Class definitions

class Fraction
{
    public $numerator;
    public $denominator;

    public function __construct($n, $d)
    {
        //  In real life, you'd do some type checking, making sure $d != 0, etc.
        $this->numerator = $n;
        $this->denominator = $d;
    }

    public function display()
    {
        echo $this->numerator . '/' . $this->denominator;
    }
}

class ComplexNumber
{
    public $real;
    public $imaginary;

    public function __construct($a, $b)
    {
        $this->real = $a;
        $this->imaginary = $b;
    }

    public function display()
    {
        echo $this->real . '+' . $this->imaginary . 'i';
    }
}


//  Main program

$fraction = new Fraction(1, 2);
$complex = new ComplexNumber(1, 2);

echo 'This is a fraction: '
$fraction->display();
echo "\n";

echo 'This is a complex number: '
$complex->display();
echo "\n";

Salidas:

This is a fraction: 1/2
This is a complex number: 1 + 2i

Algunas de las otras respuestas parecen implicar que el polimorfismo se usa solo junto con la herencia; por ejemplo, tal vez Fraction y ComplexNumber implementan una clase abstracta llamada Number que tiene un método display () , qué fracción y número complejo están obligados a implementar. Pero no necesita herencia para aprovechar el polimorfismo.

Al menos en lenguajes de tipo dinámico como PHP (no sé acerca de C ++ o Java), el polimorfismo permite al desarrollador llamar a un método sin necesariamente conocer el tipo de objeto con anticipación, y confiando en que la implementación correcta de Se llamará al método. Por ejemplo, supongamos que el usuario elige el tipo de Number creado:

$userNumberChoice =  El polimorfismo es la capacidad del programador para escribir métodos del mismo nombre que hacen cosas diferentes para diferentes tipos de objetos, dependiendo de las necesidades de esos objetos. Por ejemplo, si estaba desarrollando una clase llamada  Fraction  y una clase llamada  ComplexNumber , ambos podrían incluir un método llamado  display () , pero cada uno de ellos implementaría ese método de manera diferente. En PHP, por ejemplo, puede implementarlo así: 

//  Class definitions

class Fraction
{
    public $numerator;
    public $denominator;

    public function __construct($n, $d)
    {
        //  In real life, you'd do some type checking, making sure $d != 0, etc.
        $this->numerator = $n;
        $this->denominator = $d;
    }

    public function display()
    {
        echo $this->numerator . '/' . $this->denominator;
    }
}

class ComplexNumber
{
    public $real;
    public $imaginary;

    public function __construct($a, $b)
    {
        $this->real = $a;
        $this->imaginary = $b;
    }

    public function display()
    {
        echo $this->real . '+' . $this->imaginary . 'i';
    }
}


//  Main program

$fraction = new Fraction(1, 2);
$complex = new ComplexNumber(1, 2);

echo 'This is a fraction: '
$fraction->display();
echo "\n";

echo 'This is a complex number: '
$complex->display();
echo "\n";


 Salidas: 

This is a fraction: 1/2
This is a complex number: 1 + 2i


 Algunas de las otras respuestas parecen implicar que el polimorfismo se usa solo junto con la herencia; por ejemplo, tal vez  Fraction  y  ComplexNumber  implementan una clase abstracta llamada  Number  que tiene un método  display () , qué fracción y número complejo están obligados a implementar. Pero no  necesita  herencia para aprovechar el polimorfismo. 

 Al menos en lenguajes de tipo dinámico como PHP (no sé acerca de C ++ o Java), el polimorfismo permite al desarrollador llamar a un método sin necesariamente conocer el tipo de objeto con anticipación, y confiando en que la implementación correcta de Se llamará al método. Por ejemplo, supongamos que el usuario elige el tipo de  Number  creado: 

<*>

 En este caso, se llamará al método apropiado  display () , aunque el desarrollador no pueda saber con anticipación si el usuario elegirá una fracción o un número complejo. GET['userNumberChoice'];

switch ($userNumberChoice) {
    case 'fraction':
        $userNumber = new Fraction(1, 2);
        break;
    case 'complex':
        $userNumber = new ComplexNumber(1, 2);
        break;
}

echo "The user's number is: ";
$userNumber->display();
echo "\n";

En este caso, se llamará al método apropiado display () , aunque el desarrollador no pueda saber con anticipación si el usuario elegirá una fracción o un número complejo.

En la programación orientada a objetos, el polimorfismo se refiere a la capacidad de un lenguaje de programación para procesar objetos de manera diferente dependiendo de su tipo de datos o clase . Más específicamente, es la capacidad de redefinir métodos para clases derivadas.

Polimorfismo significa literalmente, múltiples formas. (o muchas formas): Objeto de diferentes clases y método del mismo nombre, pero los flujos de trabajo son diferentes. Un ejemplo simple sería:

Considere a una persona X.

Él es solo una persona, pero actúa como muchos. Puede preguntar cómo:

Él es un hijo para su madre. Un amigo para sus amigos. Un hermano para su hermana.

Polimorfismo en OOP significa que una clase podría tener diferentes tipos, la herencia es una forma de implementar el polimorfismo.

por ejemplo, Shape es una interfaz, tiene subtipos Square , Circle , Diamond . ahora que tiene un objeto Cuadrado, puede convertir Cuadrado en Forma automáticamente, porque Cuadrado es una Forma. Pero cuando intentas reducir Shape a Square, debes hacer una conversión de tipo explícita, porque no puedes decir que Shape es Square, también podría ser Circle. por lo que debe convertirlo manualmente con un código como Square s = (Square) shape , y si la forma es Circle, obtendrá java.lang.ClassCastException , porque Circle es no cuadrado.

Polimorfismo:

Ejecución diferente según la instancia de la clase, no el tipo de variable de referencia.

Una variable de referencia de tipo de interfaz puede hacer referencia a cualquiera de las instancias de clase que implementan esa interfaz.

El polimorfismo es la capacidad de usar un objeto en una clase dada, donde todos los componentes que componen el objeto son heredados por las subclases de la clase dada. Esto significa que una vez que una clase declara este objeto, todas las subclases debajo de él (y sus subclases, y así sucesivamente hasta llegar a la subclase más lejana / más baja) heredan el objeto y sus componentes (composición).

Recuerde que cada clase debe guardarse en archivos separados.

El siguiente código ejemplifica el polimorfismo:

La Superclase:

public class Parent {
    //Define things that all classes share
    String maidenName;
    String familyTree;

    //Give the top class a default method
    public void speak(){
         System.out.println("We are all Parents");
    }
}

El padre, una subclase:

public class Father extends Parent{
    //Can use maidenName and familyTree here
    String name="Joe";
    String called="dad";

    //Give the top class a default method
    public void speak(){
        System.out.println("I am "+name+", the father.");
    }
}

El niño, otra subclase:

public class Child extends Father {
    //Can use maidenName, familyTree, called and name here

    //Give the top class a default method
    public void speak(){
        System.out.println("Hi "+called+". What are we going to do today?");
    }
}

El método de ejecución hace referencia a la clase Parent para comenzar:

public class Parenting{
    public static void main(String[] args) {
        Parent parents = new Parent();
        Parent parent = new Father();
        Parent child = new Child();

        parents.speak();
        parent.speak();
        child.speak();
    }
}

Tenga en cuenta que cada clase debe declararse en archivos * .java separados. El código debe compilarse. También tenga en cuenta que puede usar continuamente maidenName y familyTree más abajo. Ese es el concepto de polimorfismo. El concepto de herencia también se explora aquí, donde se puede usar una clase o se define con más detalle mediante una subclase.

Espero que esto ayude y lo deje claro. Publicaré los resultados cuando encuentre una computadora que pueda usar para verificar el código. ¡Gracias por la paciencia!

El polimorfismo permite que la misma rutina (función, método) actúe sobre diferentes tipos.

Dado que muchas respuestas existentes combinan el subtipo con el polimorfismo, aquí hay tres formas (incluido el subtipo) para implementar el polimorfismo.

El polimorfismo paramétrico (genérico) permite que una rutina acepte uno o más parámetros de tipo, además de los parámetros normales, y se ejecuta en esos tipos.
Polimorfismo de subtipo permite que una rutina actúe sobre cualquier subtipo de sus parámetros.
Polimorfismo ad hoc generalmente usa sobrecarga de rutina para garantizar un comportamiento polimórfico, pero también puede referirse a otras implementaciones de polimorfismo.

Ver también:

http://wiki.c2.com/?CategoryPolymorphism

https://en.wikipedia.org/wiki/Polymorphism_(computer_science)

En lenguajes orientados a objetos, el polimorfismo permite el tratamiento y manejo de diferentes tipos de datos a través de la misma interfaz. Por ejemplo, considere la herencia en C ++: La clase B se deriva de la clase A. Se puede usar un puntero de tipo A * (puntero a la clase A) para manejar tanto un objeto de clase A como un objeto de clase B.

Polimorfismo en términos de codificación es cuando su objeto puede existir como múltiples tipos a través de herencia, etc. Si crea una clase llamada " Shape " que define el número de lados que tiene su objeto y luego puede crear una nueva clase que lo herede, como "Cuadrado". Cuando posteriormente realiza una instancia de " Square " luego puede lanzarlo hacia adelante y hacia atrás desde " Shape " a "Cuadrado" según sea necesario.

El polimorfismo le brinda la capacidad de crear un módulo que llama a otro y, sin embargo, tiene el punto de dependencia del tiempo de compilación contra el flujo de control en lugar de hacerlo con el flujo de control.

Al usar polimorfismo, un módulo de alto nivel no depende del módulo de bajo nivel. Ambos dependen de abstracciones. Esto nos ayuda a aplicar el principio de inversión de dependencia ( https://en.wikipedia.org/wiki/Dependency_inversion_principle ).

Aquí es donde encontré la definición anterior. Alrededor de 50 minutos en el video, el instructor explica lo anterior. https://www.youtube.com/watch?v=TMuno5RZNeE

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow