java中多态性概念的混淆

我对java中的多态性概念有点困惑，因为不同的作者写的不同

案例-1

动态（运行时）多态性——使用实例方法的方法重载和方法重写就是动态多态性的例子

静态（编译时）多态性——使用静态方法的方法重载和方法重写；使用私有或final方法重写方法是静态多态性的示例

案例2

方法重载是编译时/静态多态性的一个例子

方法重写是运行时/动态多态性的一个示例

那么哪种情况是正确的？？？

---

java支持静态多态还是动态多态

重载是在编译时进行的。 重写是在运行时进行的。 所以案例2是正确的。

案例2是正确的

方法重写-运行时多态性

方法重载-编译时多态性

编译时和运行时多态性与调用的解析时间直接相关

在编译时多态性中，调用在编译时解析。方法重载是编译时多态性的一个例子。重载与它是在实例级别还是在类级别无关

例如：

 public class Sample {
    static void doSomething(InputStream is) {
        System.out.println("is");
    }

    static void doSomething(OutputStream os) {
        System.out.println("os");
    }

    public static void main(String args[]) {
        System.out.println(doSomething(null)); // "compilation" error . Ambiguous call. Both InputStream and OutputStream can take `null` argument.
    } 

}

接下来是运行时多态性：这里在编译时检查调用/方法签名是否存在，但在运行时解析实际调用。 例如：

class ParentOfSample {
    void testingOverriding(String s) {
        System.out.println("Parent..");
    }
}

public class Sample extends ParentOfSample {
    static void doSomething(InputStream is) {
        System.out.println("is");
    }

    static void doSomething(OutputStream os) {
        System.out.println("os");
    }

    void testingOverriding(String s) {
        System.out.println("Sample..");
    }

    public static void main(String args[]) {
        ParentOfSample s = new Sample();
        s.testingOverriding(null);
    }
}

O/p: 样品请注意，在重写过程中，方法签名是相同的

---

因此，底线是：第二种情况是正确的。Java支持静态和动态多态性。

基本上方法重载是静态绑定，也可以说是早期绑定。因为编译器在编译时只能识别实际要调用的方法

方法重写是动态绑定或后期绑定，其中JVM仅在运行时标识方法调用（取决于指向哪个子类对象的基类引用）

您可以检查此方法是否存在方法重载：

class OverLoadedClass{
int x;
int y;
public void display(int x)
  {
    System.out.println(x);    
  }
public void display(int x,int y)
  {
    System.out.println(x+""+y);
  }
 }
 public class Test{
     public static void main(String args[]){
    OverLoadedClass o= new OverLoadedClass();
    o.display(5);
    o.display(5,10);
}
}

class Base{
int x;
public void display(int x)
 {
  System.out.println(x);
 }
}
class Child extends Base{
int x;
public void display(int x)
 { 
   System.out.println(x);
  }
}
public class Test{
public static void main(String args[]){
    Base o= new Child();
    o.display(5);
}
}

您可以检查此方法是否覆盖了：

class OverLoadedClass{
int x;
int y;
public void display(int x)
  {
    System.out.println(x);    
  }
public void display(int x,int y)
  {
    System.out.println(x+""+y);
  }
 }
 public class Test{
     public static void main(String args[]){
    OverLoadedClass o= new OverLoadedClass();
    o.display(5);
    o.display(5,10);
}
}

class Base{
int x;
public void display(int x)
 {
  System.out.println(x);
 }
}
class Child extends Base{
int x;
public void display(int x)
 { 
   System.out.println(x);
  }
}
public class Test{
public static void main(String args[]){
    Base o= new Child();
    o.display(5);
}
}

---

看看这个类似的问题：