单例设计模式

1. 设计模式介绍与代码编写

    在编写程序时经常会遇到一些典型的问题或需要完成某种特定需求.设计模式就是针对这些问题和需求.在大量的实践中总结和理论化之后的代码结构.编程风格以及解决问题的思考方式.设计模式就像经典的棋局. 不同的棋谱,我们用不同的棋局.免得自己再去思考和摸索.

单例模式是Java中的一种设计模式,它是指在设计一个类时,需要保证在整个程序运行期间针对该类只存在一个实例对象. 作用: 限制对象的创建.

 

 

问题1 : 对象中到底有什么 ?  属性(存储数据) , 行为(操作数据).

问题2 : 程序中为什么要限定的对象的创建呢 ?

 

 

1. class SingleDemo
2. {
3.        public static void main(String[] args)
4.        {
5.               Singleton s1 = Singleton.getInstance();
6.               Singleton s2 = Singleton.getInstance();
7.               boolean result = s1 == s2;
8.               System.out.println("result="+result);
9.  
10.               /*
11.               Singleton s1 = new Singleton();
12.               Singleton s2 = new Singleton();
13.               boolean result = s1 == s2;
14.               System.out.println("result="+result);
15.               */
16.        }
17. }
18.  
19. // 定义一个单例类
20. class Singleton
21. {
22.        // 1. 自己创建一个对象
23.        // 静态变量特点: 内存中仅有一份,能够被该类的所有实例对象所共享.
24.        private static Singleton INSTANCE = new Single();
25.        // 2. 构造方法 (私有化)
26.        private Singleton()
27.        {
28.       
29.        }
30.        // 3. 提供一个返回该对象的静态方法
31.        public static Singleton getInstance()
32.        {
33.               return INSTANCE; // 返回自己在本类中创建好的实例对象
34.        }
35. }

 

 从运行结果可以看出.变量 s1 和 s2 值相等.这说明变量 s1 和 s2 引用同一个对象.也就是说两次调用 getInstance() 方法获得的是同一个对象.而 getInstance() 方法是获得 Single 实例对象的唯一途径.因此 Single 类是一个单例的类.

 

 

2. 单例设计模式具备如下特点 :

1. 类中的构造方法使用 private 关键字修饰,声明为私有.这样就不能在类的外部使用 new 关键字来创建实例对象了.

1. 在类的内部创建一个该类的实例对象,并使用静态变量 INSTANCE 引用该对象,由于变量应该禁止外界直接访问,因此使用 private 修饰.声明为私有成员.
2. 为了让类的外部能够获取类的实例对象,需要定义个静态方法 getInstance (); 用于返回该类实例 INSTANCE, 由于方法是静态的.外界可以通过 "类名.方法名();" 的方法来访问. -> Single.getInstance();

 

 

3. 多学一招 : final单例 :

 

特点: 单例实现的两步曲.

 

单例模式也可以写成如下形式 : 使用 final 修饰可以实现. 但是如果提供一个公共方法,那么方法内部还可以做一些逻辑判断.

 

1. /*
2.        多学一招 : 两步实现单例设计模式
3.        1. 私有化构造方法
4.        2. 在本类的内部创建一个对象,使用public修饰,并静态化该变量,
5.           并需要使用 final 关键字对INSTANCE变量进行最终化,表示该变量不能够再次被修改.
6. */
7. class Demo
8. {
9.        public static void main(String[] args)
10.        {
11.               // 根据Single类创建对象
12.               Singleton s1 = Singleton.INSTANCE;
13.               Singleton s2 = Singleton.INSTANCE;
14.               Singleton s3 = Singleton.INSTANCE;
15.               Singleton s4 = Singleton.INSTANCE;
16.  
17.               // error: cannot assign a value to final variable INSTANCE
18.               // 如果Single类的INSTANCE属性使用final进行,下一句代码将报语法错误!
19.               Singleton.INSTANCE = null;
20.  
21.               boolean result = s1 == s2;
22.               System.out.println("result="+result);
23.               boolean result2 = s3 == s4;
24.               System.out.println("result2="+result2);
25.  
26.               // Java中规定,不能对空对象进行操作.
27.               // NullPointerException
28.               Singleton s5 = Singleton.INSTANCE;
29.               s5.show();
30.        }
31. }
32.  
33. // 设计一个 `单例类`
34. class Singleton
35. {
36.        // 属性
37.        private Singleton () {}
38.  
39.        public static final Singleton INSTANCE = new Singleton ();
40.  
41.        public void show()
42.        {
43.               System.out.println("show...");
44.        }
45. }

 

 

1. 懒汉式和饿汉式单例

饿汉式单例 :

特点: 不管你单例对象什么时候用,类一加载,我就直接在堆区中先来创建这个单例对象.

1. class Demo
2. {
3.        public static void main(String[] args)
4.        {
5.               Singleton s1 = Singleton.getInstance();
6.               Singleton s2 = Singleton.getInstance();
7.               System.out.println(s1 == s2);
8.        }
9. }
10.  
11. class Singleton
12. {
13.        // 1. 创建一个本类的对象
14.        private static Singleton INSTANCE = new Singleton (); // 静态成员变量,跟随类的加载而加载. 该对象在类加载的时候就被创建完成了.
15.        // 2. 私有化构造方法
16.        private Singleton () {}
17.        // 3. 提供一个共有方法来返回该类的对象
18.        public static Singleton getInstance()
19.        {
20.               return INSTANCE;
21.        }
22. }

 

懒汉式单例 :

  特点: 在类加载的时候,不会在堆区中创建单例对象.

1. class Demo
2. {
3.        public static void main(String[] args)
4.        {
5.               Singleton s1 = Singleton.getInstance();
6.               Singleton s2 = Singleton.getInstance();
7.               System.out.println(s1 == s2);
8.        }
9. }
10.  
11. class Singleton
12. {
13.        // 1. 创建一个本类的对象
14.        private static Singleton INSTANCE = null; // 类加载的时候不创建对象.
15.        // 2. 私有化构造方法
16.        private Singleton () {}
17.        // 3. 提供一个共有方法来返回该类的对象
18.        public static Singleton getInstance()
19.        {
20.               if (INSTANCE == null)
21.               {
22.                     INSTANCE = new Singleton ();
23.               }
24.               return INSTANCE;
25.        }
26. }

 

特点 : 单例对象什么时候用,我就什么时候来创建.

假设main方法有1000行代码,如果在第800行代码(getInstance())用到了单例,此时前800行代码运行时,不会在堆区中创建单例对象,但是当运行到第800行代码时,才会开始在堆区中来创建单例对象.