从Java中的抽象类调用子类构造函数

Question

public abstract class Parent {

    private Parent peer;

    public Parent() {
        peer = new ??????("to call overloaded constructor");
    }

    public Parent(String someString) {
    }

}

public class Child1 extends parent {

}

public class Child2 extends parent {

}

当我构造 Child1 的实例时，我希望自动构造一个也是 Child1 类型的“对等体”，并将其存储在对等属性中。对于 Child2 也是如此，具有 Child2 类型的对等体。

问题在于，在父类中对等属性的赋值。我不能通过调用new Child1() 来构造一个新的 Child 类，因为这样它就不适用于 Child2。我怎样才能做到这一点？有没有我可以使用的关键字来引用子类？ new self() 之类的东西？

Answer 1

我不确定是否可以在不陷入循环的情况下执行此操作。我相信使用工厂方法而不是构造函数来编写它会更清晰。

Answer 2

public abstract class Parent implements Clonable{

  private Object peer;

  // Example 1 
  public Parent() {
    try {
      peer = this.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
  }

  // Example 2
  public Parent(String name) {
    try {
      peer = this.getClass().getConstructor(String.class).newInstance(name);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  } 

  public <T extends Parent> T getPeer() {
    return (T)peer;
  }
}

public class Child01 extends Parent { }

public class Child02 extends Parent { }

看来代码可能更简单。

Answer 3

我首先要说我认为这可能是一个非常糟糕的设计。而且类名也不好，但我会坚持下去。

但是，一种处理方式：

public abstract class Parent {
    interface PeerFactory {
        Parent create(Parent peer);
    }
    private final Parent peer;

    protected Parent(Parent peer) {
        super();
        this.peer = peer;
    }
    protected Parent(PeerFactory peerFactory) {
        super();
        this.peer = peerFactory.create(this);
    }
}

public class Child1 extends parent {
    private static final PeerFactory peerFactory = new PeerFactory {
        public Parent create(Parent peer) {
            return new Child1(peer);
         }
    };
    public Child1() {
        super(peerFactory);
    } 
    private Child1(Peer peer) {
        super(peer);
    }   
}

Answer 4

类似这样的：

public class Peer {
    public static abstract class Parent {
            private Parent peer;

            protected Parent(boolean needPeer) {
                    if (needPeer) {
                            try {
                                    peer = getClass().newInstance();
                            }
                            catch (Throwable e) {
                                    System.err.println(e);
                            }
                    }
            }

            public String getPeerClass() {
                    return peer.getClass().toString();
            }
    }

    public static class Child1 extends Parent {
            public Child1() {
                    this(false);
            }
            public Child1(boolean needPeer) {
                    super(needPeer);
            }
    }

    public static class Child2 extends Parent {
            public Child2() {
                    this(false);
            }
            public Child2(boolean needPeer) {
                    super(needPeer);
            }
    }

    public static void main(String[] args) {
            Parent p1 = new Child1(true);
            Parent p2 = new Child2(true);

            System.out.println(p1.getPeerClass());
            System.out.println(p2.getPeerClass());
    }
}

这适用于默认构造函数，如果您想使用非默认构造函数构造一个新的对等点，则涉及更多技巧。请参阅 Class 的 javadoc。

编辑：修复了无限递归:)

Answer 5

请注意，如果没有父类中的访问器，您将无法获取对等对象（您无法实例化 Parent），因此这种设计仅作为概念证明才有意义。

Answer 6

我建议用工厂模式替换整个事情，在这种模式下，您可以完全控制添加对等点的内容，而不必在构造函数中进行。

Answer 7

回复Leonid Kuskov的回复

您的示例 2 将始终抛出 StackOverflowException。我稍微摆弄了一下代码，下面是正确的实现。虽然感谢你在那个方向给我指点。

public class AbstractClassDemo {

    public static void main(String[] args) {
        Child1 c1 = new Child1();
        System.out.println(c1.getPeer().getClass().getName());
    }

}

abstract class Parent {
    private Object peer;

    public Parent() {

    }

    public Parent(String s) {
        try {
            setPeer(this.getClass().getConstructor(String.class)
                    .newInstance(""));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Object getPeer() {
        return peer;
    }

    public void setPeer(Object peer) {
        this.peer = peer;
    }
}

class Child1 extends Parent implements Cloneable {
    public Child1() {
        super("Child1");
    }

    public Child1(String child1) {
    }
}

class Child2 extends Parent implements Cloneable {
    public Child2() {
        super("Child2");
    }

    public Child2(String child2) {
    }
}

Answer 8

public abstract class Parent implements Clonable {
  private Object peer;

  // Example 1 
  public Parent() {
    try {
      peer = this.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
  }

  // Example 2
  public Parent(String name) {
    try {
      peer = this.getClass().getConstructor(String.class).newInstance(name);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

} 

public <T extends Parent> T getPeer() {
 return (T)peer;
}

public class Child01 extends Parent { }

public class Child02 extends Parent { }

Answer 9

public abstract class Parent {

    private Parent peer;

    public Parent(Parent peer) {
        this.peer = peer;
    }

    public Parent(String someString) {
    }

}

public class Child1 extends parent {
    public Child1() {
        super(new Child1())
    }
}

public class Child2 extends parent {
    public Child2() {
        super(new Child2())
    }
}

这是我能想到的最简单的方法。不过，您可能可以使用一些 java 反射 API 在父类中执行此操作（所以询问“this”引用它是什么类并构造该类型的新类。它可能无法工作，具体取决于 java 构造函数的工作方式。在 C++ 中，构造函数中的“this”指针与构造函数类的类型相同）