java - para - hipervinculos en html ejemplos

Enlace estático y enlace dinámico

Question

Estoy realmente confundido sobre el enlace dinámico y el enlace estático. He leído que determinar el tipo de un objeto en tiempo de compilación se llama enlace estático y determinarlo en tiempo de ejecución se denomina enlace dinámico.

Qué sucede en el siguiente código:

¿Enlace estático o enlace dinámico?
¿Qué tipo de polimorfismo muestra esto?

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

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

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

Answer 1

Caso 1:

Animal a =new Animal();
a.eat();

Caso 2

Animal a=new Dog(); 
a.eat();

Aquí ambos son vinculantes dinámicos porque durante el tiempo de compilación se determina el tipo de objeto, pero en el tiempo de ejecución basado en la instancia, el objeto al que se le asigna el método de coma correspondiente se vinculará dinámicamente por la JVM.

En el primer caso, se llama el método de comer de la clase animal, mientras que en el segundo, se llama a la clase de perro como el objeto Animal se le asigna una instancia de Perro. La instancia de Perro es también una instancia de animal. Es decir, puede tomarlo como " es una " relación de que un perro es un animal. Por lo tanto, aquí el tipo de objeto se determina como perro en tiempo de ejecución y JVM vincula dinámicamente el método de comer de la clase de perro.

Verifique estos enlaces también

http://www.javatpoint.com/static-binding-and-dynamic-binding

http://www.coderanch.com/t/386124/java/java/Static-Binding-Dynamic-Binding

Answer 2

Esto realmente depende de la sobrecarga y anulación si hiciste algo como esto:

public class Animal{}


public class Dog extends Animal{}

public class AnimalActivity{

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

    public void eat(Dog d){
        System.out.println("Dog is eating");
    }
}

luego en la clase principal:

public static void main(String args[])
{
    Animal a=new Animal();
    Animal d=new Dog();
    AnimalActivity aa=new AnimalActivity();
    aa.eat(a);
    aa.eat(d);
}

el resultado en los dos casos será: el Animal is eating

pero vamos a darle un giro, vamos a tener esto:

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

entonces:

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

luego en la clase principal:

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

ahora el resultado debería ser:

Animal is eating
Dog is eating

esto se debe a que la sobrecarga se une en el tiempo de compilación "enlace estático" mientras que la anulación se une en el tiempo de ejecución "enlace dinámico"

Answer 3

Para las funciones no estáticas, utiliza el enlace estático siempre que la función no sea virtual, es decir, se le aplica la palabra clave final y / o la función es private . final implica que la función no se puede cambiar y la palabra clave private implica que solo tiene alcance de clase. De lo contrario, se utiliza el enlace dinámico.

Para las funciones estáticas, siempre se utiliza el enlace estático. Si se pasa un tipo A , ejecutará el método de A, independientemente de dónde se refieran A

Answer 4

Su código actual dará salida Animal is eating

Sin embargo, en tu clase principal, si creaste un objeto de tipo Dog y lo Animal a Animal , entonces tu salida será Dog is eating debido a la vinculación dinámica.

public static void main(String args[])
{
    Animal a = new Dog(); // An object of Dog is assigned to Animal
    a.eat(); // Dynamically determines which eat() method to call
}

Aunque a se declara como Animal , apunta a un objeto de tipo Dog . Entonces, en tiempo de ejecución, se determina el tipo de objeto y se llama al método eat() apropiado.

Una forma de pensarlo es method overloading está estáticamente vinculada y la method overriding está vinculada dinámicamente.

Answer 5

Su ejemplo es el enlace dinámico , porque en el tiempo de ejecución se determina qué tipo de a es y se invoca el método apropiado.

Ahora suponga que tiene los dos métodos siguientes también:

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

Incluso si cambia su main a

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

esto imprimirá Animal is eating , porque la llamada a callEat usa enlace estático , y el compilador solo sabe que a es de tipo Animal .

Answer 6

compruebe que esta clase de empleado tiene la función abstracta de earning() y cada clase tiene una implementación deferente toString()

Employee[] employees = new Employee[4];

// initialize array with Employees
employees[0] = new SalariedEmployee();
employees[1] = new HourlyEmployee();
employees[2] = new CommissionEmployee();
employees[3] = new BasePlusCommissionEmployee();
for (Employee currentEmployee : employees){
    System.out.println(currentEmployee); // invokes toString
    System.out.printf("earned $%,.2f%n", currentEmployee.earnings());
}

Todas las llamadas al método toString y las earnings se resuelven en el execution time , según el type of the object al que se refiere currentEmployee,

Este proceso se conoce como dynamic binding o late binding

referencia: Java ™ How to Program (Early Objects), décima edición