blocks|key|1594013|text|类类型转换的用法是不同的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1594014|class+Employee()
{
++++//body
}

class+SalariedEmployee+extends+Employee()
{
++++//body
}|code-block|syntax|javascript|1594015|你有一些多态的代码。|1594016|public+static+void+met(Employee+e)
{
++++SalariedEmployee+s+=+(SalariedEmployee)e
}

public+static+void+somemethod()
{
++++//You+write+a+polymorphic+method
++++//You+will+create+a+list+of+Employees
++++//Then+you+can+write
++++ArrayList<Employee>+employees+=+new+ArrayList<Employee>()

+++//Create+a+SalariedEmployee
+++Employee+e+=+(Employee)+new+SalariedEmployee()
+++employees.add(e);

+++e+=+(Employee)+new+CommissionEmployee()
+++employees.add(e);+++++++++

}|1594017|你不能做SalariedEmployee+b+=+(SalariedEmployee)+new+Employee();，因为不能保证每个Employee都是SalariedEmployee。|offset|length|style|CODE|1594018|entityMap^0|0|0|0|0|4|1J|1W|8|26|G|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|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]|$M|11|N|12|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

The use for Class cast is something different.

<pre><code>class Employee()
{
 //body
}

class SalariedEmployee extends Employee()
{
 //body
}
</code></pre>

You have some polymorphic code.

<pre><code>public static void met(Employee e)
{
 SalariedEmployee s = (SalariedEmployee)e
}

public static void somemethod()
{
 //You write a polymorphic method
 //You will create a list of Employees
 //Then you can write
 ArrayList&lt;Employee&gt; employees = new ArrayList&lt;Employee&gt;()

 //Create a SalariedEmployee
 Employee e = (Employee) new SalariedEmployee()
 employees.add(e);

 e = (Employee) new CommissionEmployee()
 employees.add(e); 

}
</code></pre>

You can't do <code>SalariedEmployee b = (SalariedEmployee) new Employee();</code> because every <code>Employee</code> is not guaranteed to be a <code>SalariedEmployee</code>.

blocks|key|1621102|text|试试这个，它会对你有帮助的。我将向您展示您可以在您的程序中实现的小演示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1621103|//Inheitance+Pass+Reference+of+Child+class+into+Super+class+object
class+A
{

++++void+display()
++++{
++++++++System.out.println("\n\nSuper+class+A+Dispaly+method.");
++++}
}

class+B+extends+A
{

++++void+display1()
++++{
++++++++System.out.println("\n\nDerived+class+B+Dispaly+method.");
++++}

++++public+static+void+main+(String+args[])
++++{
++++++++A+objA+=+new+A();
++++++++objA.display();

++++++++A+a1;
++++++++B+b1+=+new+B();

++++++++//Here+is+your+answer.
++++++++a1=b1;++//Dynamic+Method+Distpatch
++++++++//a1+=+new+B();+//This+will+also+work.+//Dynamic+Method+Distpatch

++++++++a1.display1();++++++
++++}
}|code-block|syntax|javascript|1621104|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|$]]

Try this, It will help you.
I'll show you small demo that u can implement in your program.

<pre><code>//Inheitance Pass Reference of Child class into Super class object
class A
{

 void display()
 {
 System.out.println("\n\nSuper class A Dispaly method.");
 }
}

class B extends A
{

 void display1()
 {
 System.out.println("\n\nDerived class B Dispaly method.");
 }

 public static void main (String args[])
 {
 A objA = new A();
 objA.display();

 A a1;
 B b1 = new B();

 //Here is your answer.
 a1=b1; //Dynamic Method Distpatch
 //a1 = new B(); //This will also work. //Dynamic Method Distpatch

 a1.display1(); 
 }
}
</code></pre>

blocks|key|1621116|text|A实际上不是B+(不是每个A都是B，但所有的B都是A)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1621117|你可以这样做：|1621118|+A+a+=+new+B();
+if+(a+instanceof+B)+{
+++++B+dog+=+(B)+a;
+}|code-block|syntax|javascript|1621119|entityMap^0|0|1|6|1|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

<code>A</code> isn't actually <code>B</code> (not every A is B , but all B is A)

You can do it like that :

<pre><code> A a = new B();
 if (a instanceof B) {
 B dog = (B) a;
 }
</code></pre>

blocks|key|480453|text|以下面的例子为例|type|unstyled|depth|inlineStyleRanges|entityRanges|data|480454|public+class+Animal
{
++public+void+eat(){}
}
public+class+Dog+extends+Animal
{
++public+void+eat(){}
++public+void+main(String[]+args)
++{
++++Animal+animal=new+Animal();
++++Dog+dog=(Dog)+animal;+//will+not+work
++}
}|code-block|syntax|javascript|480455|通过使用强制转换，你本质上是在告诉编译器“相信我，我是专业的，我知道我在做什么，我知道尽管你不能保证，但我告诉你，这个动物变量肯定会是一只狗。”|480456|由于动物实际上不是狗(它是动物，您可以执行animal+animal+=+new+Dog()；它将是一条狗)，VM在运行时抛出一个异常，因为您违反了这种信任(您告诉编译器一切都会好的，但事实并非如此！)|480457|编译器比盲目地接受所有东西要聪明一点，如果你尝试在不同的继承层次中转换对象(例如，将Dog转换为字符串)，那么编译器会将其抛回给你，因为它知道这永远不可能起作用。|480458|因为您本质上只是阻止编译器抱怨，所以每次强制转换时，通过在if语句中使用instanceof+(或类似的东西)来检查是否不会导致ClassCastException是很重要的。|480459|在你的例子中，你说我的引用b将指向点B的对象，然后你让它指向类A的对象(这不是引用b所期望的类B的对象)。因此你得到了classCastException。|480460|你可以这样做|480461|A+a+=+new+B();
B+b+=+(B)+a;|480462|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Take the following example

<pre><code>public class Animal
{
 public void eat(){}
}
public class Dog extends Animal
{
 public void eat(){}
 public void main(String[] args)
 {
 Animal animal=new Animal();
 Dog dog=(Dog) animal; //will not work
 }
}
</code></pre>

By using a cast you're essentially telling the compiler "trust me. I'm a professional, I know what I'm doing and I know that although you can't guarantee it, I'm telling you that this animal variable is definitely going to be a dog."

Since the animal isn't actually a dog (it's an animal, you could do Animal animal = new Dog(); and it'd be a dog) the VM throws an exception at runtime because you've violated that trust (you told the compiler everything would be ok and it's not!)

The compiler is a bit smarter than just blindly accepting everything, if you try and cast objects in different inheritence hierarchies (cast a Dog to a String for example) then the compiler will throw it back at you because it knows that could never possibly work.

Because you're essentially just stopping the compiler from complaining, every time you cast it's important to check that you won't cause a ClassCastException by using instanceof in an if statement (or something to that effect.)

In your case you are saying my reference b will point to object of point B and then you make it point to object of class A(which is not object of class B that reference b was expecting). Hence you get the classCastException.

You could do something like 

<pre><code>A a = new B();
B b = (B) a;
</code></pre>

blocks|key|3717430|text|假设你有Animal和Dog+extends+Animal。你可以说“一只狗是一只动物”(Animal+animal+=+new+Dog())，但不能说“一只动物是一只狗”(Dog+dog+=+new+Animal())。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3717431|Animal也可以是Cat或其他什么，而Dog或Cat必须是Animal。|3717432|entityMap^0|4|6|B|I|19|P|2F|M|0|0|6|A|3|K|3|O|3|U|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|I|$]]

Let's say you got <code>Animal</code> and <code>Dog extends Animal</code>. You can say "a dog is an animal" (<code>Animal animal = new Dog()</code>) but you can't say "an animal is a dog" (<code>Dog dog = new Animal()</code>).

An <code>Animal</code> could also be a <code>Cat</code> or whatever, while a <code>Dog</code> or a <code>Cat</code> is necessarily an <code>Animal</code>.

blocks|key|1594287|text|此外，孩子总是知道父，这是通过使用扩展关键字完成的，但父不知道孩子。当编写以下代码时：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1594288|A+a=+new+B()；|1594289|由于子对象中的扩展子句，编译器能够将子对象的引用分配给父对象，该引用在编译时本身就会被解析。继承关系是在编译时本身解析的。Java中的强制转换只影响对引用的处理；它们永远不会改变实际对象的形式。引用所指向的对象永远不会因为强制转换而改变，只有编译器(或运行时系统)的概念会改变。|1594290|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Also Child is always aware of parent which is done by using extends keyword but parent has no knowledge about child. When following is written:

A a = new B();

due the extends clause in child, compiler is able to assign reference of child to parent which is resolved at compile time itself. Inheritance relation is resolved at compile time itself.
Casts in Java affect only the treatment of references; they never change the form of the actual object. The object pointed to by a reference is never changed by casting it, only the compiler's (or run-time system's) notion of it is changed.

Let's say:

<pre><code>class A {
 public int fieldA = 0;
}

class B extends A {
 public int fieldB = 0; 
}
</code></pre>

Now, I want to create a instance of B from A:

<pre><code>A a = new A();
B b = (B) new A();
</code></pre>

This gives a classCastException. I can make a costructor in B that takes a A instance and copy fields, but it's clearly non pratical:

<pre><code>class B extends A {
 public int fieldB = 0; 

 B (A a){
 fieldA = a.fieldA;
 }
}
</code></pre>

Thank you for your help

Create a subclass from superclass

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

比方说：class A {    public int fieldA = 0;}class B extends A {    public int fieldB = 0; }现在，我想从A创建一个B的实例：A a = new A();B b = (B) new A();这给出了一个classCastException。...

问从超类创建一个子类
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从超类创建一个子类EN