Статическое связывание и динамическое связывание

Я действительно запутался в динамической привязке и статической привязке. Я читал, что определение типа объекта во время компиляции называется статической привязкой и определение его во время выполнения называется динамической привязкой.

Что происходит в коде ниже:

Статическое связывание или динамическое связывание?
Что это за полиморфизм?

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();
}

Ответ 1

Ваш пример - это динамическое связывание, потому что во время выполнения определяется тип типа a и вызывается соответствующий метод.

Теперь предположим, что у вас есть также следующие два метода:

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

Даже если вы измените свой main на

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

это напечатает Animal is eating, потому что вызов callEat использует статическое связывание, и компилятор знает только, что a имеет тип Animal.

Ответ 2

Это действительно зависит от перегрузки и переопределения, если вы сделали что-то вроде этого:

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");
    }
}

затем в основном классе:

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

результат в двух случаях будет: Animal is eating

но позволяет немного перекрутить его, давайте получим следующее:

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

то

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

затем в основном классе:

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

теперь результат должен быть:

Animal is eating
Dog is eating

это связано с тем, что перегрузка связывается во время компиляции "статическая привязка" в то время как переопределение привязок во время выполнения "динамическое связывание"

Ответ 3

Ваш текущий код будет выводиться Animal is eating

Однако в вашем основном классе, если вы создали объект типа Dog и присвоили его Animal, то ваш результат будет Dog is eating из-за динамической привязки.

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
}

Даже если a объявлен как Animal, он указывает на объект типа Dog. Таким образом, во время выполнения определяется тип объекта и вызывается соответствующий метод eat().

Один из способов думать, method overloading статически связан и method overriding динамически связан.

Ответ 4

Для нестатических функций вы используете статическое связывание всякий раз, когда функция не является виртуальной, т.е. к ней применяется ключевое слово final и/или функция private. final подразумевает, что функция не может быть изменена, а ключевое слово private подразумевает, что она имеет только класс. В противном случае используется динамическое связывание.

Для статических функций всегда используется статическая привязка. Если передается тип A, он будет запускать метод A, независимо от того, где A ссылки.

Ответ 5

Случай 1:

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

Случай 2:

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

Здесь оба являются динамическими связями, потому что во время компиляции определяется тип объекта, но во время выполнения на основе экземпляра объект, которому назначен соответствующий метод eat, будет динамически связываться с JVM.

В первом случае называется метод употребления класса животных, тогда как во втором классе собачьего еды называют, поскольку объекту Animal присваивается экземпляр собаки. Экземпляр собаки также является экземпляром животного. То есть вы можете считать, что отношение " является" собакой является животным. Таким образом, тип объекта определяется как собака во время выполнения, а JVM динамически связывает метод питания класса собаки.

Также проверьте ссылки.

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

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

Ответ 6

проверить это класс сотрудника имеет абстрактную функцию earning(), и каждый класс имеет отложенную реализацию 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());
}

Все вызовы метода toString и earnings разрешены в execution time на основе type of the object, к которому ссылается currentEmployee,

Этот процесс известен как dynamic binding или late binding

ссылка: Java ™ Как программировать (ранние объекты), десятое издание