1. class Single
   
2. {  private int num;
   
3.         public void setNum(int num)
   
4.         {        this.num=num;
   
5.         }
   
6.         public int getNum()
   
7.         {
   
8.                 return num;
   
9.         }
   
10.          Single(){}
    
11.         private static Single s =new Single();
    
12. }
    
13. class SingleDemo
    
14. {
    
15.         public static void main (String[]args)
    
16.         {
    
17.         Single s1=new Single();
    
18.         Single s2=new Single();
    
19.         s1.setNum(30);
    
20.         System.out.println(s2.getNum());
    
21.         }
    
22. }
    
23. 
    

复制代码

请问 类中有private static Single s =new Single();的语句，请问这个s是在方法区还是堆内存中？ 这个程序总共创建了几个对象？谁介绍下创建的几个对象的先后顺序，说下创建这几个对象的先后步骤

首先，Single类中，虽然有private static Single s =new Single();这句代码，但因为构造
方法没有私有化，外界依然可以创建对象（如下面的s1和s2）。s是Single类中的一个静态成员，
随着类的加载而加载，存在于方法区中，不依赖外界创建的对象。
s1和s2是通过类的构造方法在类外部创建的对象，他们是相互独立的，修改了s1的num值，不会影响
到s2，所有s2的num值依然是默认初始化值0。
这个程序一共创建了3个对象。首先，Single类一加载，s对象就存在了（为方便理解，可以将s看做
Single类的一个静态属性）。然后在运行SingleDemo的main方法时，又创建了两个对象s1和s2。基本步骤
就是这样的。

3个对象，因为你构造函数没有私有，可以创建实例的，你NEW几个就创建几个，
而且在类加载的时候就创建了一个对象。
创建顺序  S   S1 S2

补充一点，该例可以说是一个“伪单例”程序，看似在内部创建了对象，并用静态修饰。但由于没有将构造方法私有化，外界依然可以创建对象。
实现单例必须要满足：
1. 构造方法私有化
2. 内部创建静态的对象
3.对外提供获取该对象的方法。

创建了四个Single对象  private static Single s =new Single()  这个s是静态的 存在于方法区内 因为是静态的 所以初始化的顺序比构造函数早  
Single s1=new Single();  这句话执行的时候就创建了s1的成员属性 s 并创建了一个Single对象给它  然后再执行构造函数

对了对了    private static Single s =new Single() 这个是静态的  只加载一次  所以是 三次 不是四次

要想只有一个对象，首先要把Single的构造方法写成private的。
然后写一个返回Single对象的方法。
如：class Single {
        private Single() {

        }

        private static Single s = new Single();

        public static Single getInstance() {
                return s;
        }

        public void out() {
                System.out.println("SingleDemo");
        }
}
这样就只能生成一个对象。

应该是3个对象吧