Java设计模式 [持续更新]

设计模式的概念

设计模式是在大量的实践中总结和理论化之后优化的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索。

单例模式

单例模式定义

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

单例设计模式(饿汉和懒汉)

饿汉式

1. 构造器私有化→防止直接new
2. 类的内部创建对象
3. 向外暴露一个静态的公共方法。getInstance
4. 代码实现
5. 缺点:创建了对象但是没有使用

代码示例

package com.SingleModle;

import org.junit.Test;

/**
 * 饿汉式单例模式
 *
 * @author wty
 * @date 2022/10/15 9:58
 */
public class HungerMan {
    @Test
    public void getHungerMan() {
        HungerManModer instance = HungerManModer.getInstance();
        System.out.println(instance);

        HungerManModer instance2 = HungerManModer.getInstance();
        System.out.println(instance2);

        System.out.println(instance == instance2); // true：同一个对象
    }
}

class HungerManModer {
    private String name;

    // 1.创建私有的构造器
    private HungerManModer(String name) { // 这里private原因；不想外部创建对象
        this.name = name;
    }

    // 2.在类的内部初始化对象,并且需要将其修饰为static
    // 这里访问修饰符随意，可以是任意一个，因为本身只是当前类内创建对象
    // 这里static的原因是下面的getInstance()方法是static的，静态方法调用静态对象
    private static HungerManModer hungerManModer = new HungerManModer("饿汉式"); // 这里在内部已经创建了一个实例

    // 3.向外暴露一个静态的公共方法。getInstance
    // 这里static是因为getInstance()作为给外部提供的方法，在构造器不能被外部使用的情况下，想到了用类名.方法名就能调用的静态方法
    public static HungerManModer getInstance() {
        return hungerManModer;
    }

    @Override
    public String toString() {
        return "HungerManModer{" +
                "name='" + name + '\'' +
                '}';
    }
}

懒汉式

使用了对象才创建

代码示例；

package com.SingleModle;

import org.junit.Test;

/**
 * @author wty
 * @date 2022/10/15 10:47
 */
public class LazyMan {
    @Test
    public void getLazyMan() {
        //System.out.println(LazyManExercise.x); // 只是写这一个不会调用构造器，因为没有new对象
        LazyManExercise instance = LazyManExercise.getInstance();
        System.out.println(instance);

        LazyManExercise instance2 = LazyManExercise.getInstance();
        System.out.println(instance == instance2); // true 因为对象如果创建了就返回对象本身

    }
}

class LazyManExercise {
    private String name;
    public static int x =10;

    // 1.私有化构造器,这里private后，外部不允许再创建对象
    private LazyManExercise(String name) {
        this.name = name;
        System.out.println("构造器");
    }

    // 2.创建对象，但是不new
    private static LazyManExercise lazy = null;

    // 3.写getInstance方法，用static修饰
    public static LazyManExercise getInstance() {
        // 这里判断一下，如果对象没有创建那么就创建一个对象
        if (lazy == null) {
            lazy = new LazyManExercise("懒汉式");
        }
        // 如果对象已经创建过了，那么直接返回即可
        return lazy;
    }

    @Override
    public String toString() {
        return "LazyManExercise{" +
                "name='" + name + '\'' +
                '}';
    }
}

饿汉式和懒汉式二者的对比

1. 二者最主要的区别在于创建对象的时机不同；饿汉式是在类加载的时候就创建了对象，而懒汉式是在使用时才创建
2. 饿汉式不存在线程安全问题，但是懒汉式是线程不安全的。
3. 饿汉式存在浪费资源的可能，因为如果程序员一个对象实例都没有使用，饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不会有这个问题
4. 在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式。