单例模式

• 一个对象只有一个实例，后续调用都是之前new好的实例
• spring的依赖注入默认是单例

观察者模式

• 可以理解为注册中心吧，被观察者如果做出了特定的行为时，就会通知观察者
• 一对多
• 当一个对象状态发生改变，其他依赖它的对象都会得到通知并做出相应行为(更新)

装饰者模式

• 比如手抓饼，可以加火腿、鸡蛋
• 对已有的业务做进一步封装，增加额外的功能
• 通过继承实现

适配器模式

• 理解成手机充电器的转接口吧，为了适应不同参数输入，则改变输入源

工厂模式

• 父类为抽象类，用于子类继承实现
• 比如父类是车，子类可以是宝马、奔驰等

  // 工厂类
  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;
    }
  }

  用户调用Factory.getCarInstance(***)，即可获取不同实例

工厂方法模式

• 比如工厂模式就不是通过工程类去获取某个实例，而是用接口模式
• 实现方式为父类去new子类

  // 抽象产品角色
  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();
    }
  }

抽象工厂模式

• 与上述不同的是，上面的生产一个，这个生产多个

  /抽象工厂类
  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();
    }
  }

https://blog.csdn.net/onlyoncelove/article/details/81456024