Question

我很困惑：我从学习资源中采用了以下引用（带有它们出现的部分的标题），但引号似乎让我互相矛盾。

超类引用和子类对象

“它是引用变量的类型 - 不是它所引用的对象的类型 - 它决定了可以访问的成员”

重写方法支持多态性

“它是被引用的对象的类型（不是引用变量的类型），它决定了将被执行的被覆盖方法的版本”

对此的任何澄清都将不胜感激。

Answer 1

如果classB扩展了ClassA，你有：

ClassA a = new ClassB ();

使用a变量，您只能访问ClassA（或ClassA的超类或ClassA实现的接口）中定义的成员。您无法访问ClassB中未定义的ClassA中定义的成员（除非您将a强制转换为ClassB）。

但是，调用在ClassA中重写的ClassB方法将执行ClassB方法。

Answer 2

超类引用和子类对象

假设Child扩展Parent，让我们看一下：

Parent obj = new Child();

现在，如果我们尝试使用obj，我们只能使用Parent类中指定的行为（方法）。我们不能使用Child类中的任何新方法。

但是，假设Parent和Child都有方法public String whoAmI()。

父：

 return "Parent";

子：

return "Child";

现在，如果我们运行此代码：

Parent obj1 = new Child();
Parent obj2 = new Parent();

System.out.println(obj1.whoAmI());
System.out.println(obj2.whoAmI());

输出：

Child
Parent

因此，您只能通过（第一个片段中的Parent）访问您引用它的类中的方法。但是如果你在类中重写它，它被实例化为（第一个片段中的Child），并覆盖子节点中父节点的方法，然后调用父节点中的方法将调用子节点中的方法覆盖。

Answer 3

看看下面的程序。

class SuperMem{
    int i = 90;
    int j = 100;

    void show(){
        System.out.println("parent show..");
        System.out.println("Show inside Parent start");
        System.out.println(i + " " + j);
        System.out.println("Show inside Parent END");
    }
}

class submem extends SuperMem{
    int i = 10;
    int j = 20;
    void show(){
        System.out.println("Child show ..");
        System.out.println("Show inside Child start");
        System.out.println(i + " " + j);
        System.out.println("Show inside Child END");

    }
}

public class SuperMemDemo {
    public static void main(String[] args) {
        SuperMem m = new SuperMem();
        submem s = new submem();
        m = s;

        System.out.println("i " + m.i);
        System.out.println("j " + m.j);
        m.show();
    }

}

OutPut -
   我90    j 100
   儿童表演..
   显示内部儿童开始
   10 20
   在儿童内显示结束

通过动态调度方法即在运行时解决方法。分析输出，您将从完整参考Herbert Schildt

获得上述两个陈述的含义

Answer 4

假设我们有两个班级。

`class Vehicle {

public void drive(){
    System.out.println("Vehicle is Moving");
}

}

类汽车扩展车辆{

public void drive(){
    System.out.println("Car is Moving");
}

public void playMusic(){
    System.out.println("Car is Playing Music");
}

}`

“它是引用变量的类型 - 不是它引用的对象的类型 - 它决定了可以访问的成员”

这意味着我们有一个像

这样的代码

车辆车辆=新车（）; 使用车辆对象，我们可以调用drive（），但不能调用playMusic（），因为车辆的类型是Vehicle

“它被引用的对象的类型（不是引用变量的类型）决定了将被执行的被覆盖方法的版本”

这意味着我们有一个像

这样的代码

车辆车辆=新车（）; vehicle.drive（）;

它将打印“Car is Moving”而不是“Vehicle is Moving”，因为存储在车辆中的对象是Car的一个实例。

超类引用子类对象

超类引用和子类对象

重写方法支持多态性

4 个答案: