Java---23中设计模式01（5种创建型模式）+笔记

比眉伴天荒 2022-05-30 00:58 197阅读 0赞

总体来说设计模式分为三大类：

*  创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
 *  结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
 *  行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。  
    ![这里写图片描述][SouthEast]

这一篇是转载其他人的博客，然后加上自己的理解，预计用三个阶段说完，这一篇主要是创建型的5种模式。  
如有转载，请说明出处：[http://blog.csdn.net/zhangerqing][http_blog.csdn.net_zhangerqing]  
为了方便看图，将图里面各标识符的含义表示一下：

<table> 
 <thead> 
  <tr> 
   <th>图标</th> 
   <th align="center">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>球形</td> 
   <td align="center">表示接口</td> 
  </tr> 
  <tr> 
   <td>虚线箭头</td> 
   <td align="center">表示实现接口</td> 
  </tr> 
  <tr> 
   <td>矩形</td> 
   <td align="center">类和方法</td> 
  </tr> 
 </tbody> 
</table>

# 1.工厂方法模式（Factory Method） #

工厂模式一般有三种，普通工厂模式，多工厂模式，和静态工厂模式。

## 1.1.普通工厂模式 ##

就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建  
![这里写图片描述][SouthEast 1]

//笔记：先看图，这种图后面有很多，所以，先弄明白图想表达的是什么
    //这一共有四个部分，球形的那个表示是个接口，而它有两个实现类，用虚线表示接口的实现MailSender和SmsSender
    //每个部分底下都有里面对应的方法，现在看代码

//接口
    public interface Sender {   
        public void Send();  
    } 
    
    //实现Mail
    public class MailSender implements Sender {   
        @Override  
        public void Send() {  
            System.out.println("this is mailsender!");  
        }  
    }  
    
    //实现Sms
    public class SmsSender implements Sender {   
    
        @Override  
        public void Send() {  
            System.out.println("this is sms sender!");  
        }  
    }
    
    //工厂类
    public class SendFactory {   
    
        public Sender produce(String type) {  
            if ("mail".equals(type)) {  
                return new MailSender();  
            } else if ("sms".equals(type)) {  
                return new SmsSender();  
            } else {  
                System.out.println("请输入正确的类型!");  
                return null;  
            }  
        }  
    }  
    
    //测试类：
    public class FactoryTest {   
    
        public static void main(String[] args) {  
            SendFactory factory = new SendFactory();  
            Sender sender = factory.produce("sms");  
            sender.Send();  
        }  
    }  
    //输出：this is sms sender!

//笔记：对代码进行分析：一个接口实现两个类，由工厂创建

## 1.2多工厂模式 ##

多工厂模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。关系图：  
![这里写图片描述][SouthEast 2]

//笔记：与普通工厂的区别在于工厂模式里面有两个方法，分别创建新的对象

//工厂类：
    public class SendFactory {  
       public Sender produceMail(){  
            return new MailSender();  
        }  
    
        public Sender produceSms(){  
            return new SmsSender();  
        }  
    }  
    
    //测试类
    public class FactoryTest {  
    
        public static void main(String[] args) {  
            SendFactory factory = new SendFactory();  
            Sender sender = factory.produceMail();  
            sender.Send();  
        }  
    } 
    //其余和工厂类相同

//笔记：
    多工厂的特点在于工厂里面有两个方法，分别进行new对象操作，不用再进行判断
    如果在深入思考一下，这样的好处就是能够将耦合性降低，不需要在判断语句里面加，只需要在工厂里面加方法就行

## 1.3静态工厂模式 ##

将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

//工厂方法
    public class SendFactory {  
    
        public static Sender produceMail(){  
            return new MailSender();  
        }  
    
        public static Sender produceSms(){  
            return new SmsSender();  
        }  
    }  
    //测试类
    public class FactoryTest {  
    
        public static void main(String[] args) {      
            Sender sender = SendFactory.produceMail();  
            sender.Send();  
        }  
    }

//笔记：
    静态工厂很好理解，就是把方法变成了静态方法，这样的好处就是不需要new工厂对象就可以直接创建我们所需要的对象，做了一定的简化。

## 1.4普通工厂模式总结 ##

总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，则不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

# 2.抽象工厂方法模式（Abstract Factory） #

//先不看代码，先理解抽象的含义，抽象的意义在于重用与规划，使用抽象工厂可以将工厂做一个大概的分类，后面直接继承重写方法即可，很方便

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。

![这里写图片描述][SouthEast 3]

图片很好理解，抽象工厂是个接口，由它具体的实现的两个工厂，再用两个工厂具体去new对象。

//对象的抽象类
    public interface Sender {   
        public void Send();  
    }  
    //两个实现类：
    
    public class MailSender implements Sender {   
        @Override  
        public void Send() {  
            System.out.println("this is mailsender!");  
        }  
    }  
    [java] view plaincopy
    public class SmsSender implements Sender {   
    
        @Override  
        public void Send() {  
            System.out.println("this is sms sender!");  
        }  
    }  
    //抽象工厂接口：
    
    public interface Provider {   
        public Sender produce();  
    }  
    
    //两个工厂类：
    
    public class SendMailFactory implements Provider {   
    
        @Override  
        public Sender produce(){  
            return new MailSender();  
        }  
    }  
    
    public class SendSmsFactory implements Provider{   
    
        @Override  
        public Sender produce() {  
            return new SmsSender();  
        }  
    }  
    //测试类：
    
    public class Test {   
    
        public static void main(String[] args) {  
            Provider provider = new SendMailFactory();  
            Sender sender = provider.produce();  
            sender.Send();  
        }  
    }

//笔记：抽象类的特点在于可以有通过继承实现更多的可能

其实这个模式的好处就是，如果你现在想增加一个功能：发即时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现有的代码。这样做，拓展性较好！  
//抽象工厂模式是指围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。  
//感觉这个抽象工厂并没有抽象出来  
//我在另外的博文中看到了另外一种抽象工厂的使用方式：

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

//这个就将工厂也抽象出来了，我们的工厂类也是继承一个抽象工厂类

# 3.单例模式（Singleton） #

单例对象（Singleton）是一种常用的设计模式。  
在Java应用中，**单例对象能保证在一个JVM中，该对象只有一个实例存在。**这样的模式有几个好处：

*  1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
 *  2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
 *  3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（有些流程必须只有一个对象来完成）  
    （比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

**首先我们写一个简单的单例类：**

public class Singleton {  
    
        /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */  
        private static Singleton instance = null;  
    
        /* 私有构造方法，防止被实例化 */  
        private Singleton() {  
        }  
    
        /* 静态工程方法，创建实例 */  
        public static Singleton getInstance() {  
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }  
    
        /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
        public Object readResolve() {  
            return instance;  
        }  
    }

//笔记：
        //这个方法的思路在于：将构造器私有化，防止外界通过构造器实例化，然后通过静态工厂方法调用构造方法创建实例并且导入到实例的静态量中
        //这其中还是容易有疑问的，因为是静态工厂方法，所以，任何对象都可以调用，且调用的都是同一个，那么，是怎么凸显单例的特性的呢？
        //单例的特点在于，整个应用中这个实例的对象只有一个。
        //那么就好理解了：因为这个class的对象是静态的，所以，就算多个方法调用了静态工厂方法，无非是将对象的属性等特性改变了，该对象还是一个。

这个类可以满足基本要求，但是，像这样毫无**线程安全保护**的类，如果我们把它放入多线程的环境下，肯定就会出现问题了，如何解决？我们首先会想到对getInstance方法加synchronized关键字，如下：

//因为多线程情况下还是有可能创建出两个实例对象，所以应该给方法上锁
        关于多线程可以看看这篇博客

[多线程][Link 1]

public static synchronized Singleton getInstance() {  
            if (instance == null) {  
                instance = new Singleton();  
            }  
            return instance;  
        }

但是，synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降。

因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。

我们改成下面这个：

public static Singleton getInstance() {  
            if (instance == null) {  
               // synchronized (instance ) { 
            synchronized (Singleton.class) {  
                    if (instance == null) {  
                        instance = new Singleton();  
                    }  
                } 
    
            }  
            return instance;  
        }

//这里使用的 synchronized代码块的上锁方式，只有对象监视器都为instance才会同步  
//其余还是可以异步使用  
//这里原文有点小错误,注释的地方，如果instance为空应该是会报错的，对象监视器是不能为空，按照别人的建议稍微改了一下，但是，，，感觉还是要有问题，这个作者在后面有改进  
//下面有一即时加载的单例方法

1.public class Singleton {  
    2.  
    3.    /* 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载 */  
    4.   private static Singleton instance = null; 
         替换成： 
          private static Singleton instance = new Singleton(); 
    5.  
    6.    /* 私有构造方法，防止被实例化 */  
    7.    private Singleton() {  
    8.    }  
    9.  
    10.    /* 静态工程方法，创建实例 */  
    11.    public static Singleton getInstance() {  
    12.      将 if (instance == null) {  
    13.            instance = new Singleton();  
    14.        }  去掉 
    15.        return instance;  
    16.    }  
    17.  
    18.    /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
    19.    public Object readResolve() {  
    20.        return instance;  
    21.    }  
    22.}

似乎解决了之前提到的问题，将synchronized关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在instance为null，并创建对象的时候才需要加锁，性能有一定的提升。

但是，这样的情况，还是有可能有问题的，看下面的情况：

在Java指令中创建对象和赋值操作是分开进行的，也就是说instance = new Singleton();  
语句是分两步执行的。

但是JVM并**不保证这两个操作的先后顺序**，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。

这样就可能出错了，我们以A、B两个线程为例：

*  a>A、B线程同时进入了第一个if判断
 *  b>A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
 *  c>由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。
 *  d>B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
 *  e>此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。
    
        //结果就是因为JVM的创建机制导致对象未初始化，发生错误

所以程序还是有可能发生错误，其实程序在运行过程是很复杂的，从这点我们就可以看出，尤其是在写多线程环境下的程序更有难度，有挑战性。我们对该程序做进一步优化：

private static class SingletonFactory{           
            private static Singleton instance = new Singleton();           
        }           
    public static Singleton getInstance(){           
            return SingletonFactory.instance;           
        }

实际情况是，单例模式使用内部类来维护单例的实现，**JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。**  
这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题。  
同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。这样我们暂时总结一个完美的单例模式：

public class Singleton {  
    
        /* 私有构造方法，防止被实例化 */  
        private Singleton() {  
        }  
    
        /* 此处使用一个内部类来维护单例 */  
        private static class SingletonFactory {  
            private static Singleton instance = new Singleton();  
        }  
    
        /* 获取实例 */  
        public static Singleton getInstance() {  
            return SingletonFactory.instance;  
        }  
    
        /* 如果该对象被用于序列化，可以保证对象在序列化前后保持一致 */  
        public Object readResolve() {  
            return getInstance();  
        }  
    }

//笔记：在其中加入了内部类，内部类的特点保障了其的单例性
    //这里，简要说说内部类：内部类一般分为四种

其实说它完美，也不一定，如果在构造函数中抛出异常，实例将永远得不到创建，也会出错。

所以说，十分完美的东西是没有的，我们只能根据实际情况，选择最适合自己应用场景的实现方法。

也有人这样实现：因为我们只需要在创建类的时候进行同步，所以只要将创建和getInstance()分开，单独为创建加synchronized关键字，也是可以的：

public class SingletonTest {  
    
        private static SingletonTest instance = null;  
    
        private SingletonTest() {  
        }  
    
        private static synchronized void syncInit() {  
            if (instance == null) {  
                instance = new SingletonTest();  
            }  
        }  
    
        public static SingletonTest getInstance() {  
            if (instance == null) {  
                syncInit();  
            }  
            return instance;  
        }  
    }

考虑性能的话，整个程序只需创建一次实例，所以性能也不会有什么影响。  
补充：采用”影子实例”的办法为单例对象的属性同步更新

public class SingletonTest {  
    
        private static SingletonTest instance = null;  
        private Vector properties = null;  
    
        public Vector getProperties() {  
            return properties;  
        }  
    
        private SingletonTest() {  
        }  
    
        private static synchronized void syncInit() {  
            if (instance == null) {  
                instance = new SingletonTest();  
            }  
        }  
    
        public static SingletonTest getInstance() {  
            if (instance == null) {  
                syncInit();  
            }  
            return instance;  
        }  
    
        public void updateProperties() {  
            SingletonTest shadow = new SingletonTest();  
            properties = shadow.getProperties();  
        }  
    }

*  1、单例模式理解起来简单，但是具体实现起来还是有一定的难度。
 *  2、synchronized关键字锁定的是对象，在用的时候，一定要在恰当的地方使用（注意需要使用锁的对象和过程，可能有的时候并不是整个对象及整个过程都需要锁）。

**到这儿，单例模式基本已经讲完了，结尾处，笔者突然想到另一个问题，就是采用类的静态方法，实现单例模式的效果，也是可行的，此处二者有什么不同？**

首先，静态类不能实现接口。（从类的角度说是可以的，但是那样就破坏了静态了。因为接口中不允许有static修饰的方法，所以即使实现了也是非静态的）
    
    其次，单例可以被延迟初始化，静态类一般在第一次加载是初始化。之所以延迟加载，是因为有些类比较庞大，所以延迟加载有助于提升性能。
    
    再次，单例类可以被继承，他的方法可以被覆写。但是静态类内部方法都是static，无法被覆写。
    
    最后一点，单例类比较灵活，毕竟从实现上只是一个普通的Java类，只要满足单例的基本需求，你可以在里面随心所欲的实现一些其它功能，但是静态类不行。

从上面这些概括中，基本可以看出二者的区别，但是，从另一方面讲，我们上面最后实现的那个单例模式，内部就是用一个静态类来实现的，所以，二者有很大的关联，只是我们考虑问题的层面不同罢了。

两种思想的结合，才能造就出完美的解决方案，就像HashMap采用数组+链表来实现一样，其实生活中很多事情都是这样，单用不同的方法来处理问题，总是有优点也有缺点，最完美的方法是，结合各个方法的优点，才能最好的解决问题！

# 4.建造者模式（Builder） #

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。我们看一下代码：  
还和前面一样，一个Sender接口，两个实现类MailSender和SmsSender。最后，建造者类如下：

//建造类
    public class Builder {  
    
        private List<Sender> list = new ArrayList<Sender>();  
    
        public void produceMailSender(int count){  
            for(int i=0; i<count; i++){  
                list.add(new MailSender());  
            }  
        }  
    
        public void produceSmsSender(int count){  
            for(int i=0; i<count; i++){  
                list.add(new SmsSender());  
            }  
        }  
    }  
    //测试类：
    
    public class Test {  
    
        public static void main(String[] args) {  
            Builder builder = new Builder();  
            builder.produceMailSender(10);  
        }  
    }

//笔记：建造者模式的特点就是批量建造对象，存放在集合中
    //那么，这个的作用是什么：

从这点看出，建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工程模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定。

# 5.原型模式（Prototype） #

原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在Java中，复制对象是通过clone()实现的，先创建一个原型类：

public class Prototype implements Cloneable {   
    
        public Object clone() throws CloneNotSupportedException {  
            Prototype proto = (Prototype) super.clone();  
            return proto;  
        }  
    }

很简单，一个原型类，只需要实现Cloneable接口，覆写clone方法，此处clone方法可以改成任意的名称，因为Cloneable接口是个空接口，你可以任意定义实现类的方法名，如cloneA或者cloneB，因为此处的重点是super.clone()这句话，super.clone()调用的是Object的clone()方法，而在Object类中，clone()是native的，具体怎么实现，我会在另一篇文章中，关于解读Java中本地方法的调用，此处不再深究。在这儿，我将结合对象的浅复制和深复制来说一下，首先需要了解对象深、浅复制的概念：  
浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。  
深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。  
此处，写一个深浅复制的例子：

public class Prototype implements Cloneable, Serializable {   
    
        private static final long serialVersionUID = 1L;  
        private String string;  
    
        private SerializableObject obj;  
    
        /* 浅复制 */  
        public Object clone() throws CloneNotSupportedException {  
            Prototype proto = (Prototype) super.clone();  
            return proto;  
        }  
    
        /* 深复制 */  
        public Object deepClone() throws IOException, ClassNotFoundException {  
    
            /* 写入当前对象的二进制流 */  
            ByteArrayOutputStream bos = new ByteArrayOutputStream();  
            ObjectOutputStream oos = new ObjectOutputStream(bos);  
            oos.writeObject(this);  
    
            /* 读出二进制流产生的新对象 */  
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
            ObjectInputStream ois = new ObjectInputStream(bis);  
            return ois.readObject();  
        }  
    
        public String getString() {  
            return string;  
        }  
    
        public void setString(String string) {  
            this.string = string;  
        }  
    
        public SerializableObject getObj() {  
            return obj;  
        }  
    
        public void setObj(SerializableObject obj) {  
            this.obj = obj;  
        }  
    
    }  
    
    class SerializableObject implements Serializable {  
        private static final long serialVersionUID = 1L;  
    }

要实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象。

//总结：深复制在于全部都改变，所以，需要转换为二进制。

# 6.总结 #

创造模式的五种主要重点在于创造新的类，而区别在于创建的方式不同，工厂模式很好理解，把创建的地方交给工厂，类似Spring的控制反转。

而单列的作用在于安全性，一直只有一个实例。

原型模式的核心就是一个copy,用一个原型克隆出多个案例。

转载自：  
如有转载，请说明出处：[http://blog.csdn.net/zhangerqing][http_blog.csdn.net_zhangerqing]

[SouthEast]: /images/20220530/f22fc5384ed645ba804f3feb5943232f.png
[http_blog.csdn.net_zhangerqing]: http://blog.csdn.net/zhangerqing
[SouthEast 1]: /images/20220530/6f350c3b515342c395497fb9b76ae880.png
[SouthEast 2]: /images/20220530/417de877a4764ee798d3c9d201da4020.png
[SouthEast 3]: /images/20220530/ce32e0343f55438d869e29e0126e0b22.png
[Link 1]: http://blog.csdn.net/zzg19950824/article/details/79376781