java - create - j2html

Static vs. Enlace dinámico en Java

Question

Actualmente estoy haciendo una tarea para una de mis clases, y en ella, tengo que dar ejemplos, utilizando la sintaxis de Java, de enlace estático y dinámico .

Entiendo el concepto básico, que la vinculación estática ocurre en el momento de la compilación y la vinculación dinámica ocurre en el tiempo de ejecución, pero no puedo entender cómo funcionan específicamente.

Encontré un ejemplo de enlace estático en línea que da este ejemplo:

public static void callEat(Animal animal) {
    System.out.println("Animal is eating");
}

public static void callEat(Dog dog) {
    System.out.println("Dog is eating");
}

public static void main(String args[])
{
    Animal a = new Dog();
    callEat(a);
}

Y que esto imprimirá "el animal está comiendo" porque la llamada a callEat usa enlace estático , pero no estoy seguro de por qué esto se considera enlace estático.

Hasta el momento, ninguna de las fuentes que he visto ha logrado explicar esto de una manera que pueda seguir.

Answer 1

Con el método estático en la clase primaria y secundaria: Enlace estático

public class test1 {   
    public static void main(String args[]) {
        parent pc = new child(); 
        pc.start(); 
    }
}

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

class child extends parent {

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

// Output => Inside start method of parent

Enlace dinámico:

public class test1 {   
    public static void main(String args[]) {
        parent pc = new child();
        pc.start(); 
    }
}

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

class child extends parent {

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

// Output => Inside start method of child

Answer 2

Conectar una llamada de método al cuerpo del método se conoce como Enlace. Como dijo Maulik, "el enlace estático usa información de Tipo (Clase en Java) para el enlace, mientras que el enlace Dinámico usa el Objeto para resolver el enlace". Entonces este código:

public class Animal {
    void eat() {
        System.out.println("animal is eating...");
    }
}

class Dog extends Animal {

    public static void main(String args[]) {
        Animal a = new Dog();
        a.eat(); // prints >> dog is eating...
    }

    @Override
    void eat() {
        System.out.println("dog is eating...");
    }
}

Producirá el resultado: el perro está comiendo ... porque está utilizando la referencia del objeto para encontrar qué método usar. Si cambiamos el código anterior a esto:

class Animal {
    static void eat() {
        System.out.println("animal is eating...");
    }
}

class Dog extends Animal {

    public static void main(String args[]) {

        Animal a = new Dog();
        a.eat(); // prints >> animal is eating...

    }

    static void eat() {
        System.out.println("dog is eating...");
    }
}

Producirá: el animal está comiendo ... porque es un método estático, por lo que está utilizando Tipo (en este caso Animal) para resolver qué método estático llamar. Además de los métodos estáticos, los métodos privados y finales usan el mismo enfoque.

Answer 3

Desde la publicación de blog de Javarevisited :

Aquí hay algunas diferencias importantes entre la vinculación estática y dinámica:

1. La vinculación estática en Java se produce durante el tiempo de compilación, mientras que la vinculación dinámica se produce durante el tiempo de ejecución.
2. private métodos y variables private , final y static usan enlace estático y están unidos por el compilador mientras que los métodos virtuales están vinculados durante el tiempo de ejecución en función del objeto de tiempo de ejecución.
3. El enlace estático usa información de Type ( class en Java) para el enlace, mientras que el enlace dinámico usa el objeto para resolver el enlace.
4. Los métodos sobrecargados se vinculan usando enlaces estáticos mientras que los métodos reemplazados se enlazan mediante enlaces dinámicos en tiempo de ejecución.

Aquí hay un ejemplo que lo ayudará a comprender tanto el enlace estático como el dinámico en Java.

Ejemplo de enlace estático en Java

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 : método de clasificación Inside Collection

Ejemplo de enlace dinámico en Java

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

Answer 4

El compilador solo sabe que el tipo de "a" es Animal ; esto sucede en el momento de la compilación, por lo que se denomina enlace estático (Sobrecarga de método). Pero si es vinculante dinámico, entonces llamaría al método de clase Dog . Aquí hay un ejemplo de enlace dinámico.

public class DynamicBindingTest {

    public static void main(String args[]) {
        Animal a= new Dog(); //here Type is Animal but object will be Dog
        a.eat();       //Dog''s eat called because eat() is overridden method
    }
}

class Animal {

    public void eat() {
        System.out.println("Inside eat method of Animal");
    }
}

class Dog extends Animal {

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

Salida: método de comer adentro de perro

Answer 5

Hay tres diferencias principales entre la vinculación estática y dinámica al diseñar los compiladores y cómo las variables y los procedimientos se transfieren al entorno de tiempo de ejecución . Estas diferencias son las siguientes:

Enlace estático : en enlace estático se tratan tres problemas siguientes:

• Definición de un procedimiento

• Declaración de un nombre (variable, etc.)

• Alcance de la declaración

Enlace dinámico : Tres problemas que se presentan en el enlace dinámico son los siguientes:

• Activación de un procedimiento

• Encuadernación de un nombre

• Tiempo de vida de un enlace

Answer 6

Porque el compilador conoce el enlace en tiempo de compilación. Si invoca un método en una interfaz, por ejemplo, entonces el compilador no puede saber y el enlace se resuelve en tiempo de ejecución porque el objeto real que tiene un método invocado podría ser uno de varios. Por lo tanto, eso es tiempo de ejecución o enlace dinámico.

Su invocación está vinculada a la clase Animal en el momento de la compilación porque ha especificado el tipo. Si pasas esa variable a otro método en otro lugar, nadie sabría (aparte de ti porque lo escribiste) qué clase real sería. La única pista es el tipo declarado de Animal.