Полиморфизм по сравнению с переопределением по сравнению с перегрузкой

Полиморфизм касается способности языка рассматривать различный объект однородно при помощи сингла интерфейсы; как таковой это связано с переопределением, таким образом, интерфейс (или базовый класс) является полиморфным, конструктор является объектом, который переопределяет (две поверхности той же медали)

так или иначе, различие между двумя условиями лучше объяснено с помощью других языков, таких как C++: полиморфный объект в C++ ведет себя как дубликат Java, если основная функция является виртуальной, но если метод не является виртуальным, переход кода разрешен статически , и истинный тип, не проверенный во времени выполнения, таким образом, полиморфизм включает способность к объекту вести себя по-другому в зависимости от интерфейса, используемого для доступа к нему; позвольте мне сделать пример в псевдокоде:

class animal {
    public void makeRumor(){
        print("thump");
    }
}
class dog extends animal {
    public void makeRumor(){
        print("woff");
    }
}

animal a = new dog();
dog b = new dog();

a.makeRumor() -> prints thump
b.makeRumor() -> prints woff

(если makeRumor НЕ является виртуальным)

Java действительно не предлагает этот уровень полиморфизма (названный, также возражают разрезанию).

животное = новая собака (); собака b = новая собака ();

a.makeRumor() -> prints thump
b.makeRumor() -> prints woff

на обоих случаях это только распечатает woff.. с тех пор a и b относится к собаке класса

Термин перегрузка относится к наличию нескольких версий чего-то с тем же именем, обычно методы с различными списками параметров

public int DoSomething(int objectId) { ... }
public int DoSomething(string objectName) { ... }

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

, Переопределение обычно относится к полиморфизму, как Вы описали в своем вопросе

перегрузка состоит в том, когда Вы определяете 2 метода с тем же именем, но различные параметры

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

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

Однако, если кто-то дал мне простой ответ "переопределения" для вопроса, "Что такое полиморфизм?" Я попросил бы дальнейшее объяснение.

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

Классическим примером, Собаками и кошками являются животные, у животных есть метод makeNoise. Я могу выполнить итерации через массив животных, звоня makeNoise на них и ожидать, что они сделали бы там соответствующую реализацию.

код вызова не должен знать, каковы определенное животное они.

Thats, о чем я думаю как полиморфизм.

Специфически говорящая перегрузка или переопределение не дают полное изображение. Полиморфизм является просто способностью объекта специализировать его поведение на основе его типа.

я не согласился бы с некоторыми ответами здесь в той перегрузке, форма полиморфизма (параметрический полиморфизм) в случае, что метод с тем же именем может вести себя, по-другому дают различные типы параметра. Хорошим примером является перегрузка оператора. Можно определить "+", чтобы признать, что различные типы параметров - говорят, что строки или интервал - и на основе тех типов, "+" будут вести себя по-другому.

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

Вы корректны, что перегрузка не является ответом.

Ни один не является переопределяющим. Переопределение является средствами, которыми Вы получаете полиморфизм. Полиморфизм является способностью к объекту варьироваться поведение на основе его типа. Это лучше всего продемонстрировано, когда вызывающая сторона объекта, который показывает полиморфизм, не знает, каков определенный тип объект.

И переопределение и перегрузка используются для достижения полиморфизма.

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

    abstract class Beverage {
       boolean isAcceptableTemperature();
    }

    class Coffee extends Beverage {
       boolean isAcceptableTemperature() { 
           return temperature > 70;
       }
    }

    class Wine extends Beverage {
       boolean isAcceptableTemperature() { 
           return temperature < 10;
       }
    }

у Вас мог также быть метод, который является , перегрузился с двумя или больше наборами аргументов. Метод делает разные вещи на основе типа (типов) переданного аргумента (аргументов).

    class Server {
        public void pour (Coffee liquid) {
            new Cup().fillToTopWith(liquid);
        }

        public void pour (Wine liquid) {
            new WineGlass().fillHalfwayWith(liquid);
        }

        public void pour (Lemonade liquid, boolean ice) {
            Glass glass = new Glass();
            if (ice) {
                glass.fillToTopWith(new Ice());
            }
            glass.fillToTopWith(liquid);
        }
    }

Вот пример полиморфизма в pseudo-C#/Java:

class Animal
{
    abstract string MakeNoise ();
}

class Cat : Animal {
    string MakeNoise () {
        return "Meow";
    }
}

class Dog : Animal {
    string MakeNoise () {
        return "Bark";
    }
}

Main () {
   Animal animal = Zoo.GetAnimal ();
   Console.WriteLine (animal.MakeNoise ());
}

Основная функция не знает тип животного и зависит от поведения конкретной реализации MakeNoise () метод.

Редактирование: Похож на Brian, бьет меня к перфорации. Забавный мы использовали тот же пример. Но вышеупомянутый код должен помочь разъяснить понятия.

Полиморфизм является способностью экземпляра класса вести себя, как будто это был экземпляр другого класса в его дереве наследования, чаще всего один из его классов предка. Например, в Java все классы наследовались Объекту. Поэтому можно создать переменную текстового объекта и присвоить ему экземпляр любого класса.

переопределение является типом функции, которая происходит в классе, который наследовался другому классу. Функция переопределения "заменяет" функцию, наследованную от базового класса, но делает так таким способом, которым это называют, даже когда экземпляр его класса симулирует быть другим типом через полиморфизм. Что касается предыдущего примера, Вы могли определить свой собственный класс и переопределить toString () функция. Поскольку эта функция наследована от Объекта, это все еще будет доступно при копировании экземпляра этого класса в переменную Типа объекта. Обычно при вызове toString () на классе, в то время как это симулирует быть Объектом, версия toString, который будет на самом деле стрелять, является той, определенной на самом Объекте. Однако, потому что функция является переопределением, определение toString () от Вашего класса используется, даже когда истинный тип экземпляра класса скрыт позади полиморфизма.

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

Ни один:

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

Переопределение состоит в том, когда дочерний класс заменяет метод родителя одним собственным (это в iteself не составляет полиморфизм).

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

В Java Вы видите полиморфизм много с библиотекой наборов:

int countStuff(List stuff) {
  return stuff.size();
}

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

List myStuff = new MyTotallyAwesomeList();
int result = countStuff(myStuff);

, Если бы Вы перегружались, Вы имели бы:

int countStuff(LinkedList stuff) {...}
int countStuff(ArrayList stuff) {...}
int countStuff(MyTotallyAwesomeList stuff) {...}
etc...

и правильная версия countStuff () был бы выбран компилятором для соответствия параметрам.