Question

我有一个问题是为了更好地理解Java中的Singleton模式。特别是，我对私有静态变量感兴趣，私有静态变量是静态变量的类的实例。我的问题是要了解当您使用私有构造函数实例化该静态变量时会发生什么。该对象是一个类的实例，它的实例变量是，但这意味着该对象内部是该类的另一个实例，其中是另一个实例，等等。为了测试它，我编写了下一个代码：

public class SingletonTest {
private static SingletonTest s=new SingletonTest();
int x=0;

private SingletonTest(){}


public static void increase(int y){
    s.x=s.x+y;
}


public static void main(String [] args){

    SingletonTest.increase(5);
    System.out.println(SingletonTest.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.x);

}
}

它打印出5.这意味着对象内部有对象，因为有SingletonTest.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.s.x变量及其值。任何澄清行

时实际发生的事情

private static SingletonTest s=new SingletonTest();

执行了吗？对象内部创建了多少个对象？它应该是无限的，但这是不可能的。由于上层代码必须有多个.Singleton应该只产生一个对象，但事实并非如此，因为在每个实例中都是另一个。为什么这个代码只在s.x增加时产生输出5，而不是s.s.s .... s.x？对象内的每个对象都应该有自己的x。感谢您对此事的任何澄清。

Answer 1

你定义了这个：

private static SingletonTest s=new SingletonTest();

这是一个静态对象，只会创建一次，所以当你做

时

SingletonTest.s.s.s.s.s.s....您正在遍历 SingletonTest 的静态实例，但该对象本身只创建了一次。

Answer 2

试图澄清......你一遍又一遍地访问同一个实例。类似的情况（为简单起见，不使用静态成员）是这样的：

class Recursive {
    public Recursive me;
    private String message = "sayHello";

    public Recursive() {
        me = this;
    }

    public void sayHello() {
        System.out.println(message);
    }

}

Recursive对象为自己保留了一个引用。我可以反复调用 me ，但只有一个实例：

Recursive rec = new Recursive();
rec.me.me.me.me.me.sayHello();

Answer 3

感谢您的回答，但是，您的回答并没有涵盖我试图提出的内容......在我的行中，构造函数在同一行中被调用，其中定义了实例变量... 你的代码避免了...... 代码：

public class RekurzivTester {
public  RekurzivTester r=new RekurzivTester();
private RekurzivTester(){}
    public static void main(String[] args) {
        RekurzivTester rek=new RekurzivTester();
}
}

产生堆栈溢出错误。我的解释是因为当main（）中的新对象被生成时，触发了对象内部对象的无限链，但是如果向第二行添加静态，则不会再出现堆栈溢出错误。解释是每个类只有一个对象可以用rek.r，rek.rr等访问，但是，因为语句rek.rrrrrr ...有意义，它意味着里面还有r另一个r里面其中是另一个等等（到无穷大），但它们都访问同类对象，这是同类的。我是对的吗？

单身澄清

3 个答案: