单例模式

单例模式

一、前言

​ 设计模式：是一套被反复使用的代码设计经验的总结，专门用于解决特定场景的需求，是为了可重用代码，让代码更容易被他人理解，尽量达到设计原则，保证代码可靠性。

​ 单例设计模式：最常用、最简单的设计模式。

​ 用途：设计工具类。

​ 目的：保证在整个应用中某一个类有且只有一个实例（一个类只有一个对象在堆内存中）

二、分类

​ 分为：饿汉式、懒汉式

三、饿汉式单例

1. 必须先在该类中创建出一个对象。
2. 私有化自身构造器，防止外界通过构造器穿建新的工具类对象。
3. 向外暴露一个公共的静态方法用于返回自身。

package singleton;
//饿汉式
public class SortUtils {
    //事先创建好当前类的一个对象
    private  static SortUtils sortUtils=new SortUtils();
    //私有化自身构造器，防止外界通过构造器创建自身对象
    private SortUtils(){};
    public static SortUtils getSortUtils(){
        return sortUtils;
    }
    //将工具方法作为实例方法挂在单例上
    public int[] arraysort(int[] array){
        for(int i=0;i<array.length-1;i++){//控制比较轮次，一共 n-1 趟
            for(int j=0;j<array.length-1-i;j++){//控制两个挨着的元素进行比较
                if(array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}

package singleton;

public class Test {
    public static void main(String[] args) {
        //单例访问
        SortUtils a= SortUtils.getSortUtils();
        System.out.println(a);
        //测试方法
        SortUtils newGetSort= SortUtils.getSortUtils();
        int[] array={1,10,8,7,4,6};
        int[] array2=newGetSort.arraysort(array);
        for(int i:array2){
            System.out.print(i+" ");
        }
    }
}

四、懒汉式单例

1. 私有化自身构造器，防止外界通过构造器穿建新的工具类对象。
2. 判断是否sortUtils是否为空，为空则创建出一个对象。
3. 向外暴露一个公共的静态方法用于返回自身。

package singleton2;
//饿汉式
public class SortUtils {
    //私有化自身构造器，防止外界通过构造器创建自身对象
    private SortUtils(){};
    //声明当前类的一个对象
    private  static SortUtils sortUtils=null;
    //提供一个公共静态方法，返回创建好的实例
    public static SortUtils getSortUtils(){
        if(sortUtils==null){
             sortUtils = new SortUtils();
        }
        return sortUtils;
    }
    //将工具方法作为实例方法挂在单例上
    public int[] arraysort(int[] array){
        for(int i=0;i<array.length-1;i++){//控制比较轮次，一共 n-1 趟
            for(int j=0;j<array.length-1-i;j++){//控制两个挨着的元素进行比较
                if(array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}

package singleton2;
public class Test {
    public static void main(String[] args) {
        //单例访问
        SortUtils a=SortUtils.getSortUtils();
        System.out.println(a);
        //测试方法
        SortUtils newGetSort=SortUtils.getSortUtils();
        int[] array={1,10,8,7,4,6};
        int[] array2=newGetSort.arraysort(array);
        for(int i:array2){
            System.out.print(i+" ");
        }
    }
}

五、两个单例之间的区别

​ “饿汉式”是在不管你用的用不上，一开始就建立这个单例对象。线程安全。

​ “懒汉式”是在你真正用到的时候才去建这个单例对象。线程不安全。