Static vs. Dynamiczne wiązanie w Javie

Obecnie wykonuję zadanie dla jednej z moich klas i muszę w nim podać przykłady, używając składni Javy, statycznego i dynamicznego wiązania .

Rozumiem podstawową koncepcję, że statyczne wiązanie ma miejsce w czasie kompilacji, a dynamiczne wiązanie ma miejsce w czasie wykonywania, ale nie mogę dowiedzieć się, jak właściwie działają.

Znalazłem przykład statycznego wiązania online, który daje ten przykład:

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

I że to wypisze „zwierzę je”, ponieważ wywołanie callEatużywa statycznego wiązania , ale nie jestem pewien, dlaczego jest to uważane za statyczne wiązanie.

Jak dotąd żadnemu ze źródeł, które widziałem, nie udało się wyjaśnić tego w sposób, który mogę śledzić.

Z wpisu na blogu Javarevisited :

Oto kilka ważnych różnic między wiązaniem statycznym i dynamicznym:

1. Statyczne powiązanie w Javie występuje w czasie kompilacji, podczas gdy dynamiczne wiązanie występuje w czasie wykonywania.
2. private, finala staticmetody i zmienne używają statycznego wiązania i są łączone przez kompilator, podczas gdy metody wirtualne są łączone w czasie wykonywania na podstawie obiektu środowiska wykonawczego.
3. Wiązanie statyczne używa Type( classw języku Java) informacji do wiązania, podczas gdy wiązanie dynamiczne używa obiektu do rozwiązywania powiązania.
4. Przeciążone metody są łączone przy użyciu powiązania statycznego, podczas gdy metody zastępowane są łączone przy użyciu dynamicznego wiązania w czasie wykonywania.

Oto przykład, który pomoże ci zrozumieć zarówno statyczne, jak i dynamiczne wiązanie w Javie.

Przykład statycznego wiązania w Javie

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

Dane wyjściowe : metoda sortowania kolekcji wewnątrz

Przykład dynamicznego wiązania w Javie

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

Dane wyjściowe: metoda rozruchu wewnętrznego samochodu

Łączenie wywołania metody z treścią metody jest nazywane Binding. Jak powiedział Maulik, „Wiązanie statyczne wykorzystuje informacje o typie (klasa w Javie) do wiązania, podczas gdy wiązanie dynamiczne wykorzystuje obiekt do rozwiązywania powiązań”. Więc ten kod:

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

Daje wynik: pies je ... ponieważ używa odniesienia do obiektu, aby znaleźć metodę do zastosowania. Jeśli zmienimy powyższy kod na ten:

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

Wytworzy: zwierzę je ... ponieważ jest to metoda statyczna, więc używa Type (w tym przypadku Animal) do rozstrzygnięcia, którą metodę statyczną należy wywołać. Oprócz metod statycznych metody prywatne i ostateczne wykorzystują to samo podejście.

Kompilator wie tylko, że typ „a” to Animal; dzieje się to w czasie kompilacji, przez co nazywa się to wiązaniem statycznym (przeciążenie metod). Ale jeśli jest to wiązanie dynamiczne, wywoła Dogmetodę klasy. Oto przykład dynamicznego wiązania.

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

Wyjście: Wewnątrz metoda jedzenia psa

Cóż, aby zrozumieć, jak statyczne i dynamiczne wiązanie faktycznie działa ? lub jak są identyfikowane przez kompilator i JVM?

Weźmy poniższy przykład, gdzie Mammaljest klasą nadrzędną, która ma metodę speak()i Humanklasę rozszerza Mammal, zastępuje speak()metodę, a następnie ponownie ją przeciąża speak(String language).

public class OverridingInternalExample {

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

    private static class Human extends Mammal {

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

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

        @Override
        public String toString() { return "Human Class"; }

    }

    //  Code below contains the output and bytecode of the method calls
    public static void main(String[] args) {
        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
    }
}

Kiedy kompilujemy powyższy kod i próbujemy spojrzeć na kod bajtowy za pomocą javap -verbose OverridingInternalExample, widzimy, że kompilator generuje stałą tabelę, w której przypisuje kody całkowite do każdego wywołania metody i kodu bajtowego dla programu, który wyodrębniłem i włączyłem do samego programu ( zobacz komentarze poniżej każdego wywołania metody)

Patrząc na powyższym kodzie widzimy, że bytecodes o humanMammal.speak(), human.speak()i human.speak("Hindi")są zupełnie różne ( invokevirtual #4, invokevirtual #7, invokevirtual #9) ponieważ kompilator jest w stanie rozróżniać między nimi na podstawie listy argumentów i odniesienie klasy. Ponieważ wszystko to jest rozwiązywane statycznie w czasie kompilacji, dlatego przeciążanie metod jest znane jako statyczny polimorfizm lub statyczne wiązanie .

Ale kod bajtowy dla anyMammal.speak()i humanMammal.speak()jest taki sam ( invokevirtual #4), ponieważ zgodnie z kompilatorem obie metody są wywoływane w Mammalodwołaniu.

Więc teraz pojawia się pytanie, czy oba wywołania metod mają ten sam kod bajtowy, to skąd JVM wie, którą metodę wywołać?

Cóż, odpowiedź jest ukryta w samym kodzie bajtowym i jest to invokevirtualzestaw instrukcji. JVM używainvokevirtual instrukcji do wywołania Java odpowiednika metod wirtualnych C ++. W C ++, jeśli chcemy przesłonić jedną metodę w innej klasie, musimy zadeklarować ją jako wirtualną, ale w Javie wszystkie metody są domyślnie wirtualne, ponieważ możemy przesłonić każdą metodę w klasie potomnej (z wyjątkiem metod prywatnych, końcowych i statycznych).

W Javie każda zmienna referencyjna zawiera dwa ukryte wskaźniki

1. Wskaźnik do tabeli, która ponownie zawiera metody obiektu i wskaźnik do obiektu Class. np. [speak (), speak (String) Class object]
2. Wskaźnik do pamięci przydzielonej na stercie dla danych tego obiektu, np. Wartości zmiennych instancji.

Zatem wszystkie odwołania do obiektu pośrednio przechowują odwołanie do tabeli, która zawiera wszystkie odwołania do metod tego obiektu. Java zapożyczyła tę koncepcję z C ++ i ta tabela jest znana jako tabela wirtualna (vtable).

Tabela vtable jest strukturą przypominającą tablicę, która przechowuje nazwy metod wirtualnych i ich odniesienia w indeksach tablic. JVM tworzy tylko jedną tabelę vtable na klasę, kiedy ładuje klasę do pamięci.

Więc za każdym razem, gdy JVM napotyka invokevirtualzestaw instrukcji, sprawdza tabelę vtable tej klasy pod kątem odwołania do metody i wywołuje określoną metodę, która w naszym przypadku jest metodą z obiektu, a nie z odwołania.

Ponieważ wszystko to jest rozwiązywane tylko w czasie wykonywania i podczas wykonywania, JVM dowiaduje się, którą metodę wywołać, dlatego przesłanianie metody jest znane jako dynamiczny polimorfizm lub po prostu polimorfizm lub dynamiczne wiązanie .

Możesz przeczytać więcej szczegółów w moim artykule Jak JVM obsługuje wewnętrzne przeciążanie i zastępowanie metod .

Istnieją trzy główne różnice między wiązaniem statycznym i dynamicznym podczas projektowania kompilatorów oraz sposobu przenoszenia zmiennych i procedur do środowiska uruchomieniowego środowiska . Te różnice są następujące:

Wiązanie statyczne : W wiązaniu statycznym omówiono trzy następujące problemy:

• Definicja procedury

• Deklaracja nazwy (zmienna itp.)

• Zakres deklaracji

Dynamiczne wiązanie : trzy problemy, które występują w dynamicznym wiązaniu, są następujące:

• Aktywacja procedury

• Wiązanie nazwiska

• Żywotność oprawy

Z metodą statyczną w klasie nadrzędnej i podrzędnej: Static Binding

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

Dynamiczne wiązanie:

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

Wszystkie odpowiedzi są poprawne, ale chcę dodać coś, czego brakuje. kiedy zastępujesz metodę statyczną, wygląda na to, że ją zastępujemy, ale w rzeczywistości nie jest to przesłanianie metody. Zamiast tego nazywa się to ukrywaniem metody. W Javie nie można przesłonić metod statycznych .

Spójrz na poniższy przykład:

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

W dynamicznym wiązaniu metoda jest wywoływana w zależności od typu odwołania, a nie od typu obiektu, który przechowuje zmienna referencyjna. Tutaj statyczne wiązanie ma miejsce, ponieważ ukrywanie metody nie jest dynamicznym polimorfizmem. Jeśli usuniesz statyczne słowo kluczowe przed eat () i sprawisz, że będzie to metoda niestatyczna, to pokaże ci dynamiczny polimorfizm, a nie ukrywanie metod.

Znalazłem poniższy link, aby wesprzeć moją odpowiedź: https://youtu.be/tNgZpn7AeP0

W przypadku statycznego wiązania typu obiektu określanego w czasie kompilacji, podczas gdy w dynamicznym wiązaniu typ obiektu jest określany w czasie wykonywania.

class Dainamic{

    void run2(){
        System.out.println("dainamic_binding");
    }

}


public class StaticDainamicBinding extends Dainamic {

    void run(){
        System.out.println("static_binding");
    }

    @Override
    void run2() {
        super.run2();
    }

    public static void main(String[] args) {
        StaticDainamicBinding st_vs_dai = new StaticDainamicBinding();
        st_vs_dai.run();
        st_vs_dai.run2();
    }

}

Ponieważ kompilator zna powiązanie w czasie kompilacji. Jeśli na przykład wywołasz metodę w interfejsie, kompilator nie będzie mógł tego wiedzieć, a powiązanie zostanie rozwiązane w czasie wykonywania, ponieważ rzeczywisty obiekt, na którym została wywołana metoda, może być jednym z kilku. Dlatego jest to środowisko wykonawcze lub dynamiczne wiązanie.

Twoje wywołanie jest powiązane z klasą Animal w czasie kompilacji, ponieważ określono typ. Gdybyś przekazał tę zmienną do innej metody w innym miejscu, nikt nie wiedziałby (poza tobą, ponieważ ją napisałeś), jaka to byłaby klasa. Jedyną wskazówką jest zadeklarowany typ zwierzęcia.