Java学习--设计模式之创建型模式

一、简介

　　创建型模式：这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。创建型模式包括：工厂模式（Factory Pattern），抽象工厂模式（Abstract Factory Pattern），单例模式（Singleton Pattern），建造者模式（Builder Pattern），原型模式（Prototype Pattern）。

二、工厂模式（Factory Pattern）

　　1、概念

　　　工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

　　2、简介

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

　　　主要解决：主要解决接口选择的问题。

　　　何时使用：我们明确地计划不同条件下创建不同实例时。

　　　如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

　　　应用实例： 您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

　　　优点： 

　　　　（1）、一个调用者想创建一个对象，只要知道其名称就可以了。

　　　　（2）、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

　　　　（3）、屏蔽产品的具体实现，调用者只关心产品的接口。

　　　缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

　　　使用场景： 

　　　　（1）、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

　　　　（2）、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

　　　　（3）、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

　　　注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

　　3、实例

　　　我们将创建一个 Shape 接口和实现 Shape 接口的实体类。然后定义工厂类 ShapeFactory。FactoryPatternDemo，我们的演示类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。

　　　　

　　　　（1）、创建 Shape 接口；

public interface Shape {
   void draw();
}

　　　　（2）、创建实现接口的实体类；

public class Rectangle implements Shape {

   @Override
   public void draw() {
      System.out.println("三角形");
   }
}

public class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("圆形");
   }
}

public class Square implements Shape { @Override public void draw() { System.out.println("矩形"); } }

　　　　（3）、创建一个工厂，用于生成基于给定信息的实体类的对象；

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;
   }
}

　　　　（4）、使用该工厂，通过传递类型信息来获取实体类的对象；

public class FactoryPatternDemo {

   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();

      //获取 Circle 的对象，并调用它的 draw 方法
      Shape shape1 = shapeFactory.getShape("CIRCLE");

      //调用 Circle 的 draw 方法
      shape1.draw();

      //获取 Rectangle 的对象，并调用它的 draw 方法
      Shape shape2 = shapeFactory.getShape("RECTANGLE");

      //调用 Rectangle 的 draw 方法
      shape2.draw();

      //获取 Square 的对象，并调用它的 draw 方法
      Shape shape3 = shapeFactory.getShape("SQUARE");

      //调用 Square 的 draw 方法
      shape3.draw();
   }
}

　　　　（5）、验证结果；

圆形
三角形
矩形

三、抽象工厂模式（Abstract Factory Pattern）

　　1、概念

　　　抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

　　2、简介

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

　　　主要解决：主要解决接口选择的问题。

　　　何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一种产品时。

　　　如何解决：在一个产品族里面，定义多个产品。

　　　应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况，在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。所有的衣柜（具体工厂）都是衣柜类中的的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都属于上衣类（抽象产品），具体的裤子也都属于裤子类（另一个抽象产品）。

　　　优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

　　　缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

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

　　　注意事项：产品族难扩展，产品等级易扩展。

　　3、实例

　　　我们将创建 Shape 和 Color 接口和实现这些接口的实体类。然后创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。最后创建演示类AbstractFactoryPatternDemo，我们的演示类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。

　　　　

　　　　（1）、创建 Shape 接口及其实现类

public interface Shape {
   void draw();
}

public class Rectangle implements Shape {

   @Override
   public void draw() {
      System.out.println("这是三角形");
   }
}

public class Square implements Shape {

   @Override
   public void draw() {
      System.out.println("这是矩形");
   }
}

public class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("这是圆形");
   }
}

　　　　（2）、创建 Color 接口及其实现类

public interface Color {
   void fill();
}

public class Red implements Color {

   @Override
   public void fill() {
      System.out.println("这是红色");
   }
}

public class Blue implements Color {

   @Override
   public void fill() {
      System.out.println("这是蓝色");
   }
}

public class Black implements Color {

   @Override
   public void fill() {
      System.out.println("这是黑色");
   }
}

　　　　（3）、为 Color 和 Shape 对象创建抽象类来获取工厂。

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

　　　　（4）、创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。

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 ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("Black")){
         return new Black();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}

　　　　（5）、创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。

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;
   }
}

　　　　（6）、使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {

      //获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");

      //获取形状为 Circle 的对象
      Shape shape1 = shapeFactory.getShape("CIRCLE");

      //调用 Circle 的 draw 方法
      shape1.draw();

      //获取形状为 Rectangle 的对象
      Shape shape2 = shapeFactory.getShape("RECTANGLE");

      //调用 Rectangle 的 draw 方法
      shape2.draw();
      
      //获取形状为 Square 的对象
      Shape shape3 = shapeFactory.getShape("SQUARE");

      //调用 Square 的 draw 方法
      shape3.draw();

      //获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");

      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");

      //调用 Red 的 fill 方法
      color1.fill();

      //获取颜色为 Black 的对象
      Color color2 = colorFactory.getColor("Black");

      //调用 Black 的 fill 方法
      color2.fill();

      //获取颜色为 Blue 的对象
      Color color3 = colorFactory.getColor("BLUE");

      //调用 Blue 的 fill 方法
      color3.fill();
   }
}

　　　　（7）、演示结果

这是圆形
这是三角形
这是矩形
这是红色
这是黑色
这是蓝色

四、单例模式（Singleton Pattern）

　　1、概念

　　　单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

　　2、简介

　　　意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

　　　主要解决：一个全局使用的类频繁地创建与销毁。

　　　何时使用：当您想控制实例数目，节省系统资源的时候。

　　　如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

　　　关键代码：构造函数是私有的。

　　　应用实例：

　　　　（1）、Windows 是多进程多线程的，在操作一个文件的时候，就不可避免地出现多个进程或线程同时操作一个文件的现象，所以所有文件的处理必须通过唯一的实例来进行。

　　　　（2）、一些设备管理器常常设计为单例模式，比如一个电脑有两台打印机，在输出的时候就要处理不能两台打印机打印同一个文件。

　　　优点： 

　　　　（1）、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。

　　　　（2）、避免了对资源的多重占用（比如写文件操作）。

　　　缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

　　　使用场景： 

　　　　（1）、要求生产唯一序列号。

　　　　（2）、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。

　　　　（3）、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

　　　注意事项：

　　　　（1）、单例类只能有一个实例。

　　　　（2）、单例类必须自己创建自己的唯一实例。

　　　　（3）、单例类必须给所有其他对象提供这一实例。

　　　　（4）、getInstance() 方法中需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

　　3、实例

　　　我们将创建一个 SingleObject 类。SingleObject 类有它的私有构造函数和本身的一个静态实例。SingleObject 类提供了一个静态方法，供外界获取它的静态实例。创建演示类SingletonPatternDemo，我们的演示类使用 SingleObject 类来获取 SingleObject 对象。

　　　　

　　　　（1）、创建一个 SingleObject 类。

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）、创建 SingletonPatternDemo 类，从 SingleObject 类获取唯一的对象

public class SingletonPatternDemo {
   public static void main(String[] args) {

      //不合法的构造函数
      //编译时错误：构造函数 SingleObject() 是不可见的
      //SingleObject object = new SingleObject();

      //获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();

      //显示消息
      object.showMessage();
   }
}

　　　　（3）、验证实例

Hello World!

五、建造者模式（Builder Pattern）

　　1、概念

　　　建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

　　2、简介

　　　意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

　　　主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

　　　何时使用：一些基本部件不会变，而其组合经常变化的时候。

　　　如何解决：将变与不变分离开。

　　　应用实例： 

　　　　（1）、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

　　　　（2）、JAVA 中的 StringBuilder。

　　　优点： 

　　　　（1）、建造者独立，易扩展。

　　　　（2）、便于控制细节风险。

　　　缺点： 

　　　　（1）、产品必须有共同点，范围有限制。

　　　　（2）、如内部变化复杂，会有很多的建造类。

　　　使用场景： 

　　　　（1）、需要生成的对象具有复杂的内部结构。

　　　　（2）、需要生成的对象内部属性本身相互依赖。

　　　注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

 　　3、实例

　　　我们假设一个快餐店的商业案例，其中，一个典型的套餐可以是一个汉堡（Burger）和一杯冷饮（Cold drink）。汉堡（Burger）可以是素食汉堡（Veg Burger）或鸡肉汉堡（Chicken Burger），它们是包在纸盒中。冷饮（Cold drink）可以是可口可乐（coke）或百事可乐（pepsi），它们是装在瓶子中。我们将创建一个表示食物条目（比如汉堡和冷饮）的 Item 接口和实现 Item 接口的实体类，以及一个表示食物包装的 Packing 接口和实现 Packing 接口的实体类，汉堡是包在纸盒中，冷饮是装在瓶子中。然后我们创建一个 Meal 类，带有 Item 的 ArrayList 和一个通过结合 Item 来创建不同类型的 Meal 对象的 MealBuilder。最后创建演示类 BuilderPatternDemo，我们的演示类使用 MealBuilder 来创建一个 Meal。

　　　　

　　　　（1）、创建一个表示食物条目（Item）和食物包装（Packing）的接口

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 对象。

import java.util.ArrayList;
import java.util.List;

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("\nNon-Veg Meal");
      nonVegMeal.showItems();
      System.out.println("Total Cost: " +nonVegMeal.getCost());
   }
}

　　　　（8）、演示结果

Veg Meal
Item : Veg Burger, Packing : Wrapper, Price : 25.0
Item : Coke, Packing : Bottle, Price : 30.0
Total Cost: 55.0

Non-Veg Meal
Item : Chicken Burger, Packing : Wrapper, Price : 50.5
Item : Pepsi, Packing : Bottle, Price : 35.0
Total Cost: 85.5

六、原型模式（Prototype Pattern）

　　1、概念

　　　原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

　　2、简介

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

　　　主要解决：在运行期建立和删除原型。

　　　何时使用： 

　　　　（1）、当一个系统应该独立于它的产品创建、构成和表示时。

　　　　（2）、当要实例化的类是在运行时刻指定时，例如，通过动态装载。

　　　　（3）、为了避免创建一个与产品类层次平行的工厂类层次时。

　　　　（4）、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

　　　如何解决：利用已有的一个原型对象，快速地生成和原型对象一样的实例。

　　　优点： 

　　　　（1）、性能提高。

　　　　（2）、逃避构造函数的约束。

　　　缺点： 

　　　　（1）、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。

　　　　（2）、必须实现 Cloneable 接口。

　　　使用场景： 

　　　　（1）、资源优化场景。

　　　　（2）、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。

　　　　（3）、性能和安全要求的场景。

　　　　（4）、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

　　　　（5）、一个对象多个修改者的场景。

　　　　（6）、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

　　　　（7）、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。

　　　注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

　　3、实例

　　　我们将创建一个抽象类 Shape 和扩展了 Shape 类的实体类。下一步是定义类 ShapeCache，该类把 shape 对象存储在一个 Hashtable 中，并在请求的时候返回它们的克隆。最后创建演示类PrototypePatternDemo，我们的演示类使用 ShapeCache 类来获取 Shape 对象。

　　　　

　　　　（1）、创建一个实现了 Clonable 接口的抽象类 Shape；

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 void setType(String type) {
      this.type = type;
   }
   
   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("这是三角形");
   }
}

public class Square extends Shape {

   public Square(){
     type = "Square";
   }

   @Override
   public void draw() {
      System.out.println("这是矩形");
   }
}

public class Circle extends Shape {

   public Circle(){
     type = "Circle";
   }

   @Override
   public void draw() {
      System.out.println("这是圆形");
   }
}

　　　　（3）、创建一个类，从数据库获取实体类，并把它们存储在一个 Hashtable 中

import java.util.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() {
      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);
   }
}

　　　　（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());        

      Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
      System.out.println("Shape : " + clonedShape3.getType());        
   }
}

　　　　（5）、验证输出

Shape : Circle
Shape : Square
Shape : Rectangle

创建型模式的介绍就到此结束了，如有错误，还望各位大佬指正；