Java设计模式（单例模式、工厂模式）

单例模式

---

/*
 * 设计模式：
 *      代表最佳的实现方式，是有经验的开发人员通过开发总结出来的一些经验和错误，用来解决一系列问题
 *      是前人对代码开发的经验总结，不是特定的语法结构，而是一套用来提供 可复用性、可维护性、
 *          可读性、健壮性、安全性 的解决方案
 *      将常用的编码方式总结出来，形成固定的结构
 *      开发中使用设计模式，等同于使用前人的经验，可避免很多错误及问题
 *
 * 单例模式：只让某个类创建一个对象
 * 实现步骤
 *   要控制创建对象的数量。就不能右用户决定，应该由当前类控制
 *   构造方法是用来创建对象的，若当前类控制，则不能让用户直接访问构造方法
 *   1 构造方法私有化
 *       构造方法私有化，意味着用户不能创建对象
 *       这时，应该当前类创建一个对象，让用户直接获取这个对象，如何获取？
 *       对外提供一个公共的静态方法，调用该方法就返回一个对象
 *   2 创建一个公共的静态方法来返回当前类对象，并只实例化一次
 *       当外部调用通过该方法获取对象时，先判断是否创建了对象，如果没有则创建一个并保存
 *       若已经创建，直接返回
 *       那么，需要 一个存储对象的变量，这个变量必须和类生命周期相关（这个变量保存的对象不需要外部new去创建，因此是类级别）
 *       如果是局部变量，则方法每次调用，都会重新初始化局部变量，这就导致每次都会创建对象
 *       如果是成员变量，不可行，因为静态方法中不能直接操作成员变量
 *       故 只能是 静态变量，且这个变量要私有化，使其不能被外部访问，不私有化外部用户可以直接更改变量
 *   3 创建一个私有化静态变量，用于存储当前类对象（变量的类型，是当前类类型）
 *
 * 根据创建对象时机分为：
 *      1 懒汉模式: 第一次创建对象的时候，在创建对象
 *      2 饿汉模式: 加载类的时候创建对象
 * */

---

public class SglClient {

    public static void main(String[] args) {
        // 不能new，在类中创建对象
        // System.out.println(new _01_Singleton());
        // 懒汉模式
        System.out.println(_01_Singleton.getInstance());
        System.out.println(_01_Singleton.getInstance());
        System.out.println(_01_Singleton.getInstance());
        System.out.println("==========");

        // 饿汉模式
        System.out.println(_02_Singleton.getInstance());
        System.out.println(_02_Singleton.getInstance());
        System.out.println(_02_Singleton.getInstance());
    }
}

---

/**
 * 懒汉模式
 */
public class _01_Singleton {

    // 私有化构造方法
    private _01_Singleton(){

    }

    // 私有化静态变量，用于存储当前类对象
    private static _01_Singleton s;

    // 对外提供一个获取当前对象的方法
    public static _01_Singleton getInstance(){
        // 判断对象是否为空
        // 为空，则创建对象
        if (s == null){
            s = new _01_Singleton();
        }
        // 否则说明存在对象，直接返回
        return s;
    }
}

---

/**
 * 饿汉模式
 */
public class _02_Singleton {

    // 构造方法私有化
    private _02_Singleton() {
    }

    // 静态引用变量在加载阶段初始化，且整个程序声明周期中指初始化一次
    private static _02_Singleton s = new _02_Singleton();
    // 返回该对象
    public static _02_Singleton getInstance(){
        return s;
    }
}

---

工厂模式

/*
* 工厂模式；把创建对象的语句单独封装成一个工厂模式
*   所有用到这个对象的地方，都去工厂中获取，把类之间强依赖关系变弱，灵活度更高
* */
public class _01_Factory {

    public static void main(String[] args) {
//        System.out.println("==武器砖头==");
//        fight(new ZhuanTou());
//        fight(new ZhuanTou());
//        fight(new ZhuanTou());
//        fight(new ZhuanTou());
//        fight(new ZhuanTou());
        System.out.println("=====武器换为AK47======");
        // 如果要将武器换为AK47，则需要显式传入匿名对象AK47(new AK47()),这是强依赖
        fight(new AK47());
        fight(new AK47());
        fight(new AK47());
        fight(new AK47());
        System.out.println("========工厂模式换武器AK47=========");
        // 通过工厂模式隐式传入匿名对象，需要换那种对象由工厂决定，弱化依赖关系，不用在此源码中强制依赖某个对象
        // 降低类之间的耦合性，就是说当前类不显式依赖于AK47类，因为工厂可以返回RPG对象，只需要知道需要用到接口
        // 依赖于抽象，不依赖于具体的实现
        fight(WeaponFactory.getWeapon());
        fight(WeaponFactory.getWeapon());
        fight(WeaponFactory.getWeapon());
        fight(WeaponFactory.getWeapon());

        fight(new RPG());
    }

    public static void fight(Weapon weapon){
        weapon.FireInTheHole();
    }
}

---

public interface Weapon {
    void FireInTheHole();
}

---

public class ZhuanTou implements Weapon {
    @Override
    public void FireInTheHole() {
        System.out.println("扔砖头");
    }
}

---

public class AK47 implements Weapon {
    @Override
    public void FireInTheHole() {
        System.out.println("换枪来了");
    }
}

---

public class RPG implements Weapon {
    @Override
    public void FireInTheHole() {
        System.out.println("小心，火箭筒来了");
    }
}

---

public class WeaponFactory {

    public static Weapon getWeapon(){
        return new AK47();
    }
}