单例设计模式

1、定义：

所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类，只能存在一个对象的实例，并且该类只提供一个，取得其对象实例的方法。

2、单例设计方式：

     1、饿汉式（及时加载）

 

       1.1构造方法私有化 

       1.2在类里私有静态一个实例成员

       1.3.在对外提供获取本类对象的静态方法

public static 类名 方法名(){

         return 实例成员

}

 

    2、懒汉式(延时加载)

        2.1构造方法私有化。

        2.2  在类的里面有一个静态本类的成员引用。

        2.3  对外提供获取本类对象的静态方法

public static 类名 方法名(){

                       .....

                }

package lnsides;
class HungryHanStyle{//饿汉式
    //private的构造器，不能在类的外部创建该类的对象
    private HungryHanStyle(){
    }
    //私有的，只能在类的内部访问
    private static HungryHanStyle hanStyle =new HungryHanStyle();
    //getHanStyle()为static,不用创建对象即可访问
    public static HungryHanStyle getHanStyle(){
        return hanStyle;
    }
}
//懒汉式
class LazyStyle{
    //1.将构造器私有化，保证在此类的外部，不能调用本类的构造器
    private LazyStyle(){

    }
    //2.先声明类的引用
    //3.也需要配合static的方法,用static修饰此类的引用。
    private static LazyStyle style = null;

    //4.设置公共的方法来访问类的实例
    public static LazyStyle getInstance(){
        //4.1如果类的实例未创建，那么先要创建，然后返回给调用者:本类。因此需要static修饰
        if (style == null) {
            style = new LazyStyle();
        }
        //若有了类的实例，直接返回给调用者
        return style;
    }
}
class EHan{//饿汉式
    private EHan(){

    }
    private static EHan eHan =new EHan();
    public static EHan getInstance(){
        return eHan;
    }
}
class LanHan{//懒汉式
    private LanHan(){

    }
    private static LanHan lanHan;
    public static LanHan getInstance(){
        if (lanHan == null) {
            lanHan = new LanHan();
        }
        return lanHan;
    }
}
public class SingleColumn {
    public static void main(String[] args) {
        HungryHanStyle hanStyle = HungryHanStyle.getHanStyle();//访问静态方法
        HungryHanStyle hanStyle1 =HungryHanStyle.getHanStyle();
        System.out.println(hanStyle);
        System.out.println(hanStyle1);
        LazyStyle lazyStyle = LazyStyle.getInstance();
        LazyStyle lazyStyle1 =LazyStyle.getInstance();
        System.out.println(lazyStyle);
        System.out.println(lazyStyle1);
    }

}