单例模式Singleton 作用：保证整个应用程序中某个实例有且只有一个 类型：饿汉模式和懒汉模式

首先创建一个Pattern类，什么都不写。

1
2
3
4
5

package top.richmanroad.demo;

public class Pattern {

}

再新建一个测试Test类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package top.richmanroad.demo;

public class Test {
public static void main(String[] args) {
    
    Pattern pt1=new Pattern();
    Pattern pt2=new Pattern();
    Pattern pt3=new Pattern();
    System.out.println(pt1);
    System.out.println(pt2);
    System.out.println(pt3);
}
}

控制台输出结果

1
2
3

top.richmanroad.demo.Pattern@15db9742
top.richmanroad.demo.Pattern@6d06d69c
top.richmanroad.demo.Pattern@7852e922

可以看出其三次输出的地址不相同，说明此时创建了三个不同的实例

饿汉模式

将构造方法私有化，不能被外部直接创建对象，此时在Test类中就不能直接实例化对象了，然后在Pattern类中创建唯一的实例，并且将其变为类的成员(static将方法变为类所有),这样在Test类中可以直接使用；类名.成员名来获取对象。此时Pattern类如下：

1
2
3
4
5
6
7
8

package top.richmanroad.demo;

public class Pattern {
//将构造方法私有化，不能被外部直接创建对象
    private Pattern(){}
//创建类的唯一实例
    static Pattern instance=new Pattern();
}

Test类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package top.richmanroad.demo;

public class Test {
public static void main(String[] args) {
    
    Pattern pt1=Pattern.instance;
    Pattern pt2=Pattern.instance;
    Pattern pt3=Pattern.instance;
    System.out.println(pt1);
    System.out.println(pt2);
    System.out.println(pt3);
}
}

控制台输出结果：

1
2
3

top.richmanroad.demo.Pattern@15db9742
top.richmanroad.demo.Pattern@15db9742
top.richmanroad.demo.Pattern@15db9742

可以看出三者的地址指向一处，说明此时只创建了一个实例。

接下来为了安全，需要将对Pattern类进行封装(面向对象思想)，此时我们的Pattern类就变成了如下内容

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package top.richmanroad.demo;

public class Pattern {
//将构造方法私有化，不能被外部直接创建对象
    private Pattern(){}
//创建类的唯一实例
 private static Pattern instance=new Pattern();
//提供一个用于获取实例的方法
 public static Pattern getInstance(){
     return instance;
 }
    
}

Test类修改内容并输出，结果同上

1

Pattern pt1=Pattern.getInstance();

上面这种方法为饿汉模式，意思大致为:static为静态修饰符，当Pattern类加载时它就会创建一个唯一的实例，不管后面有没有调用，都随类一起产生。

懒汉模式

LazyPattern类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package top.richmanroad.demo;

public class LazyPattern {
    //构造方法私有化
private LazyPattern(){
}
//声明类的唯一实例，使用private修饰
private static LazyPattern instance;
//提供一个用于获取实例的方法，使用public static修饰
public static LazyPattern getInstance() {
    if(instance==null){
        instance=new LazyPattern();
    }
    return instance;
}

}

类中只是声明了一个唯一的实例，并没有创建，只有当用户获取实例时才去判断这个实例是否为空

饿汉模式懒汉模式
区别加载时速度慢，运行时获取对象比较快加载速度快，运行时获取对象速度比较慢
线程安全不安全