blocks|key|587180|text|这在Java中是不可能的。原因是汽车不是火车，尽管它们的大部分功能都是相同的。如果火车有一种方法ChooChoo，这显然对一辆车没有意义，但你试图在一辆作为火车的汽车上叫它，会发生什么呢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|587181|解决这一问题的方法是尝试与车辆一起工作。如果您目前有一些与Trains一起工作的代码，但没有使用列车的任何细节，那么更改代码来处理车辆应该是安全的。如果它确实利用了火车的细节，那么当它通过非火车时，你期望它如何工作呢？|587182|entityMap^0|1C|8|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

That's not possible in Java. The reason is that a Car is not a Train, even though they might have most of their functionality in common. What would happen if Train had a method <code>ChooChoo</code>, which clearly doesn't make sense for a car, but you tried to call it on a Car casted as a Train.

<hr>

The way to go about this is to try to work with Vehicle. If you currently have some code which works with Trains, but doesn't make any use of the Train specifics, it should be safe to change the code to work with Vehicle. 
If it does make use of Train specifics, how do you expect it to work when it's passed non-Trains?

blocks|key|587215|text|请注意，Car和Train是两个不同的Vehicle具体类，因此不能在它们之间进行“强制转换”。我想您想要的是在两个对象之间复制公共属性。您可以使用来自阿帕奇或春天的bean来实现这一点。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|587216|entityMap|0|LINK|mutability|MUTABLE|url|https://commons.apache.org/proper/commons-beanutils/apidocs/org/apache/commons/beanutils/BeanUtils.html|1|http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/beans/BeanUtils.html^0|4|3|8|5|J|7|24|3|0|28|2|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]|$9|Z|A|10|1|11]]|E|$]]|$1|F|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

Note that <code>Car</code> and <code>Train</code> are two different concrete classes of <code>Vehicle</code>, so you cannot "cast" between them. I guess what you want is to copy common properties between two objects. You can use bean utils from <a href="https://commons.apache.org/proper/commons-beanutils/apidocs/org/apache/commons/beanutils/BeanUtils.html" rel="nofollow">Apache</a> or <a href="http://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/beans/BeanUtils.html" rel="nofollow">Spring</a> to do that.

blocks|key|395959|text|您所说的完全可以通过某种反射方式实现；只要做一些小小的努力，就可以编写一个泛型实现，它需要两个不同的类，并尝试通过名称/类型和相互之间的传递值来匹配字段。例如，这个问题对您要寻找的内容有一些粗略的实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|395960|但我认为你应该通过继承来处理这件事。如果Car和Train都是Vehicle的，但是即使它们之间仍然有一些相似之处，也不能相互交换，那么您应该创建一个包含所有相似之处的Vehicle实现。然后，您可以简单地从这个常见的Car实现扩展您的Train和Vehicle类。|style|CODE|395961|e.g|395962|class+MovingVehicle+extends+Vehicle+//(class+which+contains+similiarities)
class+Car+extends+MovingVehicle
class+Train+extends+MovingVehicle|code-block|syntax|javascript|395963|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3913260/compare-fields-of-two-unrelated-objects^0|28|4|0|0|K|3|O|5|V|7|2C|7|31|3|3A|5|3G|7|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@$A|11|B|12|F|G]|$A|13|B|14|F|G]|$A|15|B|16|F|G]|$A|17|B|18|F|G]|$A|19|B|1A|F|G]|$A|1B|B|1C|F|G]|$A|1D|B|1E|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|1F|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|1G|8|@]|9|@]|C|$M|N]]|$1|O|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

What you're saying is definitely possible with some reflection mojo; with small effort one can write up a generic implementation which would take two distinct classes and try to match fields by name/type and transfer values over each other.
For example <a href="https://stackoverflow.com/questions/3913260/compare-fields-of-two-unrelated-objects">this question</a> have some crude implementation of what you are looking for.

But I think the way you should handle this is through inheritance. If both <code>Car</code> and <code>Train</code> are <code>Vehicle</code>s but they can not be interchanged even though they still have some similarities between them, then you should create a <code>Vehicle</code> implementation which will contain all similarities. Then you can simply extend your <code>Car</code> and <code>Train</code> classes from that common <code>Vehicle</code> implementation.

e.g

<pre><code>class MovingVehicle extends Vehicle //(class which contains similiarities)
class Car extends MovingVehicle
class Train extends MovingVehicle
</code></pre>

blocks|key|587301|text|如果您只想复制公共字段，如果您的对象是bean，请查看杜泽尔。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|587302|Mapper+mapper+=+new+DozerBeanMapper();
Car+car+=+new+Car();
mapper.map(train,+car);|code-block|syntax|javascript|587303|如果您的对象不是bean，那么您必须自己编写映射代码。|587304|PS:的确，“演员”这个词是一个不幸的选择:)|587305|entityMap|0|LINK|mutability|MUTABLE|url|http://dozer.sourceforge.net/documentation/usage.html^0|R|3|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

If you just want to copy over the common fields, and if your objects are beans, look into <a href="http://dozer.sourceforge.net/documentation/usage.html" rel="nofollow">Dozer</a>.

<pre><code>Mapper mapper = new DozerBeanMapper();
Car car = new Car();
mapper.map(train, car);
</code></pre>

If your objects are not beans, then you'll have to write the mapping code yourself.

PS: indeed, the word 'cast' was an unfortunate choice :)

blocks|key|2316595|text|在列车类中创建一个接受车辆作为参数的新构造函数。此构造函数将复制车辆中的所有字段。
//建设者公共列车(V车){+//复制所有公共变量|type|ordered-list-item|depth|inlineStyleRanges|entityRanges|data|2316596|现在可以从现有的Car对象实例化一个列车对象
轿车=新车()；火车列车=新列车(汽车)；|2316597|编辑:按照Turing85的建议将构造函数外包给车辆|unstyled|2316598|在Vehicle类中创建一个接受Vehicle参数的新构造函数。此构造函数将复制车辆中的所有字段。
//构造函数用于Vehicle.java公共车辆(车辆){+//复制所有公共变量|2316599|在火车/汽车类中创建一个新的构造函数，该构造函数接受车辆作为参数并调用super(+Vehicle+)。
//+Car.java公共汽车(车辆){超级(车辆)；}+//用于Train.java公共列车(车辆){超级(车辆)；}|2316600|现在可以通过使用现有对象实例化对象来复制公共字段。
//从现有的汽车目标车existingCar+=新车()；列车列车=新列车(ExistingCar)；//根据现有的列车目标列车existingTrain+=新列车()创建新列车；|2316601|说明：Car+car+=+new+Car(existingTrain);工作是因为汽车构造函数接受车辆对象，而列车是车辆的一种类型。|offset|length|style|CODE|2316602|entityMap^0|0|0|0|0|0|0|3|X|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|10|8|@$O|11|P|12|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|F|7|13|8|@]|9|@]|A|$]]]|T|$]]

<ol>
<li>Create a new constructor in your Train class that accepts a Vehicle as parameter. This constructor will copy all fields present in Vehicle.

<pre><code>// Constructor
public Train(Vehicle v){
 // Copy all common variables here
}
</code></pre></li>
<li>You can now instantiate a Train object from an existing Car object

<pre><code>Car car = new Car();
Train train = new Train(car);
</code></pre></li>
</ol>

<hr>

<h2>Edit: Outsourcing constructor to Vehicle as suggested by Turing85</h2>

<ol>
<li>Create a new constructor in your Vehicle class that accepts a Vehicle as parameter. This constructor will copy all fields present in Vehicle.

<pre><code>// Constructor for Vehicle.java
public Vehicle(Vehicle vehicle){
 // Copy all common variables here
}
</code></pre></li>
<li>Create a new constructor in your Train/Car class that accepts a Vehicle as parameter and call super(vehicle).

<pre><code>// Constructor for Car.java
public Car(Vehicle vehicle){
 super(vehicle);
}

// Constructor for Train.java
public Train(Vehicle vehicle){
 super(vehicle);
}
</code></pre></li>
<li>You can now copy the common fields by instantiating the object with an existing object.

<pre><code>// Creating a new Train from an existing car object
Car existingCar = new Car(); 
Train train = new Train(existingCar);

// Creating a new Car from an existing Train object
Train existingTrain = new Train();
Car car = new Car(existingTrain);
</code></pre></li>
</ol>

Explanation: <code>Car car = new Car(existingTrain);</code> works because the Car constructor accepts a Vehicle object, and a Train is a type of Vehicle.

I have a question.
For example, let's take into consideration two classes:

<pre><code>class Car extends Vehicle
class Train extends Vehicle
</code></pre>

Let's assume that the Vehicle has a lot of fields. 
I want to cast object Car to object Train. They both extends the Vehicle class so they have many fields in common. I don't want to waste time on setting each field. Is there any way in Java (some nice library maybe?) to do it with the least effort?

PS.
Reflection might be the answer, however, if the Vehicle class has many fields of more 'complicated' type it would also take a lot of time.

EDIT:
I want to create an object based on common fields from the other object. Maybe the 'cast' word is wrong. Yes, I know they are different, I just want to copy the common fields. And yes, I know it's a bad design, I just don't have other option, I need to quickly fix sth which was badly written.

How to in a simple way cast one object to another when they both inherit from the same class

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有个问题。例如，让我们考虑两个类：class Car extends Vehicleclass Train extends Vehicle让我们假设车辆有很多字段--。我想把目标车扔到火车上。它们都扩展了Vehicle类，因此它们有许多共同的字段。我不想浪费时间来设置每个字段。在Java中有什么方法(可能是一个很好的...

问如何简单地将一个对象从同一个类继承到另一个对象
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何简单地将一个对象从同一个类继承到另一个对象EN