Перегрузка и переопределение Java
Мы всегда говорим, что перегрузка метода - это статический полиморфизм, а переопределение - полиморфизм во время выполнения. Что именно мы подразумеваем под статичным здесь? Разрешен ли вызов метода при компиляции кода? Так в чем же разница между обычным вызовом метода и вызовом финального метода? Какой из них связан во время компиляции?
8 ответов
Перегрузка метода означает создание нескольких версий функции на основе входных данных. Например:
public Double doSomething(Double x) { ... }
public Object doSomething(Object y) { ... }
Выбор метода для вызова производится во время компиляции. Например:
Double obj1 = new Double();
doSomething(obj1); // calls the Double version
Object obj2 = new Object();
doSomething(obj2); // calls the Object version
Object obj3 = new Double();
doSomething(obj3); // calls the Object version because the compilers see the
// type as Object
// This makes more sense when you consider something like
public void myMethod(Object o) {
doSomething(o);
}
myMethod(new Double(5));
// inside the call to myMethod, it sees only that it has an Object
// it can't tell that it's a Double at compile time
Переопределение метода означает определение новой версии метода подклассом оригинала.
class Parent {
public void myMethod() { ... }
}
class Child extends Parent {
@Override
public void myMethod() { ... }
}
Parent p = new Parent();
p.myMethod(); // calls Parent's myMethod
Child c = new Child();
c.myMethod(); // calls Child's myMethod
Parent pc = new Child();
pc.myMethod(); // call's Child's myMethod because the type is checked at runtime
// rather than compile time
Надеюсь, это поможет
Вы правы - вызовы перегруженных методов осуществляются во время компиляции. Вот почему это статично.
Вызовы переопределенных методов реализуются во время выполнения в зависимости от типа, для которого вызывается метод.
На виртуальных методах википедия говорит:
В Java все нестатические методы по умолчанию являются "виртуальными функциями". Только методы, отмеченные ключевым словом final, не являются виртуальными.
final методы не могут быть переопределены, поэтому они реализуются статически.
Представьте себе метод:
public String analyze(Interface i) {
i.analyze();
return i.getAnalysisDetails();
}
Компилятор не может перегрузить этот метод для всех реализаций Interface это может быть передано ему.
1) Метод перегрузки используется для повышения читабельности программы. Переопределение метода используется для обеспечения конкретной реализации метода, которая уже предоставлена его суперклассом.
2) Перегрузка метода выполняется внутри класса. Переопределение метода происходит в двух классах, которые имеют отношение IS-A (наследование).
3) В случае перегрузки метода параметр должен быть другим. В случае переопределения метода параметр должен быть таким же.
4) Перегрузка метода - пример полиморфизма времени компиляции. Переопределение метода является примером полиморфизма во время выполнения.
5) В Java перегрузка метода не может быть выполнена путем изменения только типа возврата метода. Тип возврата может быть одинаковым или разным в перегрузке метода. Но вы должны изменить параметр. Тип возврата должен быть одинаковым или ковариантным в переопределении метода.
Я не думаю, что вы можете назвать перегрузку любого рода полиморфизмом. Перегруженные методы связаны во время компиляции, что исключает возможность называть это полиморфизмом.
Полиморфизм относится к динамическому связыванию метода с его вызовом, когда вы используете ссылку на базовый класс для объекта производного класса. Переопределение методов - это способ реализации этого полиморфного поведения.
Перегрузка метода просто означает предоставление двух отдельных методов в классе с одинаковым именем, но разными аргументами, в то время как тип возвращаемого значения метода может отличаться или не различаться, что позволяет нам повторно использовать одно и то же имя метода.
Но оба метода различны, поэтому могут быть решены компилятором во время компиляции, поэтому он также известен как полиморфизм времени компиляции или статический полиморфизм
Переопределение метода означает определение метода в дочернем классе, который уже определен в родительском классе с такой же сигнатурой метода, то есть с тем же именем, аргументами и типом возвращаемого значения.
Mammal mammal = new Cat();
System.out.println(mammal.speak());
На линии mammal.speak() компилятор говорит speak() метод ссылочного типа Mammal вызывается, поэтому для компилятора этот вызов Mammal.speak(),
Но во время выполнения JVM ясно знает, что mammal ссылка содержит ссылку на объект Catтак что для JVM этот вызов Cat.speak(),
Поскольку вызов метода разрешается во время выполнения JVM, поэтому он также известен как полиморфизм времени выполнения и динамическая диспетчеризация метода.
Разница между перегрузкой метода и переопределением метода
Для более подробной информации, вы можете прочитать все о перегрузке метода и переопределении метода.
Я согласен с Рэйчел, потому что в книге K&B прямо упоминается, что перегрузка не относится к полиморфизму в главе 2(ориентация на объект). Но во многих местах я обнаружил, что перегрузка означает статический полиморфизм, потому что это время компиляции, а переопределение означает динамический полиморфизм, потому что это время выполнения.
Но одна интересная вещь в книге C++ (Объектно-ориентированное программирование на C++ - Роберт Лафоре) также прямо упоминается, что перегрузка означает статический полиморфизм. Но есть еще одна вещь: есть java и C++, оба являются двумя разными языками программирования, и у них разные методы манипулирования объектами, поэтому может быть полиморфизм отличается в C++ и java?
Во-первых, я хочу обсудить динамический полиморфизм времени исполнения и компиляции / статический полиморфизм.
Время компиляции / статический полиморфизм:- как следует из названия, он связывает вызов функции с соответствующей функцией во время компиляции. Это означает, что компилятор точно знает, какой вызов функции связан с какой функцией. Перегрузка функций является примером полиморфизма времени компиляции.
Время выполнения / Динамический полиморфизм:-В этом типе полиморфизма компилятор не знает, какие функции ассоциирует вызов с какой функцией до запуска программы. Например. переопределение функции.
СЕЙЧАС, что такое переопределение функций и перегрузка функций???
Перегрузка функции:- то же имя функции, но другая сигнатура / параметр функции.
eg. Area(no. of parameter)
{ -------------
----------------
return area;}
area of square requires only one parameter
area of rectangle requires two parameters(Length and breadth)
Переопределение функции:- изменить работу функции, которая присутствует в классе Superclass и Child. например. name() в суперклассе печатает "привет Рахул", но после переопределения в дочернем классе выводит "привет Акшит"
Перегрузка собственности Переопределение
Имена методов --------------> должны быть одинаковыми ---------------- должны быть одинаковыми
Arg Types------------------> должен быть другим (хотя бы arg)
Подпись метода
Тип возврата
Частный,Static,Final
Модификатор доступа
попробуй поймать
Разрешение метода
Простое определение. Перегрузка методов связана с понятием наличия двух или более методов (функций) в одном классе с одним и тем же именем, но разными аргументами.
Переопределение метода означает наличие двух методов с одинаковыми аргументами, но разной реализацией. Один из них будет существовать в родительском классе (базовый класс), а другой будет в производном классе (дочерний класс). Для этого необходима аннотация @Override.
Проверьте это: нажмите здесь для подробного примера
Перегрузка методов связана с понятием наличия двух или более методов в одном классе с одним и тем же именем, но разными аргументами.
Переопределение метода означает наличие двух методов с одинаковыми аргументами, но разными реализациями. Один из них будет существовать в родительском классе, а другой будет в производном или дочернем классе. Аннотация @Override, хотя и не обязательна, может быть полезна для обеспечения правильного переопределения метода во время компиляции.
Пытался скрыть все отличия
Overloading Overriding
Method Name Must be same Must be same
Argument Types Must be same Must be different
Return Type No restriction Must be same till 1.4V
but after 1.4V
co- variants
were introduced
private/static/final Can be overloaded Cannot be overridden
Access Modifiers No restriction Cannot reduce the scope
Throws keyword No restriction If child class method
throws a checked
exception the parent
class method must throw
the same or the
parent exception
Method Resolution Taken care by compiler Taken care by JVM based
based on reference types on run-time object
Known as Compile-Time Polymorphism, RunTime Polymorphism,
Static Polymorphism, or dynamic polymorphism,
early binding late binding.