设计模式

1. 单例模式

单例模式，顾名思义，只实例化一个对象，私有化构造函数，一般用于实例化一个对象复杂且耗时的情况下。

1.1 饿汉式

形象地比喻一下，已经做好饭了，饿汉来了直接开吃

public class Singleton {
    // 实例化对象
    private static Singleton instance = new Singleton();

    // 私有化构造函数
    private Singleton() {
    }

    public static Singleton getInstance() {
        return instance;
    }
}

1.2 懒汉式

形象地比喻一下，懒汉做了一顿饭，后面一辈子就只吃这一次做好的

public class Singleton {
    private static Singleton singleton = null;

    // 私有化构造函数 
    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            // 实例化对象
            singleton = new Singleton();
        }
        return singleton;
    }
}

but，这样写是线程不安全的，当多个线程同时调用getInstance()方法时，可能会实例化多个对象，因此可以加同步锁

public class Singleton {
    private static Singleton instance = null;

    private Singleton() {
    }

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

but，当线程数过多时，多次使用synchronized方法会影响程序效率，因此可采用双重校验锁

public class Singleton {
    private volatile static Singleton singleton = null;

    private Singleton() {
    }

    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

2. 工厂模式

2.1 简单工厂模式

简单工厂模式：一个抽象的接口，多个抽象接口的实现类，一个工厂类，用来实例化抽象的接口

// 抽象产品类
abstract class Car {
    
    public void run();

    public void stop();
}

// 具体实现类
class Benz implements Car {
    public void run() {
        System.out.println("Benz开始启动了");
    }

    public void stop() {
        System.out.println("Benz停车了");
    }
}

class Ford implements Car {
    public void run() {
        System.out.println("Ford开始启动了");
    }

    public void stop() {
        System.out.println("Ford停车");
    }
}

// 工厂类
class Factory {
    public static Car getCarInstance(String type) {
        Car c = null;
        if ("Benz".equals(type)) {
            c = new Benz();
        }
        if ("Ford".equals(type)) {
            c = new Ford();
        }
        return c;
    }
}

public class Test {

    public static void main(String[] args) {
        Car c = Factory.getCarInstance("Benz");
        if (c != null) {
            c.run();
            c.stop();
        } else {
            System.out.println("造不了这种汽车。。。");
        }
    }
}

2.2 工厂方法模式

工厂方法模式：具体产品模式，不再是由一个工厂类去实例化具体的产品，每个产品都有一个专属的工厂

// 抽象产品角色
public interface Moveable {
    void run();
}

// 具体产品角色
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane....");
    }
}

public class Broom implements Moveable {
    @Override
    public void run() {
        System.out.println("broom.....");
    }
}

// 抽象工厂
public abstract class VehicleFactory {
    abstract Moveable create();
}

// 具体工厂
public class PlaneFactory extends VehicleFactory {
    public Moveable create() {
        return new Plane();
    }
}

public class BroomFactory extends VehicleFactory {
    public Moveable create() {
        return new Broom();
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new BroomFactory();
        Moveable m = factory.create();
        m.run();
    }
}

2.3 抽象工厂模式

抽象工厂模式：进一步优化，提取工厂接口

// 抽象工厂类

public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();

    public abstract Weapon createWeapon();

    public abstract Food createFood();
}

// 具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory {
    @Override
    public Food createFood() {
        return new Apple();
    }

    @Override
    public Vehicle createVehicle() {
        return new Car();
    }

    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}

Reference
如何学习设计模式？ - 力扣（LeetCode）的回答 - 知乎
https://www.cnblogs.com/xiaofengwang/p/11255678.html