Question

我有一个Parent类。

import java.util.HashMap;
import java.util.Map;


public class Parent {

    Map<String,String> map = new HashMap<String, String>();


    public void process(){
        System.out.println("parent");
        this.checkFunction();
    }

    protected void checkFunction(){
        System.out.println("parentC");
        System.out.println(map);
    }

    public void init(){
        (map).put("parent","b");

    }
}

现在，正如预期的那样，我有一个儿童班。

import java.util.HashMap;
import java.util.Map;


public class Child extends Parent {

    Map<String,String> map = new HashMap<String, String>();


    public void checkFunction(){
        System.out.println(map);
        System.out.println("ChildC");

    }

    public void process(){
        super.process();
        System.out.println("Child");

    }

    public void init(){

        super.init();
        (map).put("child","b");

    }
}

为了测试我想要的东西，我有一个主要课程。

public class test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Child a = new Child();
        a.init();
        a.process();
        Parent p = a;
        p.checkFunction();
    }

}

当我调用a.process（）时，我认为它应该调用child.process（），它将返回调用super.process（）。到现在为止还挺好。在Parent的process（）中，它应该调用checkFunction（）。

现在，根据我的理解，它应该调用Parent类的checkFunction（）。为什么要调用Child的checkFunction（）？

我的输出是这样的

parent
{child=b}
ChildC
Child
{child=b}
ChildC

我希望它是

parent
parentC
{parent=b}
Child
{child=b}
ChildC

Answer 1

这是因为您在子类中重写了checkFunction。因此，即使调用来自父类，子实例也会调用子checkFunction。

如果要从子实例调用父检查函数，则需要在子类中调用super.checkFunction（）。超级关键字基本上“向上移动”继承链。

可以找到超级关键字的详细说明here

OOPS概念调用父类而不是子类的函数

1 个答案: