blocks|key|800390|text|Superclass+variable+=+new+subclass+object();|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|800391|这只是创建一个类型子类的对象，但将其分配给类型超类。所有子类的数据都是创建的，但是变量不能访问子类数据/函数。换句话说，您不能调用任何方法或访问特定于子类的数据，您只能访问超类内容。|800392|但是，您可以将超类变量转换为子类并使用它的方法/数据。|800393|entityMap^0|0|18|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|K|$]]

<code>Superclass variable = new subclass object();</code> This just creates an object of type subclass, but assigns it to the type superclass. All the subclasses' data is created etc, but the variable cannot access the subclasses data/functions. In other words, you cannot call any methods or access data specific to the subclass, you can only access the superclasses stuff.

However, you can cast Superclassvariable to the Subclass and use its methods/data.

blocks|key|800406|text|请看一下这个示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|800407|public+class+A+{
++//statements
}

public+class+B+extends+A+{
++public+void+foo()+{+}
}

A+a=new+B();

//To+execute+**foo()**+method.

((B)a).foo();|code-block|syntax|javascript|800408|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Have a look at this sample:

<pre><code>public class A {
 //statements
}

public class B extends A {
 public void foo() { }
}

A a=new B();

//To execute **foo()** method.

((B)a).foo();
</code></pre>

blocks|key|821767|text|假设您有一个超类果树和子类Banana，并且您有一个方法addBananaToBasket()|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|821768|例如，该方法将不接受葡萄，因此您需要确保将香蕉添加到篮子中。|821769|所以：|821770|Fruit+myFruit+=+new+Banana();|CODE|821771|((Banana)myFruit).addBananaToBasket();⇐--这叫做铸造|821772|entityMap^0|8|2|D|6|0|A|2|0|0|0|T|0|0|12|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Y|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|Z|8|@$9|10|A|11|B|L]]|D|@]|E|$]]|$1|M|3|N|5|6|7|12|8|@$9|13|A|14|B|L]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$]]

Say you have a superclass Fruit and the subclass Banana and you have a method addBananaToBasket()

The method will not accept grapes for example so you want to make sure that you're adding a banana to the basket.

So:

<code>Fruit myFruit = new Banana();</code> 
<code>((Banana)myFruit).addBananaToBasket();</code> ⇐ This is called casting

blocks|key|821819|text|在这个例子中，超类变量告诉子类对象实现超类的方法。这就是java对象类型转换的情况。在这里，method()函数最初是超类的方法，但是超类变量不能访问子类对象中不存在于超类中的其他方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|821820|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In this example your superclass variable is telling the subclass object to implement the method of the superclass. This is the case of the java object type casting. Here the method() function is originally the method of the superclass but the superclass variable cannot access the other methods of the subclass object that are not present in the superclass.

blocks|key|2940807|text|强制转换是必要的，可以告诉您正在调用的是子方法，而不是父方法。所以它一直在向下。但是，如果方法已经在父类中定义，而在子类中被覆盖，则不进行任何强制转换。这里有一个例子：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2940808|class+Parent{
+++void+method(){+System.out.print("this+is+the+parent");+}
}

class+Child+extends+Parent{
+++@override
+++void+method(){+System.out.print("this+is+the+child");+}
}
...
Parent+o+=+new+Child();
o.method();
((Child)o).method();++|code-block|syntax|javascript|2940809|两个方法调用都会打印：“这是子”。|2940810|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Casting is necessary to tell that you are calling a child and not a parent method. So it's ever downward. However if the method is already defined in the parent class and overriden in the child class, you don't any cast. Here an example:

<pre><code>class Parent{
 void method(){ System.out.print("this is the parent"); }
}

class Child extends Parent{
 @override
 void method(){ System.out.print("this is the child"); }
}
...
Parent o = new Child();
o.method();
((Child)o).method(); 
</code></pre>

The two method call will both print : "this is the child".

blocks|key|821859|text|有时候，你会喜欢接受父母的推荐信作为论据，而在你的内心里，你可能想要做一些关于孩子的具体事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|821860|abstract+class+Animal{
+public+abstract+void+move();
}
class+Shark+extends+Animal{
+public+void+move(){
++swim();
+}
+public+void+swim(){}
+public+void+bite(){}
}
class+Dog+extends+Animal{
+public+void+move(){
++run();
+}
+public+void+run(){}
+public+void+bark(){}
}

...

void+somethingSpecific(Animal+animal){
+//+Here+you+don't+know+and+may+don't+care+which+animal+enters
+animal.move();+//+You+can+call+parent+methods+but+you+can't+call+bark+or+bite.
+if(animal+instanceof+Shark){
++Shark+shark+=+(Shark)animal;
++shark.bite();+//+Now+you+can+call+bite!
+}
+//doSomethingSharky(animal);+//+You+cannot+call+this+method.
}

...|code-block|syntax|javascript|821861|在上面的方法中，您可以通过Shark或Dog，但是如果您有这样的东西呢：|821862|void+doSomethingSharky(Shark+shark){
+//Here+you+cannot+receive+an+Animal+reference
}|821863|该方法只能通过传递鲨鱼引用来调用，因此，如果您有一个动物(它是一只鲨鱼)，您可以这样调用它：|821864|Animal+animal...
doSomethingSharky((Shark)+animal)|821865|总之，您可以使用父引用，如果您不关心父对象的实现，并且使用强制转换来使用子对象作为特定对象，那么它将是完全相同的对象，但是您的引用知道它，如果您不转换它，您的引用将指向同一个对象，但无法确定它将是哪种动物，因此只允许您调用已知的方法。|821866|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Sometimes you will like to receive as argument a Parent reference and inside you probably want to do something specific of a child.

<pre><code>abstract class Animal{
 public abstract void move();
}
class Shark extends Animal{
 public void move(){
 swim();
 }
 public void swim(){}
 public void bite(){}
}
class Dog extends Animal{
 public void move(){
 run();
 }
 public void run(){}
 public void bark(){}
}

...

void somethingSpecific(Animal animal){
 // Here you don't know and may don't care which animal enters
 animal.move(); // You can call parent methods but you can't call bark or bite.
 if(animal instanceof Shark){
 Shark shark = (Shark)animal;
 shark.bite(); // Now you can call bite!
 }
 //doSomethingSharky(animal); // You cannot call this method.
}

...
</code></pre>

In above's method you can pass either Shark or Dog, but what if you have something like this:

<pre><code>void doSomethingSharky(Shark shark){
 //Here you cannot receive an Animal reference
}
</code></pre>

That method can only be called by passing shark references
So if you have an Animal (and it is deeply a Shark) you can call it like this:

<pre><code>Animal animal...
doSomethingSharky((Shark) animal)
</code></pre>

Bottom line, you can use Parent references and it is usually better when you don't care about the implementation of the parent and use casting to use the Child as an specific object, it will be exactly the same object, but your reference know it, if you don't cast it, your reference will point to the same object but cannot be sure what kind of Animal would it be, therefore will only allow you to call known methods.

blocks|key|800576|text|您所引用的示例在java中称为Upcasting。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|800577|它使用指向它的超类变量创建子类对象。|800578|变量不变，它仍然是超类的变量，但它指向子类的对象。|800579|例如，假设你有两个类机器和照相机；照相机是机器的一个子类|800580|class+Machine{

++++public+void+start(){

++++++++System.out.println("Machine+Started");
++++}
}

class+Camera+extends+Machine{
+++++public+void+start(){

++++++++++++System.out.println("Camera+Started");
++++++++}
+++++public+void+snap(){
+++++++++System.out.println("Photo+taken");
+++++}
+}
Machine+machine1+=+new+Camera();
machine1.start();|code-block|syntax|javascript|800581|如果您执行上述语句，它将创建一个带有指向it.So的机器类引用的照相机类实例，现在输出将是"Camera+Started“，变量仍然是Machine的引用。如果尝试machine1.snap();，代码将不会编译|offset|length|style|BOLD|CODE|800582|所有的相机都是机器，因为照相机是机器的子类，但是所有的机器都不是相机。因此，您可以创建一个子类对象，并将其指向一个超类参考，但您不能要求超类引用来执行子类对象的所有功能(在我们的示例中，machine1.snap()不会编译)。超类引用只能访问超类已知的函数(在我们的示例machine1.start()中)。你不能要求一台机器的参考来抓拍。:)|800583|entityMap^0|0|0|0|0|0|1A|E|2A|G|0|2L|F|3S|G|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|11|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|12|8|@$O|13|P|14|Q|R]|$O|15|P|16|Q|S]]|9|@]|A|$]]|$1|T|3|U|5|6|7|17|8|@$O|18|P|19|Q|S]|$O|1A|P|1B|Q|S]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|W|$]]

The example you are referring to is called Upcasting in java.

It creates a subclass object with a super class variable pointing to it.

The variable does not change, it is still the variable of the super class but it is pointing to the object of subclass.

For example lets say you have two classes Machine and Camera ; Camera is a subclass of Machine

<pre><code>class Machine{

 public void start(){

 System.out.println("Machine Started");
 }
}

class Camera extends Machine{
 public void start(){

 System.out.println("Camera Started");
 }
 public void snap(){
 System.out.println("Photo taken");
 }
 }
Machine machine1 = new Camera();
machine1.start();
</code></pre>

If you execute the above statements it will create an instance of Camera class with a reference of Machine class pointing to it.So, now the output will be "Camera Started"
The variable is still a reference of Machine class. If you attempt <code>machine1.snap();</code> the code will not compile

The takeaway here is all Cameras are Machines since Camera is a subclass of Machine but all Machines are not Cameras. So you can create an object of subclass and point it to a super class refrence but you cannot ask the super class reference to do all the functions of a subclass object( In our example <code>machine1.snap()</code> wont compile). The superclass reference has access to only the functions known to the superclass (In our example <code>machine1.start()</code>). You can not ask a machine reference to take a snap. :)

blocks|key|2940881|text|在某些情况下，我们不能保证集合中存在的元素或对象的类型，或者wise，在强制检索时，我们应该执行类型转换，否则就会出现编译时错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2940882|数组总是类型安全的，也就是说，我们可以为数组中存在的元素类型提供保证。为了实现类型安全，我们必须使用类型转换。|2940883|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

in some cases we can’t provide guarantee for the type of elements or objects present inside our collection or wise, 
at the time of retrieval compulsory we should perform type casting otherwise we will get compile time error.

Arrays are always type safe that is we can provide the guarantee for the type of elements present inside array.
to achieve type safety we have to use typecasting.

blocks|key|800635|text|例如，您有动物超类和Cat+subclass.Say，您的子类有have+()；方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|800636|class+Animal{

++public+void+walk(){

++}

}

class+Cat+extends+Animal{

++@Override
++public+void+walk(){

++}

++public+void+speak(){

++}

++public+void+main(String+args[]){

++++Animal+a=new+Cat();
++++//a.speak();+Compile+Error
++++//+If+you+use+speak+method+for+"a"+reference+variable+you+should+downcast.+Like+this:

++++((Cat)a).speak();
++}

}|code-block|syntax|javascript|800637|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For example you have Animal superclass and Cat subclass.Say your subclass has speak(); method.

<pre><code>class Animal{

 public void walk(){

 }

}

class Cat extends Animal{

 @Override
 public void walk(){

 }

 public void speak(){

 }

 public void main(String args[]){

 Animal a=new Cat();
 //a.speak(); Compile Error
 // If you use speak method for "a" reference variable you should downcast. Like this:

 ((Cat)a).speak();
 }

}
</code></pre>

blocks|key|2940907|text|假设A类是超类，B类是A的子类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2940908|public+class+A+{

++++public+void+printFromA(){
++++++++System.out.println("Inside+A");
++++}
}
public+class+B+extends+A+{

++++public+void+printFromB(){
++++++++System.out.println("Inside+B");
++++}

}

public+class+MainClass+{

++++public+static+void+main(String+[]args){

++++++++A+a+=+new+B();
++++++++a.printFromA();+//this+can+be+called+without+typecasting

++++++++((B)a).printFromB();+//the+method+printFromB+needs+to+be+typecast+
++++}
}|code-block|syntax|javascript|2940909|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Lets say you have Class A as superclass and Class B subclass of A.

<pre><code>public class A {

 public void printFromA(){
 System.out.println("Inside A");
 }
}
public class B extends A {

 public void printFromB(){
 System.out.println("Inside B");
 }

}

public class MainClass {

 public static void main(String []args){

 A a = new B();
 a.printFromA(); //this can be called without typecasting

 ((B)a).printFromB(); //the method printFromB needs to be typecast 
 }
}
</code></pre>

I'm confused about what it means to cast objects in Java.

Say you have...

<pre><code>Superclass variable = new Subclass object();
(Superclass variable).method();
</code></pre>

What is happening here? Does the variable type change, or is it the object within the variable that changes? Very confused.

Casting objects in Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我对在Java中转换对象意味着什么感到困惑。说你有..。Superclass variable = new Subclass object();(Superclass variable).method();这里发生了什么事？变量类型是改变了，还是变量中的对象发生了变化？很困惑。

问Java中的铸造对象
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中的铸造对象EN