设计模式：解决某一类问题最行之有效的方法。
java中有23种设计模式：
单例设计模式：解决一个类在内存只存在一个对象。

想要保证对象唯一
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三部怎么用代码体现呢？
1，将构造函数私有化。
2，在类中创建一个本类对象。
3，提供一个方法可以获取到该对象。

对于事物该怎么描述，还怎么描述。
当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。

单例模式，保证在内存中的唯一性

1.        class Student  
2.        {  
3.                 private int age;  
4.          
5.                 private static Student s = new Student();  
6.                 private Student(){}  
7.                 public static Student getStudent()  
8.                 {  
9.                           return s;  
10.                 }  
11.          
12.                 public void setAge(int age)  
13.                 {  
14.                           this.age= age;  
15.                 }  
16.                 public int getAge()  
17.                 {  
18.                           return age;  
19.                 }  
20.        }  
21.          
22.        class SingleDemo  
23.        {  
24.                 public static void main(String[] args)  
25.                 {  
26.                           Single s1 = Single.getInstance();//静态方法可以直接调用  
27.                           Single s2 = Single.getInstance();  
28.          
29.                           s1.setNum(23);  
30.          
31.                           System.out.println(s2.getNum());  
32.                  
33.        //               Single s1 = new Single();  
34.        //               Single s2= new Single();  
35.        //               s1.setNum(30);  
36.        //               System.out.println(s2.getNum());  
37.          
38.        //               Student s1 = new Student();  
39.        //               s1.setAge(30);  
40.        //  
41.        //               Student s2 = new Student();  
42.        //               s2.setAge(12);  
43.          
44.                           Students1 = Student.getStudent();  
45.                           Students2 = Student.getStudent();  
46.                 }  
47.        }  

单例饿汉式和懒汉式

1.        /*
2.        饿汉式:先初始化对象
3.        Single类一进内存，就已经创建好了对象。
4.          
5.        */  
6.        class Single  
7.        {  
8.                 private static Single s = new Single();  
9.                 private Single(){}  
10.                 public static Single getInstance()  
11.                 {  
12.                           return s;  
13.                 }  
14.        }  
15.          

1.        /*
2.        懒汉式:
3.        对象是方法被调用时，才初始化，也叫做对象的延时加载。
4.        Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
5.        */  
6.        class Single  
7.        {  
8.                 private static Single s = null;  
9.                 private Single(){}  
10.                 public static Single getInstance()  
11.                 {  
12.                           if(s==null)  
13.                           {  
14.                                    synchronized(Single.class)  
15.                                    {                                    
16.                                             if(s==null)  
17.                                                       s= new Single();  
18.                                    }  
19.                           }  
20.                           return s;  
21.                 }   
22.        }  
23.          
24.        //记录原则：定义单例，建议使用饿汉式。  

谢谢楼主的总结，非常到位！