Java重载和覆盖

Question

我们总是说方法重载是静态多态，而重写是运行时多态。静态到底是什么意思？在编译代码时是否解析了对方法的调用？那么正常方法调用和调用最终方法之间的区别是什么？哪一个在编译时链接？

Answer 1

方法重载意味着根据输入创建函数的多个版本。例如：

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

我希望有帮助

Answer 2

你是对的 - 在编译时实现对重载方法的调用。这就是为什么它是静态。

根据调用方法的类型，在运行时实现对重写方法的调用。

On virtual methods wikipedia says:

  

在Java中，默认情况下所有非静态方法都是“虚函数”。只有标记有关键字final的方法才是非虚拟的。

final方法无法被覆盖，因此它们是静态实现的。

想象一下这个方法：

public String analyze(Interface i) {
     i.analyze();
     return i.getAnalysisDetails();
}

编译器不能为可能传递给它的Interface的所有实现重载此方法。

Answer 3

我认为你不能过度调用任何类型的多态。重载方法在编译时链接，这种方法排除了将其称为多态性。

多态性是指在对派生类对象使用基类引用时，方法与其调用的动态绑定。覆盖方法就是如何实现这种多态行为。

Answer 4

我同意rachel，因为在K＆amp; B书中直接提到第2章（面向对象）中重载不属于多态。但在很多地方我发现重载意味着静态多态，因为它是编译时间，覆盖意味着动态多态，因为它是运行时。

但有一件有趣的事情是在C ++书中（C ++中的面向对象编程--Robert Lafore），也直接提到过载意味着静态多态。 但还有一件事是java和c ++都是两种不同的编程语言，它们有不同的对象操作技术，所以c ++和java中的多态性可能不同吗？

Answer 5

方法重载只是意味着在类中提供两个具有相同名称但不同参数的单独方法，而方法返回类型可能会有所不同，也可能不同，这使我们可以重用相同的方法名称。

但两种方法都不同，因此可以在编译时由编译器解决，这就是为什么它也被称为编译时多态性或静态多态

方法覆盖意味着在子类中定义一个方法，该方法已在父类中定义，具有相同的方法签名，即相同的名称，参数和返回类型。

Mammal mammal = new Cat();
System.out.println(mammal.speak());

在mammal.speak()行编译器中，调用了引用类型speak()的{​​{1}}方法，因此对于编译器，此调用是Mammal。

但是在执行时JVM清楚地知道Mammal.speak()引用持有mammal对象的引用，因此对于JVM，这个调用是Cat。

因为JVM在运行时解析了方法调用，这就是为什么它也被称为运行时多态性和动态方法调度。

方法重载和方法覆盖之间的区别

有关详细信息，请参阅Everything About Method Overloading Vs Method Overriding。

Answer 6

简单定义 - 方法重载处理在同一个类中具有相同名称但不同参数的两个或多个方法（函数）的概念。

虽然方法重写意味着有两个方法具有相同的参数，但实现方式不同。其中一个将存在于Parent类（B​​ase Class）中，而另一个将存在于派生类（Child Class）中。@ Override注释是必需的。

检查一下： Click here for a detailed example

Answer 7

属性重载覆盖

方法名称--------------＆gt;必须相同----------------必须相同

Arg类型------------------＆gt;必须不同（至少是arg）

方法签名

返回类型

私人，静态，最终

访问修饰符

的try / catch

方法解决方案

Answer 8

首先，我要讨论运行时/动态多态性和编译时/静态多态性。

编译时/静态多态性：-顾名思义，它在编译时将函数调用绑定到其适当的Function。这意味着编译器完全知道与哪个函数关联的哪个函数调用。函数重载是编译时多态的一个例子。

运行时/动态多态性：-在这种类型的多态性中，编译器在程序运行之前不知道哪个函数调用与哪个函数关联。例如。功能覆盖。

现在，什么是函数重载和函数重载？

函数重载：-相同的函数名称，但不同的函数签名/参数。

<input id="problemText" type="text" class="form-control" name="problem" value="" readonly>

函数覆盖：-更改在超类和子类中都存在的函数的工作。                 例如。超类中的name（）打印“ hello Rahul”，但是在子类中覆盖后，它打印“ hello Akshit”

Answer 9

试图涵盖所有差异

                       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.