设计模式（第一类：创建型包含例子）

2020-07-02 本文已影响0人 momxmo

简介

设计模式分为三大类：

第一大类：创建型模式（5种）

Factory Method（工厂方法）
Abstract Factory（抽象工厂）
Builder（建造者）
Prototype（原型）
Singleton（单例）

第二大类：结构型（7种）

Adapter Class/Object（适配器）
Bridge（桥接）
Composite（组合）
Decorator（装饰）
Facade（外观）
Flyweight（享元）
Proxy（代理）

第二大类：行为型（11种）

Interpreter（解释器）
Template Method（模板）
Chain of Responsibility（责任链）
Command（命令）
Iterator（迭代器）
Mediator（中介者）
Memento（备忘录）
Observer（观察者）
State（状态）
Strategy（策略）
Visitor（访问者）

一、创建型模式（例子）

1.1 工厂方法

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
使用场景：

1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。
实现：

第一步：
//创建一个接口:
public interface Shape {
   void draw();
}
第二步：
//创建实现接口的实体类。
public class Rectangle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
public class Square implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}
第三步：
//创建一个工厂，生成基于给定信息的实体类的对象。
public class ShapeFactory {
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

1.2 抽象工厂

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
使用场景：

1、QQ 换皮肤，一整套一起换。
2、生成不同操作系统的程序。
实现：

步骤 1
//为形状创建一个接口。
public interface Shape {
   void draw();
}
步骤 2
//创建实现接口的实体类。
public class Rectangle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
public class Square implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}
步骤 3
//为颜色创建一个接口。
public interface Color {
   void fill();
}
步骤4
//创建实现接口的实体类。
public class Red implements Color {
   @Override
   public void fill() {
      System.out.println("Inside Red::fill() method.");
   }
}
public class Green implements Color {
   @Override
   public void fill() {
      System.out.println("Inside Green::fill() method.");
   }
}
步骤 5
//为 Color 和 Shape 对象创建抽象类来获取工厂。
public abstract class AbstractFactory {
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape) ;
}
步骤 6
//创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。
public class ShapeFactory extends AbstractFactory {
   @Override
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      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 ColorFactory extends AbstractFactory {
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   @Override
   public Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){
         return new Green();
      } 
      return null;
   }
}
步骤 7
//创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。
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;
   }
}

1.3 建造者

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
使用场景：
1、需要生成的对象具有复杂的内部结构。
2、需要生成的对象内部属性本身相互依赖。
实现：

步骤 1
//创建一个表示食物条目和食物包装的接口。
public interface Item {
   public String name();
   public Packing packing();
   public float price();    
}
public interface Packing {
   public String pack();
}
步骤 2
//创建实现 Packing 接口的实体类。
public class Wrapper implements Packing {
   @Override
   public String pack() {
      return "Wrapper";
   }
}
public class Bottle implements Packing {
   @Override
   public String pack() {
      return "Bottle";
   }
}
步骤 3
//创建实现 Item 接口的抽象类，该类提供了默认的功能。
public abstract class Burger implements Item {
   @Override
   public Packing packing() {
      return new Wrapper();
   }
   @Override
   public abstract float price();
}
public abstract class ColdDrink implements Item {
    @Override
    public Packing packing() {
       return new Bottle();
    }
    @Override
    public abstract float price();
}
步骤 4
//创建扩展了 Burger 和 ColdDrink 的实体类。
public class VegBurger extends Burger {
   @Override
   public float price() {
      return 25.0f;
   }
   @Override
   public String name() {
      return "Veg Burger";
   }
}
public class ChickenBurger extends Burger {
   @Override
   public float price() {
      return 50.5f;
   }
   @Override
   public String name() {
      return "Chicken Burger";
   }
}
public class Coke extends ColdDrink {
    @Override
   public float price() {
      return 30.0f;
   }
   @Override
   public String name() {
      return "Coke";
   }
}
public class Pepsi extends ColdDrink {
   @Override
   public float price() {
      return 35.0f;
   }
   @Override
   public String name() {
      return "Pepsi";
   }
}
步骤 5
//创建一个 Meal 类，带有上面定义的 Item 对象。
public class Meal {
   private List<Item> items = new ArrayList<Item>();    
   public void addItem(Item item){
      items.add(item);
   }
   public float getCost(){
      float cost = 0.0f;
      for (Item item : items) {
         cost += item.price();
      }        
      return cost;
   }
   public void showItems(){
      for (Item item : items) {
         System.out.print("Item : "+item.name());
         System.out.print(", Packing : "+item.packing().pack());
         System.out.println(", Price : "+item.price());
      }        
   }    
}
步骤 6
//创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象。
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;
   }
}
步骤 7
//BuiderPatternDemo 使用 MealBuider 来演示建造者模式（Builder Pattern）。
public class BuilderPatternDemo {
   public static void main(String[] args) {
      MealBuilder mealBuilder = new MealBuilder();
 
      Meal vegMeal = mealBuilder.prepareVegMeal();
      System.out.println("Veg Meal");
      vegMeal.showItems();
      System.out.println("Total Cost: " +vegMeal.getCost());
 
      Meal nonVegMeal = mealBuilder.prepareNonVegMeal();
      System.out.println("\n\nNon-Veg Meal");
      nonVegMeal.showItems();
      System.out.println("Total Cost: " +nonVegMeal.getCost());
   }
}

1.4 原型

意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
使用场景：

1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
实现：

步骤 1
//创建一个实现了 Cloneable 接口的抽象类。
public abstract class Shape implements Cloneable {
   private String id;
   protected String type;
   abstract void draw();
   public String getType(){
      return type;
   }
   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public Object clone() {
      Object clone = null;
      try {
         clone = super.clone();
      } catch (CloneNotSupportedException e) {
         e.printStackTrace();
      }
      return clone;
   }
}
步骤 2
//创建扩展了上面抽象类的实体类。
public class Rectangle extends Shape {
   public Rectangle(){
     type = "Rectangle";
   }
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
public class Square extends Shape {
   public Square(){
     type = "Square";
   }
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}
步骤 3
//创建一个类，从数据库获取实体类，并把它们存储在一个 Hashtable 中。
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() {
      Square square = new Square();
      square.setId("1");
      shapeMap.put(square.getId(),square);
 
      Rectangle rectangle = new Rectangle();
      rectangle.setId("2");
      shapeMap.put(rectangle.getId(),rectangle);
   }
}
步骤 4
//PrototypePatternDemo 使用 ShapeCache 类来获取存储在 Hashtable 中的形状的克隆。
public class PrototypePatternDemo {
   public static void main(String[] args) {
      ShapeCache.loadCache();
 
      Shape clonedShape = (Shape) ShapeCache.getShape("1");
      System.out.println("Shape : " + clonedShape.getType());        
 
      Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
      System.out.println("Shape : " + clonedShape2.getType());        
}

1.5 单例

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
使用场景：
1、要求生产唯一序列号。
2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。
实现：

步骤 1
//创建一个 Singleton 类。
//1、饿汉式（线程安全）
public class SingleObject {
   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();
   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject(){}
   //获取唯一可用的对象
   public static SingleObject getInstance(){
      return instance;
   }
   public void showMessage(){
      System.out.println("Hello World!");
   }
}
//2、懒汉式（线程安全）
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;  
    }  
}
步骤 2
//从 singleton 类获取唯一的对象。
public class SingletonPatternDemo {
   public static void main(String[] args) {
      //获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();
      //显示消息
      object.showMessage();
   }
}

设计模式（第一类：创建型包含例子）

简介

第一大类：创建型模式（5种）

第二大类：结构型（7种）

第二大类：行为型（11种）

一、创建型模式（例子）

1.1 工厂方法

1.2 抽象工厂

1.3 建造者

1.4 原型

1.5 单例

猜你喜欢

热点阅读

设计模式（第一类：创建型 包含例子）

简介

第一大类：创建型模式（5种）

第二大类：结构型（7种）

第二大类：行为型（11种）

一、创建型模式（例子）

1.1 工厂方法

1.2 抽象工厂

1.3 建造者

1.4 原型

1.5 单例

猜你喜欢

热点阅读

设计模式（第一类：创建型包含例子）