设计模式知识点

设计模式类型

创建型设计模式：（创建对象的同时隐藏创建逻辑）
工厂模式（Factory Pattern）
抽象工厂模式（Abstract Factory Pattern）
单例模式（Singleton Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）

结构型设计模式：（关注类和对象的组合）
适配器模式（Adapter Pattern）
桥接模式（Bridge Pattern）
过滤器模式（Filter、Criteria Pattern）
组合模式（Composite Pattern）
装饰器模式（Decorator Pattern）
外观模式（Facade Pattern）
享元模式（Flyweight Pattern）
代理模式（Proxy Pattern）

行为型模式：（关注对象之间的通信）
责任链模式（Chain of Responsibility Pattern）
命令模式（Command Pattern）
解释器模式（Interpreter Pattern）
迭代器模式（Iterator Pattern）
中介者模式（Mediator Pattern）
备忘录模式（Memento Pattern）
观察者模式（Observer Pattern）
状态模式（State Pattern）
空对象模式（Null Object Pattern）
策略模式（Strategy Pattern）
模板模式（Template Pattern）
访问者模式（Visitor Pattern）

J2EE模式：（关注表示层）
MVC 模式（MVC Pattern）
业务代表模式（Business Delegate Pattern）
组合实体模式（Composite Entity Pattern）
数据访问对象模式（Data Access Object Pattern）
前端控制器模式（Front Controller Pattern）
拦截过滤器模式（Intercepting Filter Pattern）
服务定位器模式（Service Locator Pattern）
传输对象模式（Transfer Object Pattern）

设计模式原则：

开闭原则（Open Close Principle）：对扩展开放，对修改关闭
里氏代换原则（Liskov Substitution Principle）：任何基类可以出现的地方，子类一定可以出现。
依赖倒转原则（Dependence Inversion Principle）：针对接口编程，依赖于抽象而不依赖于具体。
接口隔离原则（Interface Segregation Principle）：使用多个隔离的接口，比使用单个接口要好，降低类耦合度。
迪米特法则，又称最少知道原则（Demeter Principle）：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。
合成复用原则（Composite Reuse Principle）：尽量使用合成/聚合的方式，而不是使用继承。

工厂模式：

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

public class ShapeFactory {
   
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
   
      if(shapeType == null){
   
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
   
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
   
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
   
         return new Square();
      }
      return null;
   }
}

public class Rectangle implements Shape {
   
 
   @Override
   public void draw() {
   
      System.out.println("Inside Rectangle::draw() method.");
   }
}
...

抽象工厂:

多了一层创建工厂的抽象类。接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

public abstract class AbstractFactory {
   
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape);
}

public class ShapeFactory extends AbstractFactory {
   
    
   @Override
   public Shape getShape(String shapeType){
   
      if(shapeType == null){
   
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
   
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
   
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
   
         return new Square();
      }
      return null;
   }
   
   @Override
   public Color getColor(String color) {
   
      return null;
   }
}

public class FactoryProducer {
   
   public static AbstractFactory getFactory(String choice){
   
      if(choice.equalsIgnoreCase("SHAPE")){
   
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
   
         return new ColorFactory();
      }
      return null;
   }
}

单例模式：

涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

//饿汉式（线程安全）
public class Singleton {
     
    private static Singleton instance = new Singleton();  
    private Singleton (){
   }  
    public static Singleton getInstance() {
     
    return instance;  
    }  
}

//懒汉式（线程不安全）
public class Singleton {
     
    private static Singleton instance;  
    private Singleton (){
   }  
  
    public static Singleton getInstance() {
     
        if (instance == null) {
     
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

//懒汉式（线程安全）
public class Singleton {
     
    private static Singleton instance;  
    private Singleton (){
   }  
    public static synchronized Singleton getInstance() {
     
        if (instance == null) {
     
            instance = new Singleton();  
        }  
        return instance;  
    }  
}

//双检锁
public class Singleton {
     
    private volatile static Singleton singleton;  
    private Singleton (){
   }  
    public static Singleton getSingleton() {
     
    if (singleton == null) {
     
        synchronized (Singleton.class) {
     
            if (singleton == null) {
     
                singleton = new Singleton();  
            }  
        }  
    }  
    return singleton;  
    }  
}

//静态内部类：
public class Singleton {
     
    private static class SingletonHolder {
     
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){
   }  
    public static final Singleton getInstance() {
     
        return SingletonHolder.INSTANCE;  
    }  
}

//枚举：
public enum Singleton {
     
    INSTANCE;  
    public void whateverMethod() {
     
    }  
}

建造者模式：

使用多个简单的对象一步一步构建成一个复杂的对象。一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

public class MealBuilder {
   
 
   public Meal prepareVegMeal (){
   
      Meal meal = new Meal();
      meal.addItem(new VegBurger());
      meal.addItem(new Coke());
      return meal;
   }   
 
   public Meal prepareNonVegMeal (){
   
      Meal meal = new Meal();
      meal.addItem(new ChickenBurger());
      meal.addItem(new Pepsi());
      return meal;
   }
}

public abstract class Burger implements Item {
   
 
   @Override
   public Packing packing() {
   
      return new Wrapper();
   }
 
   @Override
   public abstract float price();
}

public interface Item {
   
   public String name();
   public Packing packing();
   public float price();    
}
...

原型模式:

是用于创建重复的对象，同时又能保证性能。用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

public class ShapeCache {
   
    
   private static Hashtable<String, Shape> shapeMap 
      = new Hashtable<String, Shape>();
 
   public static Shape getShape(String shapeId) {
   
      Shape cachedShape = shapeMap.get(shapeId);
      return (Shape) cachedShape.clone();
   }
 
   // 对每种形状都运行数据库查询，并创建该形状
   // shapeMap.put(shapeKey, shape);
   // 例如，我们要添加三种形状
   public static void loadCache() {
   
      Circle circle = new Circle();
      circle.setId("1");
      shapeMap.put(circle.getId(),circle);
 
      Square square = new Square();
      square.setId("2");
      shapeMap.put(square.getId(),square);
 
      Rectangle rectangle = new Rectangle();
      rectangle.setId("3");
      shapeMap.put(rectangle.getId(),rectangle);
   }
}

public abstract class Shape implements Cloneable {
   
   
   private String id;
   protected String type;
   
   abstract void draw();
   
   public Object clone() {
   
      Object clone = null;
      try {
   
         clone = super.clone();
      } catch (CloneNotSupportedException e) {
   
         e.printStackTrace();
      }
      return clone;
   }
}

适配器模式：

作为两个不兼容的接口之间的桥梁。

public class MediaAdapter implements MediaPlayer {
   
 
   AdvancedMediaPlayer advancedMusicPlayer;
 
   public MediaAdapter(String audioType){
   
      if(audioType.equalsIgnoreCase("vlc") ){
   
         advancedMusicPlayer = new VlcPlayer();       
      } else if (audioType.equalsIgnoreCase("mp4")){
   
         advancedMusicPlayer = new Mp4Player();
      }  
   }
 
   @Override
   public void play(String audioType, String fileName) {
   
      if(audioType.equalsIgnoreCase("vlc")){
   
         advancedMusicPlayer.playVlc(fileName);
      }else if(audioType.equalsIgnoreCase("mp4")){
   
         advancedMusicPlayer.playMp4(fileName);
      }
   }
}

public interface AdvancedMediaPlayer {
    
   public void playVlc(String fileName);
   public void playMp4(String fileName);
}

public class VlcPlayer implements AdvancedMediaPlayer{
   
   @Override
   public void playVlc(String fileName) {
   
      System.out.println("Playing vlc file. Name: "+ fileName);      
   }
 
   @Override
   public void playMp4(String fileName) {
   
      //什么也不做
   }
}
...

桥接模式：

涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。

public interface DrawAPI {
   
   public void drawCircle(int radius, int x, int y);
}

public class RedCircle implements DrawAPI {
   
   @Override
   public void drawCircle(int radius, int x, int y) {
   
      System.out.println("Drawing Circle[ color: red, radius: "
         + radius +", x: " +x+", "+ y +"]");
   }
}

public abstract class Shape {
   
   protected DrawAPI drawAPI;
   protected Shape(DrawAPI drawAPI){
   
      this.drawAPI = drawAPI;
   }
   public abstract void draw();  
}

public class Circle extends Shape {
   
   private int x, y, radius;
 
   public Circle(int x, int y, int radius, DrawAPI drawAPI) {
   
      super(drawAPI);
      this.x = x;  
      this.y = y;  
      this.radius