Java 为什么不'；多态性在这种情况下不起作用吗？

方法调用

aThing.intValue（）

是一个编译器错误。为什么多态性在这种情况下不起作用

我的教科书中还有一个相关的陈述，有点复杂：

可以执行操作的决定因素是引用的类型，而不是被引用对象的类型

你能简要说明一下吗

其中as

Computer[]labComputers=新计算机[10]适用于多态性

Object aThing = new Integer(25);

添加了：
我相信在中间的某个地方，会有

public class Computer {
    int ram;
    public Computer(int rm){
        ram= rm;
    }
    public String toString(){
        String result = "ram is " + ram;
        return result;
    }
}


public class Notebook extends Computer{
int size;
public Notebook(int rm, int sz){
    super(rm);
    size = sz;
}
@Override
    public String toString(){
        String result = super.toString() + " size is " + size;
        return result;
    }

}

对于方法调用
labComputers[1].toString（）
，polymophism确保调用正确的
toString
。在我看来，
labComputer[1]=新笔记本（2,15）
相当于
对象o=新整数（25）。但是多态性对我的计算机示例有效，而不是在对象整数示例中。为什么？
因为即使
整数
是
对象
，
对象
不是
整数
，因此它没有
整数
的方法，只有
对象


可以执行操作的决定因素是引用的类型，而不是被引用对象的类型

这意味着，即使被引用的对象包含更多功能，如果引用的类型与对象的类型不同，则只有引用类型的功能可用

在以下方面：

labComputer[1] = new Notebook(2,15);
labComputer[2] = new Computer(2);

aThing
的类型声明为
Object
。即使实现包含的内容不止这些，但实现包含的任何其他内容都不再可见，因为变量的类型不是
Integer
，而是
Object
。
对象
和
整数
都有相同的方法，但从现在起，您只能访问
对象
提供的方法，因为除了您之外，没有人知道这实际上是一个
整数
，而不仅仅是一个
对象


在第二个示例中，它们意味着即使
Object
和
Integer
都有相同的方法，当您调用其中一个方法时，也会调用实际类型的方法。因此，在本例中，如果您在
aThing
上调用
toString（）
，您将调用
Integer
的
toString（）
方法，而不是
对象。因此，这只是一个访问问题。将其声明为
对象
的事实并不意味着您将获得
对象
的方法来响应调用，它只意味着
整数
中存在而不在
对象
中的任何方法都将不可用


例如：

Object aThing = new Integer(25);

现在让我们创建一个
笔记本
：

class Computer {
    public int getInstalledOperatingSystems() { return 3; }
}

class Desktop extends Computer {
    public String getShapeOfCase() { ... }
}

class Notebook extends Computer {
    public int getInstalledOperatingSystems() { return 1; }
    public String getBrand() { ... }
    public void closeLid() { ... }
}

showStatistics(n);

假设您有以下方法：

Notebook n = new Notebook();

如果使用上面定义的
笔记本
调用此方法：

public String showStatistics(Computer computer) {
    result = "Operating systems: " + computer.getInstalledOperatingSystems();
    return result;
}

然后该方法将接收
笔记本
，因为
笔记本
是
计算机
。它可以调用
笔记本
的
getInstalledOperatingSystems（）
方法，因为任何
计算机
都有该方法。当它调用它时，结果将接收
1
，因为
笔记本
覆盖了
计算机
的实现。但是
showStatistics（）。不管怎么说，它有一台
计算机
，它不知道
计算机
没有的任何其他方法

你可以给它发送一个
桌面
，或者明天你可以创建一个扩展
桌面
的
游戏机
，或者一个扩展
计算机
的
服务器
类。你也可以寄这个。但是
showStatistics（）。它甚至在编写
showStatistics（）
时还没有发明

这与以下说法是一致的：
服务器
始终是
计算机
，而
计算机
并不总是
服务器


你可以查一下。因此，如果您知道您可能会被传递到
笔记本
，而不仅仅是一台计算机，您可以查找它，甚至可以调用
笔记本
的方法，但您必须确保您正在查看
笔记本
：

class Computer {
    public int getInstalledOperatingSystems() { return 3; }
}

class Desktop extends Computer {
    public String getShapeOfCase() { ... }
}

class Notebook extends Computer {
    public int getInstalledOperatingSystems() { return 1; }
    public String getBrand() { ... }
    public void closeLid() { ... }
}

showStatistics(n);

它不起作用，因为您的变量来自
Object
类，所以只能使用
Object
类中的方法。如果要将其用作
整数
，应首先执行（向下）类型转换：

if (computer instanceof Notebook) {
    // this is definitely a Notebook, so you can assure the compiler
    // of that explicitly, by using a cast
    Notebook notebook = (Notebook) computer;

    result += "This isn't just a generic computer, it's actually a notebook! ";

    // now that you have a variable of type Notebook, you can call
    // whatever Notebook provides
    result += "It's produced by: " + notebook.getBrand();
}

现在，为什么我们可以工作？因为如果类型转换不起作用，向下转换可能会抛出ClassCastException

在您的示例中，我将发布一个基本代码来说明polymophism是如何工作的：

Integer aInteger = (Integer)aThing;
//it could maybe work
aInteger.intValue();

这样想，dog是一个对象，dog类可能有如下方法

dog.bark（）

如果将层次向上投射到对象，则对象的特定性会降低

objecto=dog

现在你们只知道o是一个物体，你们不知道什么样的物体，所以你们不知道这个物体是否会吠叫

当你向上移动层次结构时，你几乎总是会因为对你拥有的东西不太明确而失去功能。
编译器需要被告知对象应该是什么类型，这样它就可以查找类并查看方法是否合法

所以你可以说
objectathing=newinteger（25）但是你想说
intthingvalue=（整数）aThing.intValue（）

如果有一个MySubClass对象是subc