blocks|key|796365|text|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())
++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|796366|这是我能想到的最简单的方法。你也许可以在父类中使用一些java反射API来做这件事(所以询问'this‘引用它是什么类，并构造一个该类型的新类。然而，它可能不会工作，这取决于java构造函数的工作方式。在C%2B%2B中，构造函数中的“this”指针与构造函数类的类型相同)|unstyled|796367|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>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())
 }
}
</code></pre>

Here's the simplest way I can think of. You could probably do it in the parent class using some of the java reflection API though (so ask the 'this' reference what class it is and construct a new class of that type. It may not work depending on how java constructors work though. In C++, the 'this' pointer in a constructor is of the same type as the constructors class)

blocks|key|796389|text|如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|796390|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());
++++}
}|code-block|syntax|javascript|796391|这个函数与默认构造函数一起工作，如果你想用非默认构造函数构造一个新的对等体，就会涉及到更多的技巧。请参阅类的javadoc。|796392|Edit:修复无限递归:)|796393|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Something like this:

<pre><code>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());
 }
}
</code></pre>

This one works with default constructor, there's a bit more trickery involved if you want to construct a new peer with a non-default constructor. See The javadoc for Class.

Edit: fixed the infinite recursion :)

blocks|key|796411|text|我不确定是否有可能在不陷入循环的情况下做到这一点。我确信，使用工厂方法而不是构造函数来编写它会更清晰。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|796412|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I'm not sure if it is possible to do this without running into cycles. I am convinced that it would be a lot clearer to write this using factory methods instead of constructors.

blocks|key|796432|text|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+{+}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|796433|看起来代码可能更简单。|unstyled|796434|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>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 &lt;T extends Parent&gt; T getPeer() {
 return (T)peer;
 }
}

public class Child01 extends Parent { }

public class Child02 extends Parent { }
</code></pre>

It seems that the code may be more simple.

blocks|key|1260504|text|请注意，如果父类中没有访问器，则无法获取对等对象(不能实例化父对象)，因此此设计仅作为概念证明才有意义。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1260505|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Note that without an accessor in the parent class you cannot get the peer object (you cannot instantiate Parent), so this design only makes sense as concept proof.

blocks|key|4015399|text|我首先要说的是，我认为这可能是一个非常糟糕的设计。类名也很糟糕，但我将继续使用它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4015400|然而，处理它的一种方法是：|4015401|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);
++++}+++
}|code-block|syntax|javascript|4015402|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I'll start by saying that I think it's probably a really bad design. And the class names are also bad, but I'll stick with them.

However, one way of dealing with it:

<pre><code>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);
 } 
}
</code></pre>

blocks|key|796559|text|我建议用工厂模式来代替这整个事情，在工厂模式中，你可以完全控制添加了什么，而不需要在构造器中做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|796560|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I would suggest replacing this whole thing with a Factory pattern, where you have complete control over what gets a peer added and you don't have to do it in the constructor.

blocks|key|796564|text|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+{+}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|796565|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>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 &lt;T extends Parent&gt; T getPeer() {
 return (T)peer;
}

public class Child01 extends Parent { }

public class Child02 extends Parent { }
</code></pre>

blocks|key|1260577|text|回复Leonid+Kuskov的答案|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1260578|您的示例2将始终抛出StackOverflowException。我摆弄了一下代码，下面是它的正确实现。不过，还是要感谢你在这方面给我指点迷津。|1260579|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)+{
++++}
}|code-block|syntax|javascript|1260580|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/110046/leonid-kuskov^0|2|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Replying for answer of <a href="https://stackoverflow.com/users/110046/leonid-kuskov">Leonid Kuskov</a>

Your example 2 will always throw a StackOverflowException. I fiddled around with the code a bit an below is the correct implementation for that. Though thanks to you to give me pointers in that direction.

<pre><code>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) {
 }
}
</code></pre>

<pre><code>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 {

}
</code></pre>

When I construct an instance of Child1, I want a "peer" to automatically be constructed which is also of type Child1, and be stored in the peer property. Likewise for Child2, with a peer of type Child2.

The problem is, on the assignment of the peer property in the parent class. I can't construct a new Child class by calling <code>new Child1()</code> because then it wouldn't work for Child2. How can I do this? Is there a keyword that I can use that would refer to the child class? Something like <code>new self()</code>?

Call subclass constructor from abstract class in Java

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

public abstract class Parent {    private Parent peer;    public Parent() {        peer = new ??????("to call overloaded constructor");    }    public Parent(St...

问在Java中从抽象类调用子类构造函数
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中从抽象类调用子类构造函数EN