问“类变量的类型决定了哪些方法名可以与变量一起使用”。那是什么意思？
EN

Stack Overflow用户

提问于 2019-02-27 19:34:23

回答 4查看 108关注 0票数 0

我目前正在研究多态性，但我不理解以下语句：

类变量的类型决定了哪些方法名称可以与变量一起使用。但是，由变量命名的对象决定了使用哪个具有相同方法名称的定义。

我很困惑。

java

云联络中心6.1折起

灵活稳定的一体化云联络中心，助力快速搭建集电话、在线交流、音视频通话为一体的客户联络平台

回答 4

Stack Overflow用户

发布于 2019-02-27 19:38:19

这意味着您可以从对象调用的方法受到该对象类型的限制。例如，假设您有以下类：

public class Animal {
    public void sayName() {
        System.out.println('animal');
    }
}

public class Cow extends Animal {
    @Override
    public void sayName() {
        System.out.println('cow');
    }

    public void sayMoo() {
        System.out.println('mooo');
    }
}

现在，您可以像这样声明您的奶牛：

Animal cow = new Cow();

您可以这样做，因为Cow是Animal的子类。然而，如果你这样做了，你将不能用你的Cow说moo，因为你已经创建了一个简单的Animal变量。因此，无法从您的变量访问sayMoo方法。

票数 1

Stack Overflow用户

发布于 2019-02-27 19:39:12

类变量的类型决定了哪些方法名可以与变量一起使用。

这意味着如果你有一个Base类和一个Base类型的变量：

Base base = ...

您可以调用一个方法

base.method()

仅当在类Base (或Base的超类)中定义method()时。

但是，由变量命名的对象确定使用哪个具有相同方法名称的定义。

这意味着调用base.method()并不总是执行Base类的method()。

例如，如果Derived是一个扩展类Base并覆盖method()方法的类，那么如果base引用的实例的实际类型是Derived

Base base = new Derived();

然后调用

base.method();

将执行method()的Derived类实现。

“类变量的类型”是指引用变量的静态(编译时)类型。

“由变量命名的对象”指的是由变量引用的实例(对象)的动态(运行时)类型。

票数 1

Stack Overflow用户

发布于 2019-02-27 19:46:25

考虑以下代码(以及其中的解释)：

class A {
   public void methodA() {
       System.out.println("A -> A");
   }
   public void methodB() {
       System.out.println("A -> B");
   }
}

class B extends A {
   @Override
   public void methodB() {
       System.out.println("B -> B");
   }
   public void methodC() {
       System.out.println("B -> C");
   }
}

A a = new B(); 

// here, the type of variable a determines which methods can be called on that var.
// A declares two methods, methodA and methodB and only those can be called.
// Even a is actually referring to an instance of B which declares methodC
// as well, the call a.methodC() is not valid because a has type A.
a.methodA(); // prints A -> A

// Here, the actual implementation (the object that a refers to) determines 
// which implementation is being called and because the actual object 
// is an instance of B, we get B -> B printed.
a.methodB(); // prints B -> B
// a.methodC(); cannot be called