是否可以调用子类？ 超类对象上的方法？

Question

Animal 是 Dog 的超类 Dog 有一个名为 bark 的方法

public void bark()
{
    System.out.println("woof");
}

考虑以下内容：

Animal a = new Dog();
if (a instanceof Dog){
    a.bark();
}

会发生什么？

1. 不允许赋值
2. 允许调用 bark，并在运行时打印“woof”
3. 允许调用 bark，但不打印任何内容
4. 对 bark 的调用导致编译时错误
5. 对 bark 的调用导致运行时错误

我说 2 是因为我们正在检查该物体是否是一只狗； 因为狗是其中包含 bark 方法的类，如果是，那么我们调用它，它将打印出 :s

我的理解正确吗？

Answer 1

这不会编译，因为 Animal 没有名为 bark 的方法。 可以这样想，所有的狗都是动物，但并非所有的动物都是狗。 所有的狗都会吠叫，但并非所有的动物都会吠叫。

Answer 2

不——答案是；

4) 对 bark 的调用导致编译时错误

bark 方法未定义为指定类型 Animal 上的方法，因此将导致编译时问题； 这可以通过铸造来解决；

((Dog)a).bark();

Answer 3

关键在于以下行：

Animal a = new Dog();

虽然创建了 Dog 的新实例，但它的引用是由 a 声明的，该实例被声明为 Animal 类型代码>. 因此，任何对 a 的引用都会使 new Dog 被作为 Animal 处理。

因此，除非 Animal 有 bark 方法，否则以下行将导致编译器错误：

a.bark();

即使 a 已被测试以查看它是否是一个Dog 的实例，并且 a instanceof Dog 实际上会返回 true，变量 a 仍然是 is 类型Animal，因此 if 语句内的块仍将 a 作为 Animal 处理。

这是静态类型语言的一项功能，其中变量提前分配类型，并在编译时检查类型是否匹配。 如果此代码在动态类型语言上执行，其中类型在运行时检查，可以允许类似以下内容：

var a = new Dog();
if (a instanceof Dog)
    a.bark();

a.bark() 保证仅在实例是 Dog 时执行，因此对 bark 的调用代码> 永远有效。 但是，Java 是静态类型语言，因此不允许这种类型的代码。

Answer 4

在 Head First Java 中，他们使用了电视遥控器的很好的比喻作为参考 /em> 和您的电视作为引用指向的对象。 如果您的遥控器只有开、关、频道加减、音量加减的按钮（方法），那么您的电视有什么炫酷的功能并不重要。 您仍然只能通过遥控器执行一些基本操作。 例如，如果您的遥控器没有静音按钮，则您无法将电视静音。

Animal 参考仅了解 Animal 方法。 无论底层对象有什么其他方法，您都无法从 Animal 引用访问它们。

Answer 5

是 4。你不能要求一个普通的动物（你的代码中的 a 是这样的）吠叫。 因为你可以很容易地说出来

Animal a = new Cat();

，但吠叫线无法知道你没有说过。

Answer 6

如果想法是从超类对象打印子类方法，那么这将起作用：

而不是 Animal a = new Dog(); if (Dog 的一个实例){ a.bark(); }
更改为

Animal a = new Dog();

if (a instanceof Dog){ 
    Dog d = (Dog) a; 
    d.bark();
}  

这将超类转换回子类并打印它。
尽管它的设计很糟糕，但它是动态了解其指向哪个子类对象的一种方法。

Answer 7

在java（我知道的唯一语言）中，您可以创建一个空方法并在超类中调用它。 然后你可以在子类中重写它来做你想做的事情。 这样超类调用其子类的方法。

public class Test {
    public static void main(String[] args){
        Snake S = new Snake();
        Dog d = new Dog();
    }
}


class Animal{ //Super Class
    public Animal(){
        bark(); //calls bark when a new animal is created
    }
    public void bark(){
        System.out.println("this animal can't bark");
    }
}



class Dog extends Animal{ //Subclass 1
    @Override
    public void bark(){
        System.out.println("Woof");
    }
}



class Snake extends Animal{//Subclass 2
    public void tss(){
    }
}

此代码调用 Snake 的对象，然后调用 Dog 的对象。 它将以下内容写入控制台：

this animal can't bark
Woof

Snake 没有任何 bark 方法，因此调用超类的方法。 它将第一行写入控制台。
Dog 有一个 bark 方法，因此超类调用它。 它将第二行写入控制台。

Answer 8

仅供参考，这不是一个好的设计。

几乎任何时候您拥有这种形式的代码：

if (x instanceof SomeClass)
{
   x.SomeMethod();
}

您都在滥用类型系统。 这不是使用类的方法，也不是编写可维护的面向对象代码的方法。 它很脆。 很复杂。 这不好。

您可以在基类中创建模板方法，但它们必须调用基类中存在并在子类中重写的方法。

Answer 9

“我说 2 是因为我们正在检查该对象是否是狗；因为狗是其中包含 bark 方法的类，如果是，那么我们调用它，它将打印出：s”

“我说 2 是因为我们正在检查该对象是否是狗；因为狗是其中包含 bark 方法的类，如果是， 是正确的，但这不是它的工作方式。

Java 是一种静态类型语言，这意味着对象可能响应的方法的有效性在编译时进行验证。

您可能认为支票：

if( a instanceof Dog ) 

可以，但实际上不行。 编译器所做的是检查声明类型的“接口”（在本例中为 Animal ）。 “接口”由 Animal 类上声明的方法组成。

如果超类 Animal 中没有定义 bark() 方法，编译器会说：“嘿，那不起作用”。

这很有用，因为“有时”我们在编码时会犯错（例如输入 barck() ）。

如果编译器没有警告我们这一点，您将必须在“运行时”找到它，并且并不总是有一个明确的提示。消息（例如 IE 中的 javascript 表示类似“意外对象”之类的内容）

不过，像 java 这样的静态类型语言允许我们强制调用。 在本例中，它使用“强制转换”运算符 ()

像这样

1. Animal a = new Dog();
2.  if (a instanceof Dog){
3.     Dog imADog = ( Dog ) a;
4.     imADog.bark();
5. }

在第 3 行中，您正在“强制转换”为 Dog 类型，以便编译器可以检查 bark 是否是有效消息。

这是向编译器发出的指令，“嘿，我是这里的程序员，我知道我在做什么”。 编译器检查，Ok，dog，可以接收消息 bark()，继续。 然而，如果在运行时动物不是狗，则会引发运行时异常。

演员阵容也可以缩写为：

if( a instanceof Dog ) {
   ((Dog)a).bark();  
}

That will run。

所以，正确的答案是4：“对 bark 的调用导致编译时错误”

我希望这会有所帮助。