设计模式之单例模式

1，设计模式的由来:

　　设计模式的概念首先来源于其它行业：建筑业，在早起建房子的时候，肯定是经验缺乏、显得杂乱无序的，这就会造成很多问题，在行业发展过程，通过不断的经验积累，前辈们针对这些问题提出了合理解决方案，这就是设计模式，参照设计模式往往可以解决很多问题，在计算机编程方面，也会出现类似问题，所以牛人们把这些解决问题的方案进行归类和总结，形成了面向对象编程的23种设计模式。

1.1，单例模式释义:

　　保证类在内存中只有一个对象，就像就是实例，所以只有一个实例就是单例。

1.2，单例模式分为两种:

    //饿汉式
    class Singleton {
        //1,私有构造函数
        private Singleton(){}
        //2,创建本类对象
        private static Singleton s = new Singleton();
        //3,对外提供公共的访问方法
        public static Singleton getInstance() {
            return s;
        }
     }

    class Singleton { //饿汗式延迟加载
        //1,私有构造函数
        private Singleton(){}
        //2,声明一个本类的引用
        private static Singleton s;
        //3,对外提供公共的访问方法
        public static Singleton getInstance() {
            if(s == null) {
                s = new Singleton();
            }
            return s;
    }

1.3，利用final完成的单例设计模式:

    class Singleton {
        private Singleton() {}
        public static final Singleton s = new Singleton();//final是最终的意思,被final修饰的变量不可以被更改
    }

1.4，懒汉式同步锁（懒汉式线程不安全的解决方案）：

    public class Singleton {
        private static Singleton instance = null;
        private Singleton(){};
        public static synchronized Singleton getInstance(){
            if(instance == null){
                instance = new Singleton();
            }
        return instance;
    }

缺点：每次调用getInstance时都会判断锁，这样会降低程序的效率。注：锁（Singleton.class）该类所属的字节码文件对象。

1.5，懒汉式双重校验锁:

    private static Singleton instance = null;
    private Singleton(){};
    public static  Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }

1.6，常见例子:

public class Demo2_Singleton {
    public static void main(String[] args) {
        Studen s = new Studen();
        s.setName("JAVA大法好");
        s.setAge(100);
        System.out.println(s.getName()+"~~~~~~"+s.getAge());
    }
}
class Studen{
    private String name;
    private int age;
    public Studen() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Studen(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

public class Demo2_Singleton {
    public static void main(String[] args) {
//        这样就可以看的出单例设计模式的好处,本类只存在一个实例,获取对象的属性不用new了,大大节省了内存空间，保证了对象的唯一性
        Studen s = Studen.getInstance();
        s.setName("JAVA大法好");
        s.setAge(100);
        System.out.println(s.getName()+"~~~~~~"+s.getAge());//编译结果：JAVA大法好~~~~~~100
    }
}
class Studen{
    private String name;
    private int age;
    private  Studen() {}//私有构造方法
    private static Studen instance = new Studen();//2.本类中创建该类的对象
    public static Studen getInstance(){//3.创建一个方法，向外部提供该类的对象
        return instance;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

1.7，饿汉式与懒汉式的区别:

　　懒汉式是空间换时间,懒汉式是时间换空间,在多线程访问中,饿汉式不会创建多个对象,而懒汉式有可能会创建多个对象