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;
}
}

Answer 1

嗯，你可以做到：

@array2

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

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

或构图模型：

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

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

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

要将父对象中的所有公共/继承属性复制到子类对象，可以将其静态copyProperties（）方法用作：

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

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

Answer 2

在子构造函数中将'this'更改为'super'，并删除parent参数，而不是用两个参数替换它 int parameter1; // ... int parameter1000; ：）

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

class Child extends Parent
{
    public Child(int parameter1, int parameter1000)
    {
        super.parameter1 = parameter1
        super.parameter1000 = parameter1000;
    }
}

Answer 3

您可以使用json util来执行此操作，例如fastjson。

Child child = JSON.parseObject(JSON.toJSONString(parent), Child.class);

Answer 4

您真的要让父母成为孩子班吗？如果给定的对象（作为父对象）创建为子类，则无需进行强制转换即可访问正确的函数。这是一个例子：在主窗口中，您会看到一个用于存储父对象的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类：关键字抽象强制每个孩子实现该方法，因此，如果您有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
|-lib
  |-Parent.java
  |-C1.java
  |-C2.java

Answer 5

你可以这样做

class how {
    public void data(){
      System.out.println("Im in class");
         }
      }


public class Main  extends how{

    public void method1(){
         System.out.println("Hey implemntation done");
    }



public static void main(String[] args) {
    how h = new Main();
    ((Main)h).method1();
       
    }
 }

我们在这里得到的输出是 Hey implementation done。我们将基类 how 转换为子类 Main 像这样 ((Main)h) 来调用子类 method1

的 Main

加上你只能在父类包含子类对象的引用时对其进行转换

如何在Java中将父级转换为子级

5 个答案: