如何在 Java 中将父对象转换为子对象

Question

我这样做：

 Child child = (Child)parent;

这给了我一个错误，我发现不可能这样做。我不知道为什么，但我认为这应该是可能的，如果 Child 类继承自 Parent 类，它包含 Parent

我的问题是：

• 为什么它不起作用？

• 我怎样才能完成这项工作，而不像这样设置每个父母的属性

:

 class Parent{
    public int parameter1;//...
    public int parameter1000;
}

class Child extends Parent
{
    public Child(Parent parent)
{
        this.parameter1 = parent.parameter1;//...
        this.parameter1000 = parent.parameter1000;
}
}

原文由 likaa 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

那么你可以这样做：

 Parent p = new Child();
// do whatever
Child c = (Child)p;

或者，如果您必须从一个纯 Parent 对象开始，您可以考虑在您的父类中有一个构造函数并调用：

 class Child{
    public Child(Parent p){
        super(p);
    }
}
class Parent{
    public Parent(Args...){
        //set params
    }
}

或组成模型：

 class Child {
    Parent p;
    int param1;
    int param2;
}

在这种情况下，您可以直接设置父级。

您还可以使用 Apache Commons BeanUtils 来执行此操作。使用它的 BeanUtils 类，您可以访问许多用于通过反射填充 JavaBeans 属性的实用方法。

要将所有公共/继承的属性从父对象复制到子类对象，您可以使用其静态 copyProperties() 方法，如下所示：

 BeanUtils.copyProperties(parentObj,childObject);

但是请注意，这是一项繁重的操作。

原文由 Akash Roy Choudhury 发布，翻译遵循 CC BY-SA 3.0 许可协议

Answer 2

你真的想让你的父母进入孩子班级吗？如果给定的对象（作为父对象给出）是作为子类创建的，则无需强制转换即可访问正确的函数。这是一个示例：在主体中，您会看到一个 Vector ‘ps’ 来存储父对象，但添加的是从父对象扩展的子对象。在遍历该向量时，我不知道接下来会得到哪种子对象（因此我无法转换为正确的类），但是由于我调用的函数的关键字 Override ，所以使用了正确的子对象/方法。

 import java.util.Vector;
import lib.Parent;
import lib.C1;
import lib.C2;

public class MyClass {
    public static void main(String []args){
        System.out.println("Hello World");
        C1 c1 = new C1();
        C2 c2 = new C2();

        ps.add(c1);
        ps.add(c2);

        for(int k = 0; k < ps.size(); k++){
            ps.get(k).setInteger(); // no cast needed
            System.out.println("stored entity " + ps.get(k).i);
        }
        // or use a ranged for loop
        for(Parent p: ps){
            p.setInteger();
            System.out.println("stored entity " + p.i);
        }
    }

    static Vector<Parent> ps = new Vector<>();
}

Parent 类：关键字 abstract 强制每个子对象实现那个方法，所以如果你有一个 Parent 对象，你可以安全地调用这个方法。由于 Parent 类本身是抽象的，因此您不会有一个只是 Parent 对象的对象，因为这是不允许的，也不会编译。

 package lib;
public abstract class Parent{
    public Integer i;

    public abstract void setInteger();
}

这里有两个子类，它们具有不同的 setInteger() 方法实现。

 package lib;
import lib.Parent;

public class C1 extends Parent{

    @Override
    public void setInteger(){
        i = new Integer(1);
    }
}

第二个孩子：

 package lib;
import lib.Parent;

public class C2 extends Parent{

    @Override
    public void setInteger(){
        i = new Integer(2);
    }
}

输出是

stored entity 1
stored entity 2
stored entity 1  <-- ranged for
stored entity 2  <-- ranged for

编辑：文件结构看起来像这样

|-MyClass.java
|-库
  |-Parent.java
  |-C1.java
  |-C2.java

原文由 Jakobimatrix 发布，翻译遵循 CC BY-SA 4.0 许可协议