poo - polimorfismo java ejemplo

¿Cuál es la diferencia entre polimorfismo dinámico y estático en Java?

Question

¿Alguien puede proporcionar un ejemplo simple que explique la diferencia entre el polimorfismo dinámico y el estático en Java?

Answer 1

La vinculación se refiere al enlace entre la llamada al método y la definición del método.

Esta imagen muestra claramente lo que es vinculante.

En esta imagen, la llamada "a1.methodOne ()" es vinculante para la correspondiente definición de methodOne () y la llamada "a1.methodTwo ()" es vinculante para la correspondiente definición de methodTwo ().

Para cada llamada de método, debe haber una definición de método adecuada. Esta es una regla en Java. Si el compilador no ve la definición de método adecuada para cada llamada de método, arroja un error.

Ahora, ven al enlace estático y enlace dinámico en java.

Enlace estático en Java:

La vinculación estática es una vinculación que ocurre durante la compilación. También se llama enlace anticipado porque la vinculación ocurre antes de que un programa realmente se ejecute

.

La unión estática se puede demostrar como en la imagen de abajo.

En esta imagen, ''a1'' es una variable de referencia de tipo Clase A que apunta al objeto de clase A. ''a2'' también es una variable de referencia de tipo clase A pero apunta al objeto de Clase B.

Durante la compilación, mientras se vincula, el compilador no verifica el tipo de objeto al que apunta una variable de referencia particular. Simplemente verifica el tipo de variable de referencia a través de la cual se llama un método y verifica si existe una definición de método para ese tipo.

Por ejemplo, para la llamada al método "a1.method ()" en la imagen de arriba, el compilador verifica si existe una definición de método para el método () en la Clase A. Porque ''a1'' es del tipo Clase A. De manera similar, para la llamada al método "a2.method ()", verifica si existe una definición de método para el método () en la Clase A. Porque ''a2'' también es del tipo Clase A. No verifica a qué objeto apuntan ''a1'' y ''a2''. Este tipo de enlace se denomina enlace estático.

Encuadernación dinámica en Java:

La vinculación dinámica es una vinculación que ocurre durante el tiempo de ejecución. También se llama enlace tardío porque el enlace ocurre cuando el programa realmente se está ejecutando.

Durante el tiempo de ejecución, los objetos reales se usan para vincular. Por ejemplo, para la llamada "a1.method ()" en la imagen de arriba, se invocará el método () del objeto real al que apunta ''a1''. Para la llamada "a2.method ()", se invocará el método () del objeto real al que apunta ''a2''. Este tipo de enlace se llama enlace dinámico.

La vinculación dinámica del ejemplo anterior se puede demostrar como a continuación.

Referencia static-binding-and-dynamic-binding-in-java

Answer 2

El polimorfismo se refiere a la capacidad de un objeto para comportarse de manera diferente para el mismo desencadenador.

Polimorfismo estático (Polimorfismo en tiempo de compilación)

• El polimorfismo estático decide qué método ejecutar durante el tiempo de compilación.
• Método La sobrecarga es un ejemplo de polimorfismo estático, y es necesario que ocurra el polimorfismo estático.
• Polimorfismo estático logrado a través de enlace estático.
• El polimorfismo estático ocurre en la misma clase.
• La asignación de objetos no es necesaria para el polimorfismo estático.
• Herencia no involucrada para el polimorfismo estático.

Polimorfismo dinámico (polimorfismo en tiempo de ejecución)

• El polimorfismo dinámico decide qué método ejecutar en tiempo de ejecución.
• Método Overriding es un ejemplo de polimorfismo dinámico, y es necesario que ocurra polimorfismo dinámico.
• Polimorfismo dinámico logrado a través de enlace dinámico.
• El polimorfismo dinámico ocurre entre diferentes clases.
• Se requiere cuando se asigna un objeto de subclase al objeto de superclase para el polimorfismo dinámico.
• Herencia involucrada para el polimorfismo dinámico.

Answer 3

La sobrecarga de métodos es un polimorfismo en tiempo de compilación, tomemos un ejemplo para comprender el concepto.

class Person                                            //person.java file
{
    public static void main ( String[] args )
    {
      Eat e = new Eat();
       e.eat(noodle);                                //line 6
    }

   void eat (Noodles n)      //Noodles is a object    line 8                     
   {

   }
   void eat ( Pizza p)           //Pizza is a object
  {

  }

}

En este ejemplo, la persona tiene un método de comer que representa que puede comer pizza o fideos. Que el método eat está sobrecargado cuando compilamos esta Person.java el compilador resuelve el método llamado "e.eat (fideos) [que está en la línea 6] con la definición de método especificada en la línea 8 que es el método que toma fideos como parámetro y todo el proceso lo realiza el compilador, por lo que es Polimorfismo de tiempo de compilación. El proceso de reemplazo de la llamada a método con definición de método se denomina enlace, en este caso, lo realiza el compilador, por lo que se denomina enlace anticipado.

Answer 4

Polymorphism: polimorfismo es la capacidad de un objeto para tomar muchas formas. El uso más común de polimorfismo en OOP ocurre cuando se usa una referencia de clase principal para referirse a un objeto de clase hijo.

Polimorfismo dinámico de unión / tiempo de ejecución:

Polimorfismo de tiempo de ejecución también conocido como anulación de método. En este Mecanismo por el cual una llamada a una función anulada se resuelve en un tiempo de ejecución.

public class DynamicBindingTest {

    public static void main(String args[]) {
        Vehicle vehicle = new Car(); //here Type is vehicle but object will be Car
        vehicle.start();       //Car''s start called because start() is overridden method
    }
}

class Vehicle {

    public void start() {
        System.out.println("Inside start method of Vehicle");
    }
}

class Car extends Vehicle {

    @Override
    public void start() {
        System.out.println("Inside start method of Car");
    }
}

Salida:

Método de inicio de arranque del coche

Polimorfismo estático de unión / tiempo de compilación:

El método que se debe invocar se decide únicamente en tiempo de compilación.

public class StaticBindingTest {

    public static void main(String args[])  {
       Collection c = new HashSet();
       StaticBindingTest et = new StaticBindingTest();
       et.sort(c);

    }

    //overloaded method takes Collection argument
    public Collection sort(Collection c){
        System.out.println("Inside Collection sort method");
        return c;
    }


   //another overloaded method which takes HashSet argument which is sub class
    public Collection sort(HashSet hs){
        System.out.println("Inside HashSet sort method");
        return hs;
    }

}

Salida: Inside Collection sort meto

Answer 5

En lenguaje sencillo :

Polimorfismo estático : el mismo nombre del método está sobrecargado con diferentes tipos o números de parámetros en la misma clase (firma diferente). La llamada al método dirigido se resuelve en tiempo de compilación.

Polimorfismo dinámico : el mismo método se anula con la misma firma en diferentes clases . El tipo de objeto en el que se invoca el método no se conoce en tiempo de compilación, pero se decidirá en tiempo de ejecución.

En general, la sobrecarga no se considerará como polimorfismo.

Desde la page tutorial de Java:

Las subclases de una clase pueden definir sus propios comportamientos únicos y aun así compartir algunas de las mismas funcionalidades de la clase padre

Answer 6

Polimorfismo

1. Enlace estático / enlace de tiempo de compilación / enlace anticipado / sobrecarga de método (en la misma clase)

2. Encuadernación dinámica / Encuadernación en tiempo de ejecución / Encuadernación tardía / Anulación de método (en diferentes clases)

ejemplo de sobrecarga:

class Calculation {  
  void sum(int a,int b){System.out.println(a+b);}  
  void sum(int a,int b,int c){System.out.println(a+b+c);}  

  public static void main(String args[]) {  
    Calculation obj=new Calculation();  
    obj.sum(10,10,10);  // 30
    obj.sum(20,20);     //40 
  }  
}  

ejemplo primordial:

class Animal {    
   public void move(){
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {

   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal(); // Animal reference and object
      Animal b = new Dog(); // Animal reference but Dog object

      a.move();//output: Animals can move

      b.move();//output:Dogs can walk and run
   }
}

Answer 7

El polimorfismo dinámico (tiempo de ejecución) es el polimorfismo existente en el tiempo de ejecución. Aquí, el compilador de Java no entiende qué método se llama en el tiempo de compilación. Solo JVM decide qué método se llama en tiempo de ejecución. La sobrecarga de métodos y la anulación de métodos utilizando métodos de instancia son ejemplos de polimorfismo dinámico.

Por ejemplo,

• Considere una aplicación que serializa y deserializa diferentes tipos de documentos.

• Podemos tener ''Documento'' como la clase base y las diferentes clases de tipos de documentos que se derivan de él. Por ejemplo, XMLDocument, WordDocument, etc.

• La clase de documento definirá los métodos ''Serialize ()'' y ''De-serialize ()'' como virtuales y cada clase derivada implementará estos métodos a su manera en función del contenido real de los documentos.

• Cuando los diferentes tipos de documentos necesitan ser serializados / deserializados, los objetos del documento serán referidos por la referencia (o puntero) de la clase ''Documento'' y cuando se llaman los métodos ''Serialize ()'' o ''De-serialize ()'' en él, se llaman versiones apropiadas de los métodos virtuales.

El polimorfismo estático (tiempo de compilación) es el polimorfismo exhibido en tiempo de compilación. Aquí, el compilador de Java sabe a qué método se llama. Sobrecarga de métodos y anulación de métodos con métodos estáticos; método de anulación utilizando métodos privados o finales son ejemplos de polimorfismo estático

Por ejemplo,

• Un objeto empleado puede tener dos métodos print () uno que no toma argumentos y otro que toma una cadena de prefijo que se mostrará junto con los datos del empleado.

• Dadas estas interfaces, cuando se llama al método print () sin ningún argumento, el compilador, mirando los argumentos de la función, sabe qué función se debe invocar y genera el código del objeto en consecuencia.

Para obtener más información, lea "Qué es el polimorfismo" (Google it).

Answer 8

La sobrecarga de métodos es un ejemplo de compile time de compile time / static polymorphism porque el enlace de métodos entre la llamada al método y la definición del método ocurre en tiempo de compilación y depende de la referencia de la clase (referencia creada en tiempo de compilación y va a la pila).

la anulación de método es un ejemplo de dynamic polymorphism run time de run time / dynamic polymorphism porque el enlace de método entre llamada de método y definición de método ocurre en tiempo de ejecución y depende del objeto de la clase (objeto creado en tiempo de ejecución y va al montón).

Answer 9

La sobrecarga de métodos se conoce como polimorfismo estático y también conocida como polimorfismo de tiempo de compilación o enlace estático porque el compilador resuelve las llamadas a los métodos sobrecargadas en tiempo de compilación sobre la base de la lista de argumentos y la referencia sobre la que estamos llamando al método.

Y la anulación de método se conoce como polimorfismo dinámico o polimorfismo simple o despacho de método de tiempo de ejecución o enlace dinámico porque la llamada al método anulado se resuelve en el tiempo de ejecución.

Para entender por qué esto es así, tomemos un ejemplo de Mammal y Clase Human

class Mammal {
    public void speak() { System.out.println("ohlllalalalalalaoaoaoa"); }
}

class Human extends Mammal {

    @Override
    public void speak() { System.out.println("Hello"); }

    public void speak(String language) {
        if (language.equals("Hindi")) System.out.println("Namaste");
        else System.out.println("Hello");
    }

}

He incluido la salida y el bytecode de las líneas de código a continuación

Mammal anyMammal = new Mammal();
anyMammal.speak();  // Output - ohlllalalalalalaoaoaoa
// 10: invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V

Mammal humanMammal = new Human();
humanMammal.speak(); // Output - Hello
// 23: invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V

Human human = new Human();
human.speak(); // Output - Hello
// 36: invokevirtual #7 // Method org/programming/mitra/exercises/OverridingInternalExample$Human.speak:()V

human.speak("Hindi"); // Output - Namaste
// 42: invokevirtual #9 // Method org/programming/mitra/exercises/OverridingInternalExample$Human.speak:(Ljava/lang/String;)V

Y mirando el código anterior, podemos ver que los códigos de byte de HumanMammal.speak (), human.speak () y human.speak ("Hindi") son totalmente diferentes porque el compilador puede diferenciarlos según la lista de argumentos y referencia de clase. Y esta es la razón por la cual la sobrecarga de métodos se conoce como polimorfismo estático .

Pero bytecode para anyMammal.speak () y humanMammal.speak () es lo mismo porque de acuerdo con el compilador se invocan ambos métodos en la referencia Mammal pero la salida para ambas llamadas a métodos es diferente porque en tiempo de ejecución JVM sabe qué objeto está reteniendo una referencia y las llamadas JVM el método en el objeto y esta es la razón por la cual el método Overriding se conoce como Polimorfismo Dinámico.

Por lo tanto, desde el código y el código de bytes anteriores, está claro que durante la fase de compilación, el método de llamada se considera a partir del tipo de referencia. Pero en el momento de la ejecución se llamará al método desde el objeto que contiene la referencia.

Si desea saber más acerca de esto, puede leer más sobre cómo JVM maneja sobrecarga y sobreescritura del método internamente .

Answer 10

Polimorfismo estático: es donde la decisión de resolver qué método lograr se determina durante el tiempo de compilación. Método de sobrecarga podría ser un ejemplo de esto.

Polimorfismo dinámico: es donde la decisión de elegir qué método ejecutar se establece durante el tiempo de ejecución. Método Overriding podría ser un ejemplo de esto.

Answer 11

Tiempo de compilación del polimorfismo (enlace estático / vinculación temprana): en el polimorfismo estático, si llamamos a un método en nuestro código, entonces, la definición de ese método que se va a llamar en realidad se resuelve solo en tiempo de compilación.

(o)

En tiempo de compilación, Java sabe qué método invocar comprobando las firmas de método. Por lo tanto, esto se llama polimorfismo en tiempo de compilación o enlace estático.

Polimorfismo dinámico (enlace tardío / polimorfismo de tiempo de ejecución): en tiempo de ejecución, Java espera hasta el tiempo de ejecución para determinar a qué objeto apunta realmente la referencia. La resolución del método se tomó en tiempo de ejecución, debido a que llamamos polimorfismo de tiempo de ejecución.

Answer 12

• La sobrecarga del método sería un ejemplo de polimorfismo estático

• mientras que anular sería un ejemplo de polimorfismo dinámico.

  Porque, en caso de sobrecarga, en tiempo de compilación el compilador sabe qué método vincular a la llamada. Sin embargo, se determina en tiempo de ejecución para el polimorfismo dinámico