单例设计模式

一：单例设计模式的定义

单例设计模式，顾名思义，就是在整个程序运行过程中，只向外界提供一个对象，这样做可以避免资源的浪费，例如

我们打开回收站或者ppt时，只会启动一个窗口。

单例模式的java实现：

1：饿汉式

 1 /**
 2  *
 3  */
 4 package com.hlcui.singleton;
 5
 6 /**
 7  * @author Administrator 饿汉式单例类
 8  */
 9 public class SingletonDemo {
10     // 1:内部创建一个对象
11     private static SingletonDemo single = new SingletonDemo();
12
13     // 2:私有化构造方法
14     private SingletonDemo() {
15
16     }
17
18     // 3:对外界提供一个方法，获取SingletonDemo对象
19     public static SingletonDemo getInstance() {
20         return single;
21     }
22 }

2：懒汉式

 1 /**
 2  *
 3  */
 4 package com.hlcui.singleton;
 5
 6 /**
 7  * @author Administrator 懒汉式单例类
 8  *
 9  */
10 public class SingletonDemo2 {
11     // 1:内部创建对象的引用
12     private static SingletonDemo2 single;
13
14     // 2:私有化构造方法
15     private SingletonDemo2() {
16
17     }
18
19     // 3:对外提供一个方法，获取对象，只是要进行判断
20     public static SingletonDemo2 getInstance() {
21         if (single == null) {
22             single = new SingletonDemo2();
23         }
24         return single;
25     }
26 }

3:懒汉式与饿汉式比较

两种不同实现方式的区别：

<1> 从资源利用的角度看，懒汉式是在调用其静态方法的时候才被实例化的，所以要比饿汉式稍好一些。

<2> 从反映时间和速度上看，饿汉式在类加载的时候就得到了初始化，所以要比懒汉式好一些。

由上可见，创建一个单子类必须满足以下三个条件:

1.构造器私有

2.自己持有自身的一个静态引用

3.对外面系统提供访问唯一实例的公共静态接口(方法).

二：案例分析

1：单例代码

 1 /**
 2  *
 3  */
 4 package com.hlcui.singleton;
 5
 6 import java.awt.Rectangle;
 7 import java.awt.event.ActionEvent;
 8 import java.awt.event.ActionListener;
 9
10 import javax.swing.JButton;
11 import javax.swing.JFrame;
12 import javax.swing.JLabel;
13
14 /**
15  * @author Administrator
16  *
17  */
18 public class DemoSingleton extends JFrame {
19     /**
20      *
21      */
22     private static final long serialVersionUID = 1L;
23     // 一个私有的,静态的本类对象
24     private static DemoSingleton testFrame = new DemoSingleton();
25     JLabel jLMes = new JLabel();
26
27     // 构造必须是私有的,这样其它的类才不能访问
28     private DemoSingleton() {
29         getContentPane().setLayout(null);
30         this.getContentPane().add(jLMes);
31         this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
32         jLMes.setText("这是产生的唯一窗体");
33         jLMes.setBounds(new Rectangle(103, 53, 230, 96));
34     }
35
36     // 公有的静态方法返回一个本类对象
37     public static synchronized DemoSingleton getInstance() {
38         return testFrame;
39     }
40
41 }

2：测试代码

 1 /**
 2  *
 3  */
 4 package com.hlcui.singleton;
 5
 6 import java.awt.Rectangle;
 7 import java.awt.event.ActionEvent;
 8 import java.awt.event.ActionListener;
 9
10 import javax.swing.JButton;
11 import javax.swing.JFrame;
12
13 /**
14  * @author Administrator
15  *
16  */
17 class Test extends JFrame {
18        JButton jBtn = new JButton();
19
20        public Test() {
21           getContentPane().setLayout(null);
22           jBtn.setBounds(new Rectangle(125, 182, 168, 43));
23           jBtn.setText("单击产生唯一窗体");
24
25           this.jBtn.addActionListener(new MyActionListener());
26           this.getContentPane().add(jBtn);
27           this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
28           this.setSize(500, 300);
29           this.setVisible(true);
30        }
31
32        class MyActionListener implements ActionListener {
33           // 单击按钮时调用单子模式类的静态方法,获得一个对象
34           public void actionPerformed(ActionEvent e) {
35              DemoSingleton testFrame = DemoSingleton.getInstance();
36              testFrame.setSize(300, 200);
37              testFrame.setVisible(true);
38
39           }
40        }
41
42        public static void main(String[] args) {
43
44           Test test = new Test();
45        }
46 }

3：运行效果

三：懒汉式与饿汉式的理解

1：懒汉式

比较懒，就是什么时候用，什么时候建立这个对象

private SingleDemo（）{};

private static  SingleDemo single = null;

public static synchronized getInstantce(){

　　if(single == null){

　　　　single == new SingleDemo();

　　}

　　return single;

}

2：饿汉式

确实比较饿，就是不管用不用，先建立对象再说

private SingleDemo（）{};

private static  SingleDemo single = new SingleDemo();;

public static synchronized getInstantce(){

　　return single;

}