以下所有都是韩顺平老师讲设计模式我个人的笔记而已，如有雷同，就是雷同。

原则：

单一职责：代码不要写到一个类里，比如Controller，Service，Dao。然而也会由另外一个问题Service过重，转而DDD。

依赖倒转：参数中不要放实现类，要放接口，接口尽可能分工明确，只做某一件事。

里氏替换：子类不要重写父类的方法，如果重写了，考虑抽象成接口。 

迪米特法则：类与类之间降低依赖，一个类在另外一个类中的位置可以是1.继承或实现   2.成员变量   3.参数   4.引用jar包，尽可能减少依赖。

模块化和开闭原则：一个jar包可以对外修改，对内不变。

 

模式：

单例模式：比较重的对象，程序中只有一个。比如Spring的示例默认都是单例。推荐使用静态内部类，枚举，双重检查懒汉式。

// 懒汉式(线程安全，同步方法)
class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    //同时保证了效率, 推荐使用
    
    public static synchronized Singleton getInstance() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
            
        }
        return instance;
    }
}

// 静态内部类完成， 推荐使用
class Singleton {
   private static volatile Singleton instance;

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

   //写一个静态内部类,该类中有一个静态属性 Singleton
   private static class SingletonInstance {
      private static final Singleton INSTANCE = new Singleton(); 
   }

   //提供一个静态的公有方法，直接返回SingletonInstance.INSTANCE

   public static synchronized Singleton getInstance() {

      return SingletonInstance.INSTANCE;
   }
}

//使用枚举，可以实现单例, 推荐
enum Singleton {
   INSTANCE; //属性
   public void sayOK() {
      System.out.println("ok~");
   }
}

 

 

工厂模式：

　　需要引用抽象类的地方多了之后，很多个引用对象中就会有很多对应的   判断抽象类的实现是哪个子类   的重复代码。

　　简单工厂（静态工厂）：1.封装实例化对象的行为 =》引用类的参数中包含了一个一个抽象类，不如包含一个工厂，只需要在工厂中判断是哪个子类。

 

　　工厂多了以后，提取一个公共的抽象类，类中定义一个实现方法，所有的子类工厂各自实现它，那为什么不直接定义一个抽象工厂呢？即抽象工厂模式。

　　工厂方法：2.把对象实例化行为推迟到子类 =》工厂方法：工厂很多了之后

　　

　　抽象工厂模式：

//实体类
public class BJCheesePizza extends Pizza {public void prepare() {}}
public class BJPepperPizza extends Pizza {public void prepare() {}}
public class LDCheesePizza extends Pizza{public void prepare() {}}
public class LDPepperPizza extends Pizza{public void prepare() {}}
public abstract class Pizza {public abstract void prepare();}

//抽象工厂
public interface AbsFactory {
    public Pizza createPizza(String orderType);
}

//这是A工厂子类
public class BJFactory implements AbsFactory {

    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~使用的是抽象工厂模式~");

        Pizza pizza = null;
        if(orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza();
        }
        return pizza;
    }

}

//这是B工厂子类
public class LDFactory implements AbsFactory {

    @Override
    public Pizza createPizza(String orderType) {
        System.out.println("~使用的是抽象工厂模式~");
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new LDCheesePizza();
        } else if (orderType.equals("pepper")) {
            pizza = new LDPepperPizza();
        }
        return pizza;
    }

}

//引用方
public class OrderPizza {

    AbsFactory factory;

    // 构造器
    public OrderPizza(AbsFactory factory) {
        setFactory(factory);
    }

    private void setFactory(AbsFactory factory) {
        Pizza pizza = null;
        String orderType = ""; // 用户输入
        this.factory = factory;
        do {
            orderType = getType();
            // TODO factory 可能是北京的工厂子类，也可能是伦敦的工厂子类
            pizza = factory.createPizza(orderType);
            if (pizza != null) { // 订购ok
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }

} 

//调用者 public class PizzaStore { public static void main(String[] args) { //new OrderPizza(new BJFactory()); new OrderPizza(new LDFactory()); } }

 

原型模式：