设计模式

面向对象设计原则

1、单一职责原则

定义：
一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。
单一职责原则是实现高内聚、低耦合的指导方针，是最简单却最难运用的原则，需要设计人员发现类的不同职责并将其分离

2、开闭原则

定义：
软件实体应当对扩展开放，对修改关闭。
指软件实体应尽量在不修改原有代码的情况下进行扩展。

3、里氏替换原则

定义：
所有引用基类的地方必须能透明地使用其子类的对象。
里氏替换原则表明，在软件中将一个基类对象替换成它的子类对象，程序将不会产生任何错误和异常，反过来则不成立。
在运用里氏替换原则时，应该将父类设计为抽象类或者接口，让子类继承父类或实现父类接口，并实现在父类中声明的方法。

4、依赖倒转原则

定义：
高层模块不应该依赖底层模块，它们都应该依赖抽象。抽象不应该依赖于细节，细节应该依赖于抽象。
依赖倒转原则要求：要针对接口编程，不要针对实现编程。

5、接口隔离原则

定义：
客户端不应该依赖那些它不需要的接口。
在使用接口隔离原则的时候，需要注意控制接口的粒度，接口不能太小，如果太小会导致系统中接口泛滥，不利于维护；接口也不能太大，太大的接口将违背接口隔离原则，灵活性较差，使用起来不方便。

6、合成复用原则

定义：
优先使用对象组合，而不是继承来达到复用的目的。
一般而言，如果两个类之间是”Has-A”关系应使用组合或聚合，如果是”Is-A”关系可使用继承。

7、迪米特法则-又称最少知识原则

定义：
每一个软件单位对其他的单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位

前提

1. 设计模式的目的是在一个软件体系中找到稳定点与变化的点，用设计模式控制好变化
2. 代码设计模式的实现应该是“重构到设计模式”，也就是不应该是为了用某个模式去写代码，而是在代码的优化过程中依照原则重构，便会自然而然的靠近设计模式。

常用方法：

• 静态->动态
• 早绑定->晚绑定
• 继承->组合
• 编译时依赖->运行时依赖
• 紧耦合->松耦合

1.模板模式

1.1.动机

对于某一项任务，它常常有稳定的整体操作结构，但各个子步骤却有很多改变的需求，或者由于固有的原因而无法和任务整体同步实现。

1.2.定义

定义一个操作中的算法的骨架(稳定)，而将一些步骤延迟到子类(变化)中。模板方法使得子类可以复用一个算法的结构即可重定义(override)该算法的某些特定步骤。

1.3.实例

Java web中的Filter类就是这个思想，Filter需要实现的就是init，doFilter，destory。是稳定的，符合方法前提，只是具体实现(尤其是doFilter步骤)会变化。

package javax.servlet;
import java.io.IOException;
public interface Filter {
    void init(FilterConfig var1) throws ServletException;
    void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;
    void destroy();
}

1.4.优点

1. 封装不变部分，扩展可变部分。
2. 提取公共代码，便于维护。
3. 行为由父类控制，子类实现。

2.策略模式

2.1.动机

某些对象使用的算法可能多种多样，经常改变，如果将这些算法都编码到对象中，将会使对象点的异常复杂，而且有时候支持不适用的算法也是一个性能负担。策略模式的目的就是根据需要透明的改变对象的算法，将对象与算法解耦。

2.2.定义

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法，使得他们根据场景可互相替换

2.3.实例

首先假定有下面这种情况:在Calculate这个类中有三种计算方式，我们把这三种全部封装到类里面，使用时就实例化调用，好似没有问题，但是如果现在有一种新的计算方式也要加入这个类，就需要修改了，这违背了开闭原则。应当是对修改关闭，对扩展开放的。

package com.xiao.strategy;
public class Calculate {
    public int add(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }
    public int multi(int a,int b){
        return a*b;
    }
    public static void main(String[] args) {
        new Calculate().add(1,2);
    }
}

于是我们用策略模式修改

• 定义一个计算策略的接口

package com.xiao.strategy;
public interface AbstractCalculate {
    int operation(int a,int b);
}

• 具体的策略来实现这个接口

package com.xiao.strategy;
public class AddCalculate implements AbstractCalculate {
    @Override
    public int operation(int a, int b) {
        return a+b;
    }
}
public class SubCalculate implements AbstractCalculate {
    @Override
    public int operation(int a, int b) {
        return a-b;
    }
}
public class MulCalculate implements AbstractCalculate {
    @Override
    public int operation(int a, int b) {
        return a*b;
    }
}

• 定义一个具体执行策略的类

package com.xiao.strategy;
public class CalculateImpl {
    private AbstractCalculate abstractCalculate;
    public CalculateImpl(AbstractCalculate abstractCalculate) {
        this.abstractCalculate = abstractCalculate;
    }
    public int operation(int a,int b){
        return this.abstractCalculate.operation(a,b);
    }
    public static void main(String[] args) {
        int add = new CalculateImpl(new AddCalculate()).operation(5,10);
        System.out.println("5+10="+add);
        int sub = new CalculateImpl(new SubCalculate()).operation(5,10);
        System.out.println("5-10="+sub);
    }
}

这时，如果要扩展，只需要写新的实现AbstractCalculate这个接口的类就好了。

2.4.优点

1. 算法可以自由切换。
2. 避免使用多重条件判断。
3. 扩展性良好。

3.观察者模式

3.1.动机

在软件建构中，我们需要为某些对象创建一种“通知依赖关系”，————-一个对象(目标对象)的状态发送改变，所有的其他关心对象(观察者对象)都将得到通知。如果这样的依赖关系过于紧密，将使得软件不能很好的抵御变化。

3.2.定义

定义对象键的一种一对多【甚至多对多】(变化)的依赖关系，当一个或多个对象状态发送改变时，所有依赖于这些对象的其他对象的到通知。

3.3.实例

有这么一个简单的情景：一家进口公司和一家出口公司都想同时知道人民币与美元的汇率，以便做出调整。

这个模型中汇率就是被观察的对象，公司是观察的对象，需要知道汇率的变化，最直接的想法是：让汇率对象内部同时维护两家公司，每当汇率变化就通知公司，但是这种想法下，一旦有其他的公司也想知道汇率，就必须要该源码了，显然违背了开闭原则。

上面的设计之所以出问题，在于被观察者内部需要维护变化的具体实现。于是，在观察者模式中，我们就把具体实现变为抽象实现，因为都是公司，我们就提取出公共属性抽象为接口(或抽象类)，由于公司的数量不定(可能添加或删除)，于是我们维护成一个可变长的数组。

Rate接口

package com.xiao.observer;
public interface Rate {
    //添加一个观察者
    void addCompany(Company company);
    //删除一个观察者
    void removeCompany(Company company);
    //查询
    float getRate();
    //改变
    void updateRate(float rate);
    //通知观察者
    void notifyCompanies();
}

Rate具体实现(RMB与Dollar的实现几乎完全一致，只是name不同)

package com.xiao.observer;
import java.util.ArrayList;
import java.util.List;
public class RMBRate implements Rate {
    private List<Company> companies = new ArrayList();
    private float rate;
    private final String name = "人民币";
    public RMBRate(float rate) {this.rate = rate;}
    @Override
    public float getRate() {return rate;}
    @Override
    public void addCompany(Company company) {companies.add(company);}
    @Override
    public void removeCompany(Company company) {companies.remove(company);}
    //一旦发生更新，就通知所有观察者
    @Override
    public void updateRate(float rate) {
        this.rate = rate;
        notifyCompanies();
    }
    @Override
    public void notifyCompanies() {
        for (Company company : companies) {
            company.reflact(this.name,this.getRate());
        }
    }
}

Company具体实现

package com.xiao.observer;
public class InputCompany implements Company {
    @Override
    public void reflact(String name,float updateRate) {
        System.out.println("进口公司："+
                (updateRate>=0?name+"汇率增加"+updateRate:name+"汇率减少"+(-updateRate)));
    }
}
public class OutputCompany implements Company {
    @Override
    public void reflact(String name,float updateRate) {
        System.out.println("出口公司："+
                (updateRate>=0?name+"汇率增加"+updateRate:name+"汇率减少"+(-updateRate)));
    }
}

测试

package com.xiao.observer;
public class ObserverDemo {
    public static void main(String[] args) {
        //初始化汇率
        Rate rmb = new RMBRate(100.0f);
        Rate dollar = new DollarRate(80.0f);
        //初始化公司
        Company inputCompany = new InputCompany();
        Company outputCompany = new OutputCompany();
        //添加观察者
        rmb.addCompany(inputCompany);
        rmb.addCompany(outputCompany);
        dollar.addCompany(inputCompany);
        dollar.addCompany(outputCompany);
        //被观察者做出改变同时通知观察者
        rmb.updateRate(20.0f);
        dollar.updateRate(-10.0f);
    }
}
/**结果：
进口公司：人民币汇率增加20.0
出口公司：人民币汇率增加20.0
进口公司：美元汇率减少10.0
出口公司：美元汇率减少10.0
**/

3.4.优点

1. 观察者和被观察者是抽象耦合的。
2. 建立一套触发机制。

3.5.发布订阅模式与观察者模式

首先：发布订阅模式与观察者模式不同

• 出版者+订阅者 = 观察者模式
• 出版者+中间商+订阅者 = 发布订阅模式

在观察者模式中，出版者与订阅者相互熟知(比如上面的实例：汇率是要让公司知道，公司就是要知道汇率的变化)，观察者模式的目的是通过双方的抽象结合实现松耦合。

而发布订阅模式中，出版者与订阅者完全零耦合，出版者只需要将更新的内容交给中间商，订阅者把想要知道的内容交给中间商，中间商从发布者那里取到后交给订阅者，整个过程发布者和玉订阅者没有接触，完全解耦

• 观察者模式

• 发布订阅模式

从表面上看：

• 观察者模式里，只有两个角色 —— 观察者 + 被观察者
• 而发布订阅模式里，却不仅仅只有发布者和订阅者两个角色，还有一个经常被我们忽略的 —— 中间商

往更深层次讲：

• 观察者和被观察者，是松耦合的关系
• 发布者和订阅者，则完全不存在耦合

从使用层面上讲：

• 观察者模式，多用于单个应用内部
• 发布订阅模式，则更多的是一种跨应用的模式(cross-application pattern)，比如我们常用的消息中间件

4.装饰模式

4.1.动机

在软件组件中，如果责任划分的不清晰，使用基础得到的结果往往是随着需求的变化，子类急剧膨胀，这关键就是划清责任。

4.2.定义

动态(组合)地给一个对象增加一些额外的职责。该模式比审查子类(继承)去扩展父类功能更加灵活(消除重复代码&减少子类个数)。

4.3.实例

被装饰者基类与装饰者共同接口。

package com.xiao.decorater;
public interface Shape {
    void draw();
}

被装饰者基类

package com.xiao.decorater;
public class BackgroundShape implements Shape {
    @Override
    public void draw() {
        System.out.println("有背景了......");
    }
}

装饰者类基类

package com.xiao.decorater;
public abstract class Decorater implements Shape {
    protected Shape shape;
    public Decorater(Shape shape) {
        this.shape = shape;
    }
    @Override
    public void draw(){}
    public abstract void decorate();
}

装饰者类

package com.xiao.decorater;
public class LineDecorater extends Decorater {
    public LineDecorater(Shape shape) {super(shape);}
    @Override
    public void draw() {
        shape.draw();
        decorate();
    }
    public void decorate(){
        System.out.println("画了一条线");
    }
}

package com.xiao.decorater;
public class RentDecorate extends Decorater {
    public RentDecorate(Shape shape) {super(shape);}
    @Override
    public void draw() {
        shape.draw();
        decorate();
    }
    public void decorate(){
        System.out.println("画了一个矩形");
    }
}

package com.xiao.decorater;
public class RedDecorate extends Decorater{
    public RedDecorate(Shape shape) {super(shape);}
    @Override
    public void draw() {
        shape.draw();
        decorate();
    }
    @Override
    public void decorate() {
        System.out.println("染红了......");
    }
}

测试

package com.xiao.decorater;
public class DecoraterDemo {
    public static void main(String[] args) {
        new RedDecorate(
                new LineDecorater(
                        new RentDecorate(
                                new BackgroundShape())
        )).draw();
    }
}
/**结果
有背景了......
画了一个矩形
画了一条线
染红了......
**/

4.4.优点

装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

5.桥接模式

5.1.动机

有时在一个类中会出现不同维度的变化内容，假设这些变化全部定义为抽象实现，那继承这个抽象类时就会出现有时不需要其中一个维度的设置却必须实现，那如果让这个维度有具体实现，那要不就是这个维度固定，要不就是再多些几个同样的类。显然不合适。

5.2.定义

桥梁模式的用意是“将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化”。对于两个甚至多个对变化的维度，使用桥接模式十分合适

5.3.实例

有如下要求：要绘制一个图形，可能是矩形或圆，这个图形的颜色可以是红色或绿色。

将颜色抽象出来

package com.xiao.bridge;
public interface Color {
    String paint();
}

颜色具体实现

package com.xiao.bridge;
public class GreenColor implements Color {
    @Override
    public String paint() {
        return "绿色";
    }
}

package com.xiao.bridge;
public class RedColdr implements Color {
    @Override
    public String paint() {
        return "红色";
    }
}

抽象对象（有颜色与形状两个维度）

package com.xiao.bridge;
public abstract class Shape {
    private Color color;
    public Shape(Color color) {
        this.color = color;
    }
    public Color getColor() {
        return color;
    }
    public abstract void draw();
}

抽象对象拓展

package com.xiao.bridge;
public class CircleShape extends Shape {
    public CircleShape(Color color) {
        super(color);
    }
    @Override
    public void draw() {
        System.out.println("一个"+this.getColor().paint()+"的圆");
    }
}

package com.xiao.bridge;
public class RentShape extends Shape {
    public RentShape(Color color) {
        super(color);
    }
    @Override
    public void draw() {
        System.out.println("一个"+this.getColor().paint()+"的矩形");
    }
}

测试

package com.xiao.bridge;
public class BridageDemo {
    public static void main(String[] args) {
        Shape rent = new RentShape(new RedColdr());
        Shape circle = new CircleShape(new GreenColor());
        rent.draw();
        circle.draw();
    }
}
/**结果
一个红色的矩形
一个绿色的圆
**/

5.4.优点

1. 抽象和实现的分离。
2. 优秀的扩展能力。
3. 实现细节对客户透明。

5.5.理解

为什么这个模式要叫桥接模式？

我的理解：

这个类中有多个维度的独立的内容，我们讲这些维度都定义为一个个的接口，这些接口就是“桥”，桥一端连接具体实现，一端连接抽象对象，通过这个“桥”把类中内容的具体实现扩展到类的外面，用户操作时使用不同维度的接口就可以了，不用关心具体的实现，这就不仅实现了解耦，也实现了高扩展性，实现了复用。

6.工厂模式

6.1.动机

• 客户只知道创建产品的工厂名，而不知道具体的产品名。
• 创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口。
• 客户不关心创建产品的细节，只关心产品的品牌

6.2.定义

工厂模式实现将对象实例封装到一个工厂中，用户在使用时，只需要知道对象的最终接口类和名称即可。

6.3.实例

对象最终接口

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 Circle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

工厂

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 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();
   }
}
/**结果
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
**/

6.4.优点

• 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
• 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
• 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

7.抽象工厂

7.2.动机

工厂模式是为了解决某一类对象实例化的屏蔽，比如用户需要的是上衣，那我们搞一个工厂，将所有的上衣实例放在工厂中，让用户去取。但有时我们会面临“一系列相互依赖的对象”的创建，比如现在用户不仅要上衣，还要裤子，鞋子等，显然把他们全部放在一个工厂里面是不合适的。这是我们就可以搞一个超级工厂->生产不同种类的工厂的工厂，这个工厂不生产具体某一种产品，所以叫做抽象工厂。

7.2.定义

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足以下条件。

• 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
• 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

7.3.实例

第一产品接口

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 Circle implements Shape {
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

第二类产品接口

public interface Color {
   void fill();
}

第二类产品实体

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.");
   }
}
public class Blue implements Color {
   @Override
   public void fill() {
      System.out.println("Inside Blue::fill() 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 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();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      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 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();
   }
}
/**结果
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.
**/

7.4.优点

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
• 抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

7.5.问题

抽象工厂模式的扩展有一定的“开闭原则”倾斜性：

1. 当增加一个新的产品族时只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则。
2. 当产品族中需要增加一个新种类的产品时，则所有的工厂类都需要进行修改，不满足开闭原则。

8.原型模式

8.1.动机

在软件系统中，经常面临“某些结构复杂的对象”的创建工作；由于需求的变化，这些对象经常面临较大的变化，但是它们却拥有比较稳定一致的接口。

8.2.定义

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。java直接就有原型模式的实现，就是clone方法。

8.3.实例

java克隆分为两种：

• 浅克隆
• 深克隆

• 首先要克隆的对象必须实现Clonable接口，并且重写clone方法
• 如果对象属性中没有其他对象，直接克隆就是深克隆，但是如果有，直接clone就是浅克隆，对象内部的其他对象没有完成克隆，要想实现深克隆，不仅要依赖类实现Clonable接口，重写clone方法，在当前克隆对象类中clone重写是要对依赖对象克隆重置。
• String类型由于字符串常量池的存在，无法实现深克隆.

Student类

package com.xiao.prototype;
public class Student implements Cloneable{
    private int id;
    private String name;
    private int age;
    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public int getId() { return id;}
    public void setId(int id) { this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public int getAge() {return age; }
    public void setAge(int age) {this.age = age;}
    @Override
    protected Student clone() throws CloneNotSupportedException {
        return (Student)super.clone();
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试

package com.xiao.prototype;
public class ProtoDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        //创建对象
        Student xiao = new Student(1, "xiao", 18);
        System.out.println(xiao.toString());
        //克隆
        Student clone = xiao.clone();
        //判断是否相同
        System.out.println(clone==xiao);
        //修改克隆对象的属性
        clone.setId(2);
        clone.setName("yun");
        clone.setAge(19);
        //前后比较
        System.out.println(clone);
        System.out.println(xiao);
    }
}
/**结果
Student{id=1, name='xiao', age=18}
false
Student{id=2, name='yun', age=19}
Student{id=1, name='xiao', age=18}
**/

含有其他对象的对象深克隆实现

Teacher类

package com.xiao.prototype;
public class Teacher implements Cloneable{
    private int id;
    private String name;
    private Student student;
    public Teacher(int id, String name, Student student) {
        this.id = id;
        this.name = name;
        this.student = student;
    }
    public int getId() { return id;}
    public void setId(int id) {this.id = id;}
    public String getName() { return name;}
    public void setName(String name) {this.name = name;}
    public Student getStudent() {return student;}
    public void setStudent(Student student) {this.student = student;}
    @Override
    protected Teacher clone() throws CloneNotSupportedException {
        Teacher clone = (Teacher)super.clone();
        clone.setStudent(this.getStudent().clone());
        return clone;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", student=" + student +
                '}';
    }
}

   @Override
   protected Teacher clone() throws CloneNotSupportedException {
       Teacher clone = (Teacher)super.clone();
       clone.setStudent(this.getStudent().clone());
       return clone;
   }

如果要深克隆clone的重写需要设置依赖对象的clone。

测试

package com.xiao.prototype;
public class ProtoDemo2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher teacher = new Teacher(1, "张三", new Student(1, "xiao", 18));
        Teacher clone = teacher.clone();
        System.out.println(clone.getStudent() == teacher.getStudent());
    }
}
/**结果
false
**/

8.4.优点

• Java 自带的原型模式基于内存二进制流的复制，在性能上比直接 new 一个对象更加优良。
• 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份，并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作。

9.建造者模式

9.1.动机

在软件系统中，有时会面临“一个复杂对象的创建”，其通常各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分进程要面对较大的变化，但是将他们组合起来的算法比较固定

9.2.定义

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。如java的StringBuilder。

9.3.模式1

经典的建造者模式下有四个角色:

1. 抽象建造者（builder）：描述具体建造者的公共接口，一般用来定义建造细节的方法，并不涉及具体的对象部件的创建。
2. 具体建造者（ConcreteBuilder）：描述具体建造者，并实现抽象建造者公共接口。
3. 指挥者（Director）：调用具体建造者来创建复杂对象（产品）的各个部分，并按照一定顺序（流程）来建造复杂对象。
4. 产品（Product）：描述一个由一系列部件组成较为复杂的对象。

这种模式适用于这个复杂对象的结构比较固定，比如要建一栋楼，确定了有五层。那用户只需要告诉指挥者每一层的细节要求，指挥者就会按照要求完成建造。

实例

就模拟造一栋四层的楼。

产品

package com.xiao.builder1;
public class Product {
    private String floor0;
    private String floor1;
    private String floor2;
    private String floor3;
    public Product() {
    }
    public Product(String floor0, String floor1, String floor2, String floor3) {
        this.floor0 = floor0;
        this.floor1 = floor1;
        this.floor2 = floor2;
        this.floor3 = floor3;
    }
    public String getFloor0() {return floor0;}
    public void setFloor0(String floor0) {this.floor0 = floor0;}
    public String getFloor1() {return floor1;}
    public void setFloor1(String floor1) {this.floor1 = floor1;}
    public String getFloor2() {return floor2;}
    public void setFloor2(String floor2) {this.floor2 = floor2;}
    public String getFloor3() {return floor3;}
    public void setFloor3(String floor3) {this.floor3 = floor3;}
    @Override
    public String toString() {
        return "Product{" +
                "floor0='" + floor0 + '\'' +
                ", floor1='" + floor1 + '\'' +
                ", floor2='" + floor2 + '\'' +
                ", floor3='" + floor3 + '\'' +
                '}';
    }
}

抽象工厂

package com.xiao.builder1;
public abstract class AbstractBuilder {
    protected Product product;
    public abstract AbstractBuilder buildFloor0();
    public abstract AbstractBuilder buildFloor1();
    public abstract AbstractBuilder buildFloor2();
    public abstract AbstractBuilder buildFloor3();
    public Product getProduct(){
        return this.product;
    }
}

具体工厂

package com.xiao.builder1;
public class ProductBuilder extends AbstractBuilder {
    public ProductBuilder() {
        this.product = new Product();
    }
    @Override
    public AbstractBuilder buildFloor0() {
        product.setFloor0("地下室建好了");
        return this;
    }
    @Override
    public AbstractBuilder buildFloor1() {
        product.setFloor1("第一层建好了");
        return this;
    }
    @Override
    public AbstractBuilder buildFloor2() {
        product.setFloor2("第二层建好了");
        return this;
    }
    @Override
    public AbstractBuilder buildFloor3() {
        product.setFloor3("第三层建好了");
        return this;
    }
}

指挥者

package com.xiao.builder1;
public class Director {
    private AbstractBuilder abstractBuilder;
    public Director(AbstractBuilder builder) {
        this.abstractBuilder = builder;
    }
    public Product direct(){
        abstractBuilder.buildFloor0();
        abstractBuilder.buildFloor1();
        abstractBuilder.buildFloor2();
        abstractBuilder.buildFloor3();
        return abstractBuilder.getProduct();
    }
}

测试

package com.xiao.builder1;
public class Builder1Demo {
    public static void main(String[] args) {
        Product product = new Director(new ProductBuilder()).direct();
        System.out.println(product);
    }
}
/**结果
Product{floor0='地下室建好了', floor1='第一层建好了', floor2='第二层建好了', floor3='第三层建好了'}
**/

9.4.模式2

有一些情况下，一个复杂的对象的组成是不固定的，比如String类型，一个字符串里面可能包含任意东西，这就代表建造者无法确定产品的结构，当然只要给要求，建造者还是可以建造，只是由于结构不确定，指挥者就没法按照预定的计划指挥了。这时指挥者就不需要了，用户直接与建造者对接，用户给要求，建造者按照要求在产品基础上建造。这就是第二种模式，只需要三个角色

1. 产品
2. 抽象建造者
3. 具体建造者

实例

现在要建造一间房屋，需要的有家具，喷漆，装饰

Rome

package com.xiao.builder2;
import java.util.ArrayList;
import java.util.List;
public class Rome {
    //家具
    private List<String> furniture;
    //喷漆颜色
    private String color;
    //装饰(可以没有)
    private List<String> decorate;
    public Rome() {
        this.furniture = new ArrayList<>();
        this.decorate = new ArrayList<>();
    }
    public Rome(List<String> furnitures, String color, List<String> decorate) {
        this.furniture = furnitures;
        this.color = color;
        this.decorate = decorate;
    }
    public List<String> getFurnitures() {return furniture;}
    public void setFurnitures(List<String> furnitures) { this.furniture = furnitures;}
    public String getColor() {return color;}
    public void setColor(String color) {this.color = color;}
    public List<String> getDecorate() {return decorate;}
    public void setDecorate(List<String> decorate) {this.decorate = decorate;}
    @Override
    public String toString() {
        return "Rome{" +
                "furniture=" + furniture +
                ", color='" + color + '\'' +
                ", decorate=" + decorate +
                '}';
    }
}

抽象建造者

package com.xiao.builder2;
public abstract class AbstractBuilder {
    public abstract AbstractBuilder addFurniture(String oneFurniture);
    public abstract AbstractBuilder removeFurniture(String oneFurniture);
    public abstract AbstractBuilder setColor(String newColor);
    public abstract AbstractBuilder addDecoration(String oneDecoration);
    public abstract AbstractBuilder removeDecoration(String oneDecoration);
    public abstract Rome getRome();
}

具体建造者

package com.xiao.builder2;
public class RomeBuilder extends AbstractBuilder{
    private Rome rome;
    public RomeBuilder(Rome rome) {
        this.rome = rome;
    }
    @Override
    public AbstractBuilder addFurniture(String oneFurniture) {
        rome.getFurnitures().add(oneFurniture);
        return this;
    }
    @Override
    public AbstractBuilder removeFurniture(String oneFurniture) {
        for(String furinture:rome.getFurnitures()){
            if (!oneFurniture.equals(furinture)){
                continue;
            }
            else {rome.getFurnitures().remove(oneFurniture);}
        }
        return this;
    }
    @Override
    public AbstractBuilder setColor(String newColor) {
        this.rome.setColor(newColor);
        return this;
    }
    @Override
    public AbstractBuilder addDecoration(String oneDecoration) {
        this.getRome().getDecorate().add(oneDecoration);
        return this;
    }
    @Override
    public AbstractBuilder removeDecoration(String oneDecoration) {
        for(String decotate:rome.getDecorate()){
            if (!oneDecoration.equals(decotate)){
                continue;
            }
            else {rome.getDecorate().remove(oneDecoration);}
        }
        return this;
    }
    @Override
    public Rome getRome() {
        return this.rome;
    }
}

测试

package com.xiao.builder2;
public class Builder2Demo {
    public static void main(String[] args) {
        Rome rome = new RomeBuilder(new Rome()).setColor("蓝色")
                .addFurniture("沙发").addFurniture("椅子")
                .addDecoration("壁画").addDecoration("花")
                .getRome();
        System.out.println(rome);
    }
}
/**结果
Rome{furniture=[沙发, 椅子], color='蓝色', decorate=[壁画, 花]}
**/

9.5.优点

1、产品的建造和表示分离，实现了解耦。

2、将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰

3、增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则“。

10.单例模式

10.1.动机

在软件系统中，经常有一些特殊的类，必须保证他们在系统中只能存在一个实例，才能确保它们的逻辑正确性，以及良好的效率。

10.2.定义

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

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

10.3.6种实现

1.懒汉式，线程不安全

• 是否 Lazy 初始化：是
• 是否多线程安全：否
• 实现难度：易

这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

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

问题所在：单线程下没有问题，如果是多线程，会出现线程A进入第6行后还未执行第七行线程B也进入了第六行判断通过，就会实例化两个了。

2.懒汉式，线程安全

• 是否 Lazy 初始化：是
• 是否多线程安全：是
• 实现难度：易

• 这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
• 优点：第一次调用才初始化，避免内存浪费。
• 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

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

问题所在：synchronized是悲观锁，多线程是一定是一条一条的进入，但是很多时候对这个实例的访问只是“读操作”，这样就会对性能有影响。

3.饿汉式

• 是否 Lazy 初始化：否
• 是否多线程安全：是
• 实现难度：易

• 这种方式比较常用，但容易产生垃圾对象。
• 优点：没有加锁，执行效率会提高。
• 缺点：类加载时就初始化，浪费内存。

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

问题所在：它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

4.原始双检锁DCL

• 是否 Lazy 初始化：是
• 是否多线程安全：有概率不安全[指令重构问题]
• 实现难度：较复杂

public class Singleton {  
    private static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        if (singleton == null) {  
            singleton = new Singleton();  
        }  
        }  
    }  
    return singleton;  
    }  
}