java类中包含类⾃⾝的变量_java-类如何具有⾃⼰的类型的成
员，这不是⽆限递归吗？...
java-类如何具有⾃⼰的类型的成员，这不是⽆限递归吗？
假设我定义了⼀个类，该类具有与⾃⼰相同类型的变量作为成员。
public class abc {
private abc p;
}
这实际上有效，令我惊讶的是。
为什么我不应该这样：创建⼀个abc实例，它包含abc类型的变量，其中包含abc类型的变量，其中包含abc类型的变量，...
显然我错了，有⼈可以启发我吗？
jason asked 2020-08-06T16:32:29Z
7个解决⽅案
36 votes
您仅声明变量⽽不创建它。 尝试在声明或构造函数中创建它，让我知道会发⽣什么：
public class Abc {
private Abc p = new Abc(); // have fun!
public static void main(String[] args) {
new Abc();
}
}
顺便说⼀句，如果您不是在类中创建它，⽽是在getter⽅法或构造函数参数中接受对它的引⽤，则您的代码将正常⼯作。 这就是某些链接列表的⼯作⽅式。
Hovercraft Full Of Eels answered 2020-08-06T16:32:39Z
20 votes
区别在于编译时检查与运⾏时检查。
在第⼀种情况(编译时)中，您声明在这种情况下将引⽤类型为2999663452953753773056的值。 编译器在检查适当的语义时将意识到这⼀点，并且由于它在编译时就知道类型，因此认为没有问题。
在第⼆种情况下(运⾏时)，您实际上将创建⼀个值供此引⽤引⽤。 在这⾥您可能会遇到⿇烦。 例如，如果您说以下：
public class abc {
private abc p;
public abc() {
p = new abc();
}
}
这可能会因所引⽤的确切原因⽽给您带来⿇烦(递归不包含任何基本情况，并且会不断分配内存，直到将VM⽤完堆空间为⽌)。
但是，您仍然可以执⾏类似的操作并避免⽆限递归。 通过避免在构造过程中创建值，可以推迟使⽤它，直到需要使⽤⽅法为⽌。 实际上，这是在Java中实现单例模式的常见⽅法之⼀。 例如：
public class abc {
private abc p;
private abc() { // Private construction. Use singleton method
}
public static synchronized abc getInstance() {
if (p == null)
p = new abc();
return p;
}
}
这是完全有效的，因为您只创建了⼀个新的值实例，并且由于运⾏时已经加载了该类，因此它将知道实例变量的类型是有效的。
pseudoramble answered 2020-08-06T16:33:22Z
10 votes
当您要对⼀些实际场景进⾏建模时，可能必须使⽤此概念。 例如，考虑⼀棵树的分⽀。 ⼀棵树的分⽀上可能有n个分⽀。 或从计算机科学背景出发，想到⼀个链表的Node。 节点将引⽤其旁边的节点。 最后，下⼀个将包含⼀个空值，以指⽰列表的结尾。
因此，这仅是参考，表明此类型可能引⽤其⾃⾝的⼀种。 ⽽已。
ring bearer answered 2020-08-06T16:33:47Z
1 votes
在这⾥总结⼀些答案。
该类包含对⾃⼰的同类的引⽤。现实世界中最好的类⽐是寻宝。 ⼀个线索位置中包含⼀些数据和⼀个线索，这会导致另⼀个线索位置，您再次知道重复该线索位置。
并不是说⼀个线索位置中有另⼀个线索位置，您似乎可以推断出那种线索位置。
Rakesh Horkeri answered 2020-08-06T16:34:17Z
1 votes
如选择的答案所述，这是可以的，因为没有实例化变量，⽽是接受了set⽅法或构造函数参数的引⽤。 因此，您看到的只是参考，只是地址。
但是，有⼀种实例化它的⽅法⽽不会引起噩梦循环，那就是将其声明为静态。 由于静态成员不在对象级别⽽是在类级别，因此这种弯曲了递归规则。
所以...
public class abc
{
public static abc p = new abc ();
}
之所以可以正常⼯作，是因为变量“ p”实际上不受abc类的实例影响。 这⼏乎等同于在另⼀个类中创建“ p”对象。
请记住，我可以这样做...
public class abc
{
public static abc p = new abc ();
java类的概念public static void main(String [] args)
{
abc.p;
}
}
在main⽅法中不创建abc的新对象。 静态就是这样⼯作的，它们⼏乎不受对象实例化的影响，在您的问题中，它们是递归规则的例外。
WTRIX answered 2020-08-06T16:35:00Z
1 votes
它的基本⽤法可以是数据结构中的链接列表。 它是链接列表中的核⼼概念，是从⼀个节点到另⼀节点的引⽤。 类Node由链接列表的基本元素组成。
class Node{
private int value;
private Node next; //reference, as a pointer to another node, →
Node(){
this.value=0;
<=null;
}
Node(int value){
this.value=value;
<=null;
}
Node(int value,Node next){
this.value=value;
<=next;
}
public int getValue() {
return this.value;
}
public void setValue(int value) {
this.value=value;
}
public Node getNext() {
;
}
public void setNext(Node next) {
<=next;
}
}
我们可以使⽤参考来连接这些节点。
class Linkedlist{
Node head = new Node();
Node one = new Node();
Node two = new Node();
// Assign data values
one.value = 1;
two.value = 2;
// Connect nodes
< = two;
< = NULL;
//Save address of first node in head
head = one;
}
头→1个下⼀个→2个下⼀个→NULL
因此，这只是在链接列表的数据结构中将⼀个节点连接到另⼀个节点的引⽤类型。
LEO CHEN answered 2020-08-06T16:35:33Z
0 votes
当我们谈论“递归”时，代码的“执⾏”是我们考虑的重点。 是的，如果发⽣“递归”，则它是“动态的”。
在类型声明中，包含成员的变量(即包含变量的类型)为“静态”。 例如，⼀个盒⼦可能在其中包含另⼀个
盒⼦，依此类推。 但最后有⼀个最⼩的盒⼦，⾥⾯什么也不装。 对于⼀连串的铁路车厢，除最后⼀个车厢外，每个车厢都有⼀个成员。
在程序中，静态数据必须是“有限的”(您没有“⽆限”的存储空间)。 代码的执⾏可以是“⽆限的”。 但是有⼀个例外。 只是想像⼀个链环。
Mike Lue answered 2020-08-06T16:36:03Z

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。