В чем разница между динамическим и статическим полиморфизмом в Java?

Может ли кто-нибудь представить простой пример, объясняющий разницу между Динамическим и Статическим полиморфизмом в Java?

Ответ 1

Полиморфизм

1. Статическая привязка/Связывание времени компиляции/раннее связывание/перегрузка метода (в том же классе)

2. Динамическое связывание/временная привязка/поздняя привязка/переопределение метода (в разных классах)

пример перегрузки:

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

пример переопределения:

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

Ответ 2

Перегрузка метода будет примером статического полиморфизма
тогда как переопределение будет примером динамического полиморфизма.

Потому что, в случае перегрузки, во время компиляции компилятор знает, какой метод ссылается на вызов. Тем не менее, он определяется во время выполнения для динамического полиморфизма

Ответ 3

Динамический (время выполнения) полиморфизм - это полиморфизм, существовавший во время выполнения. Здесь компилятор Java не понимает, какой метод вызывается во время компиляции. Только JVM решает, какой метод вызывается во время выполнения. Перегрузка метода и переопределение метода с использованием методов экземпляра являются примерами динамического полиморфизма.

Например,

Рассмотрим приложение, которое сериализует и де-сериализует разные типы документов.
Мы можем иметь "Документ как базовый класс и другой тип документа классы, вытекающие из него. Например. XMLDocument, WordDocument и т.д.
Класс документа будет определять "Сериализация() и" Де-сериализация() методы как виртуальные, и каждый производный класс будет реализовывать эти методы по-своему основаны на фактическом содержании документов.
Если необходимо использовать разные типы документов сериализованные/де-сериализованные, объекты документа будут "Ссылка на класс документа (или указатель)" и когда " Вызывается метод Serialize() или 'De-serialize(), вызывается соответствующие версии виртуальных методов.

Статический (компиляционный) полиморфизм - это полиморфизм, проявляющийся во время компиляции. Здесь компилятор Java знает, какой метод вызывается. Перегрузка метода и переопределение метода с использованием статических методов; метод переопределения с использованием частных или конечных методов является примером статического полиморфизма

Например,

Объект сотрудника может иметь два метода print(), которые не принимают аргументы, а один - строку префикса, отображаемую вместе с данные сотрудника.
Учитывая эти интерфейсы, когда метод print() вызывается без каких-либо аргументы, компилятор, глядя на аргументы функции, знает, какая функция предназначена для вызова, и генерирует объектный код соответственно.

Подробнее читайте в разделе "Что такое полиморфизм" (Google it).

Ответ 4

перегрузка метода является примером compile time/static polymorphism, потому что привязка метода между вызовом метода и определением метода происходит во время компиляции и зависит от ссылки класса (ссылка, созданная при компиляции время и переходит в стек).

метод переопределения является примером run time/dynamic polymorphism, потому что привязка метода между вызовом метода и определением метода происходит во время выполнения и зависит от объекта класса (объект, созданный во время выполнения и идет в кучу).

Ответ 5

Полиморфизм: Полиморфизм - это способность объекта принимать различные формы. Наиболее частое использование полиморфизма в ООП происходит, когда ссылка на родительский класс используется для ссылки на объект дочернего класса.

Динамический связывание/полиморфизм времени выполнения:

Время выполнения Полиморфизм также известен как метод переопределения. В этом механизме, с помощью которого вызов переопределенной функции разрешается во время выполнения.

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

Вывод:

Метод внутреннего запуска автомобиля

Статический связывание/полиморфизм времени компиляции:

Какой метод следует вызывать, определяется только во время компиляции.

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

}

Вывод: Внутри коллекции sort metho

Ответ 6

Проще говоря:

Статический полиморфизм: имя одного и того же метода перегружено с другим типом или числом параметров в одном классе (другая подпись). Вызов целевого метода разрешается во время компиляции.

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

Обычно перегрузка не будет рассматриваться как полиморфизм.

Из учебника java страница:

Подклассы класса могут определять свое собственное уникальное поведение и совместно использовать одни и те же функциональные возможности родительского класса

Ответ 7

Связывание относится к ссылке между вызовом метода и определением метода.

На этом рисунке ясно показано, что является обязательным.

На этом рисунке вызов a1.methodOne() является привязкой к соответствующему определению методаOne(), а вызов "a1.methodTwo()" привязан к соответствующему определению методаTwo().

Для каждого вызова метода должно быть правильное определение метода. Это правило в java. Если компилятор не видит правильного определения метода для каждого вызова метода, он выдает ошибку.

Теперь переходим к статической привязке и динамической привязке в java.

Статическая привязка в Java:

Статическое связывание является связыванием, которое происходит во время компиляции. это также называется ранним связыванием, потому что привязка происходит перед программой фактически работает

Статическое связывание может быть продемонстрировано, как показано на рисунке ниже.

На этом рисунке 'a1 является ссылочной переменной типа A, указывающей на объект класса A.' a2 также является ссылочной переменной типа A, но указывает на объект класса B.

Во время компиляции при связывании компилятор не проверяет тип объекта, к которому указывает конкретная ссылочная переменная. Он просто проверяет тип ссылочной переменной, через которую вызывается метод, и проверяет, существует ли в нем тип определения метода.

Например, для вызова метода "a1.method()" на приведенном выше рисунке компилятор проверяет, существует ли определение метода для метода() в классе A. Поскольку "a1" - это тип класса A. Аналогично, для вызова метода "a2.method()" он проверяет, существует ли определение метода для метода() в классе A. Поскольку "a2" также является классом типа A. Он не проверяет, к какому объекту, 'a1 и' a2 указывают. Этот тип привязки называется статическим привязкой.

Динамическое связывание в Java:

Динамическое связывание - это привязка, которая происходит во время выполнения. Это также называемый поздним связыванием, потому что привязка происходит, когда программа фактически является работает.

Во время выполнения фактические объекты используются для привязки. Например, для вызова "a1.method()" на приведенном выше рисунке будет вызван метод() фактического объекта, к которому будет называться "a1". Для вызова "a2.method()" метод call() фактического объекта, к которому будет называться "a2". Этот тип привязки называется динамическим связыванием.

Динамическое связывание вышеприведенного примера можно продемонстрировать, как показано ниже.

Ссылка static-binding-and-dynamic-binding-in-java

Ответ 8

Статический полиморфизм: - это решение для решения того, какой метод выполнить, определяется во время компиляции. Примером может служить перегрузка метода.

Динамический полиморфизм: - это решение о выборе того, какой метод выполнить, задается во время выполнения. Примером может служить метод переопределения.

Ответ 9

Перегрузка метода известна как Статический полиморфизм, а также известна как Полиморфизм времени компиляции или Статическая привязка), поскольку перегружена вызовы методов решаются во время компиляции компилятором на основе списка аргументов и ссылки, на которую мы вызываем метод.

И Переопределение метода известно как Динамический полиморфизм или простой Полиморфизм или Отправка метода времени выполнения или Dynamic Binding, поскольку переопределенный вызов метода разрешается во время выполнения.

Чтобы понять, почему это так, давайте возьмем пример Mammal и Human class

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

}

Я включил вывод, а также байт-код в следующих строках кода

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

И, посмотрев выше код, мы видим, что байткоды humanMammal.speak(), human.speak() и human.speak( "хинди" ) совершенно разные, потому что компилятор способен различать их на основе список аргументов и ссылку на класс. И вот почему Перегрузка метода известна как Статический полиморфизм.

Но байт-код для anyMammal.speak() и humanMammal.speak() аналогичен тому, что в соответствии с компилятором оба метода вызывается в ссылке Mammal, но вывод для обоих вызовов метода отличается от того, что во время выполнения JVM знает, к какому объекту относится ссылка и JVM вызывает метод объекта, и поэтому метод Overriding известен как динамический полиморфизм.

Итак, из вышеприведенного кода и байт-кода ясно, что во время компиляции фазовый метод вызова рассматривается из ссылочного типа. Но во время выполнения метод будет вызываться из объекта, который удерживает ссылку.

Если вы хотите узнать больше об этом, вы можете узнать больше о Как перегружать и переопределять метод обработки JVM внутри страны.

Ответ 10

Перегрузка метода - это полиморфизм времени компиляции, давайте возьмем пример, чтобы понять концепцию.

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
  {

  }

}

В этом примере у Человека есть метод еды, который означает, что он может либо есть пиццу, либо лапшу. То, что метод есть, перегружается, когда мы скомпилируем этот Person.java, компилятор разрешает вызов метода "e.eat(лапша) [который находится в строке 6] с определением метода, указанным в строке 8, который является методом, который берет лапшу в качестве параметра и весь процесс выполняется компилятором, так что это полиморфизм времени компиляции. Процесс замены вызова метода с помощью определения метода называется связыванием, в этом случае он выполняется компилятором, поэтому его называют ранним связыванием.