Question

所以我一直在研究抽象类和动态绑定，并决定测试几个例子。

我有以下3个类：AbstractDemo（main），MyAbstract和MySubAbstract。主要方法是使用动态或静态绑定从两个类调用方法。

除了我尝试使用动态绑定并调用仅在子类（sub1（））中定义的方法之一的最后一个调用之外，所有以下调用都有效。我假设尽管声明了超类的引用，但对象仍然能够找到在该对象的类中声明的方法。

有人可以解释一下原因吗？

public abstract class MyAbstract {
 public abstract void abs1();   
 public abstract void abs2();

 public void nonAbs1() {
    System.out.println("MyAbstract nonAbs1");
 }

 public void nonAbs2() {
    System.out.println("MyAbstract nonAbs2");
 }
}


public class MySubAbstract extends MyAbstract {

 public void abs1() {
     System.out.println("MySubAbstract abs1()"); 
 }

 public void abs2() {
     System.out.println("MySubAbstract abs2()");
 }

 public void sub1() {
      System.out.println("MySubAbstract sub1()");
 }

 public void sub2() {
      System.out.println("MySubAbstract sub2()");
 }

 public void nonAbs1() {
      System.out.println("MySubAbstract nonAbs1()");
 }
}


public class AbstractDemo {

 public static void main(String[] args) {
    MySubAbstract a = new MySubAbstract(); a.abs1();
    MySubAbstract b = new MySubAbstract(); b.sub1();
    MySubAbstract c = new MySubAbstract(); c.nonAbs2();
    MySubAbstract d = new MySubAbstract(); d.nonAbs1();
    MySubAbstract e = new MySubAbstract(); e.nonAbs2(); 
    MyAbstract f = new MySubAbstract(); f.abs1();
    MyAbstract g = new MySubAbstract(); g.nonAbs1();
    MyAbstract h = new MySubAbstract(); h.sub1();
  }
}

Answer 1

从您的代码h声明为MyAbstract，因此如果没有显式转换，您只能访问MyAbstract中声明的方法（抽象和具体方法）。

要致电sub1()，您需要投出

MyAbstract h = new MySubAbstract(); 
((MySubAbstract) h).sub1();

Answer 2

MyAbstract h = new MySubAbstract（）; h.sub1（）;

这将创建并对象MySubAbstract并将其存储在MyAbstract类型的引用中，这意味着您只能从MyAbstract调用方法，除非您将其((MySubAbstract) h)强制转换。< / p>

请将polymorphism视为例子

抽象类和动态绑定

2 个答案: