设计模式之单例模式

一：单例设计模式的定义

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

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

单例模式的java实现：

1：饿汉式

/**
 * 
 */
package com.hlcui.singleton;

/**
 * @author Administrator 饿汉式单例类
 */
public class SingletonDemo {
    // 1:内部创建一个对象
    private static SingletonDemo single = new SingletonDemo();

    // 2:私有化构造方法
    private SingletonDemo() {

    }

    // 3:对外界提供一个方法，获取SingletonDemo对象
    public static SingletonDemo getInstance() {
        return single;
    }
}

2：懒汉式

/**
 * 
 */
package com.hlcui.singleton;

/**
 * @author Administrator 懒汉式单例类
 * 
 */
public class SingletonDemo2 {
    // 1:内部创建对象的引用
    private static SingletonDemo2 single;

    // 2:私有化构造方法
    private SingletonDemo2() {

    }

    // 3:对外提供一个方法，获取对象，只是要进行判断
    public static SingletonDemo2 getInstance() {
        if (single == null) {
            single = new SingletonDemo2();
        }
        return single;
    }
}

3:懒汉式与饿汉式比较

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

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

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

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

1.构造器私有

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

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

二：案例分析

1：单例代码

/**
 * 
 */
package com.hlcui.singleton;

import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;

/**
 * @author Administrator
 * 
 */
public class DemoSingleton extends JFrame {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    // 一个私有的,静态的本类对象
    private static DemoSingleton testFrame = new DemoSingleton();
    JLabel jLMes = new JLabel();

    // 构造必须是私有的,这样其它的类才不能访问
    private DemoSingleton() {
        getContentPane().setLayout(null);
        this.getContentPane().add(jLMes);
        this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        jLMes.setText("这是产生的唯一窗体");
        jLMes.setBounds(new Rectangle(103, 53, 230, 96));
    }

    // 公有的静态方法返回一个本类对象
    public static synchronized DemoSingleton getInstance() {
        return testFrame;
    }

}

2：测试代码

/**
 * 
 */
package com.hlcui.singleton;

import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;

/**
 * @author Administrator
 *
 */
class Test extends JFrame {
       JButton jBtn = new JButton();
     
       public Test() {
          getContentPane().setLayout(null);
          jBtn.setBounds(new Rectangle(125, 182, 168, 43));
          jBtn.setText("单击产生唯一窗体");
     
          this.jBtn.addActionListener(new MyActionListener());
          this.getContentPane().add(jBtn);
          this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
          this.setSize(500, 300);
          this.setVisible(true);
       }
     
       class MyActionListener implements ActionListener {
          // 单击按钮时调用单子模式类的静态方法,获得一个对象
          public void actionPerformed(ActionEvent e) {
             DemoSingleton testFrame = DemoSingleton.getInstance();
             testFrame.setSize(300, 200);
             testFrame.setVisible(true);
     
          }
       }
     
       public static void main(String[] args) {
     
          Test test = new Test();
       }
}

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;

}