设计模式（个人理解版）

创建型模式：共5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式 结构型模式：共7种：适配器模式、装饰器模式、代理模式、桥接模式、外观模式、组合模式、享元模式 行为型模式：共11种：策略模式、模板方法模式、观察者模式、责任链模式、访问者模式、中介者模式、迭代器模式、命令模式、状态模式、备忘录模式、解释器 ————————————————

工厂方法：接口：汽车工厂 实现类：宝马工厂、奔驰工厂

抽象工厂：接口：发动机 实现类：发动机A 发动机B

接口：空调 实现类：空调A 空调B

接口：工厂【制造发动机、空调】 实现类：宝马1（发动机A 空调B） 宝马2（发动机B 空调A）

单例：

//懒汉式单例类.在第一次调用的时候实例化自己 
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

建造者==原型模式：

（1）原型模式比 new 方式创建对象的性能要好的多，因为 Object 类的 clone() 方法是一个本地方法，直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显；

（2）简化对象的创建；原型模式适合在重复地创建相似对象的场景使用，比如在一个循环体内创建对象

Object 类的 clone() 方法只会拷贝对象中的基本的数据类型（8种基本数据类型 byte,char,short,int,long,float,double,boolean 和对应的封装类），对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。

深拷贝：把要克隆的对象所引用的对象都克隆了一遍

接口：Cloneable 实现类：Prototype

类：ShallowClone继承Prototype

浅拷贝：

public class ShallowClone extends Prototype {
    @Override
    public Prototype clone(){
        Prototype prototype = null;
        try {
            prototype = (Prototype)super.clone();
        }
        catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return prototype;
    }

深拷贝：

public class DeepClone extends Prototype {
    @SuppressWarnings("unchecked")
    @Override
    public Prototype clone() {
        Prototype prototype = null;
        try {
            prototype = (Prototype)super.clone();
        }
        catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        //区别 要把引用也拷贝
        prototype.list = (ArrayList<String>) this.list.clone();
        return prototype;
    }

适配器： 一个插座，只可以插欧洲的插头，有一个亚洲的插头，需要用适配器转接

三种：类、对象、接口

1、已有的类、方法【只能插欧洲插头的插座】：Adaptee

2、目标接口【可以插亚洲插头的插座】：target【中间者】

实现类【适配器类】：Adapter extends Adaptee imple target

装饰器：

*装饰者与被装饰者都拥有共同的超类，但这里继承的目的是继承类型，而不是行为。*

接口：Human 方法：穿衣服【被装饰者】

装饰器类：Decorator 继承 Human

   abstract class Decorator implements Human
{
​    private Human human;

   public Decorator(Human human)
   {
       this.human = human;
  }
   @Override
 ​    public void wearClothes()
 ​    {//这个的意思是什么
 ​        human.wearClothes();
 ​    }
 }

Decorator1 继承Decorator 增加进房子的方法

Decorator2 继承Decorator 增加去衣柜的方法

Decorator3 继承Decorator 增加找衣服的方法

普通类：Person继承Human

代理模式：某天你看到一位女生，一见钟情，心里发誓要她做你女朋友，但是你想这样直接上去可能会唐突了。于是你采用迂回政策，先和她室友搞好关系，然后通过她室友给她礼物，然后……。

首先出现的就是美女一枚：BeautifulGirl 属性：她的名字

接口：送礼物 方法：送花、送巧克力、送车

普通类：我继承送礼物

代理类：美女的闺蜜

   public class HerChum implements GiveGift{
	//重点
    You you;
    public HerChum(BeautifulGirl mm){
       you = new You(mm);}

桥接模式：

假如你有一个几何形状Shape类，从它能扩展出两个子类： 圆形Circle和 方形Square 。 你希望对这样的类层次结构进行扩展以使其包含颜色，所以你打算创建名为红色Red和蓝色Blue的形状子类。 但是， 由于你已有两个子类， 所以总共需要创建四个类才能覆盖所有组合， 例如 蓝色圆形Blue­Circle和 红色方形Red­Square 。 我们可以将颜色相关的代码抽取到拥有 红色和 蓝色两个子类的颜色类中， 然后在 形状类中添加一个指向某一颜色对象的引用成员变量

接口：颜色 实现类：红色、蓝色

抽象类：形状，颜色是他的成员变量 抽象方法：

普通类：圆形、方形继承 形状

外观模式：

实现类:CPU 方法：开机、关机

Memory 方法：开机、关机

Disk 方法：开机、关机

电脑-》成员：CPU Memory Disk

方法：开机、关机

主类：new 电脑就可以了

组合模式：

文件夹-文件-删文件/添加文件/修改文件

类：文件 属性：名字 方法：展示

类：文件夹 继承 文件 方法：删除、添加

类：具体文件 继承 文件 方法：重写展示

享元模式：

数据库连接池、线程池等都是用享元模式的应用。

假如我们有一个绘图的应用程序，通过它我们可以出绘制各种各样的形状、颜色的图形，那么这里形状和颜色就是内部状态了，通过享元模式我们就可以实现该属性的共享了。

抽象类：shape

具体类：圆形 继承 shape

享元类： 享元工厂

//核心类 public class FlyweightFactory{ static Map<String, Shape> shapes = new HashMap<String, Shape>();

public static Shape getShape(String key){
    Shape shape = shapes.get(key);
    //如果shape==null,表示不存在,则新建,并且保持到共享池中
    if(shape == null){
        shape = new Circle(key);
        shapes.put(key, shape);
    }
    return shape;
}
​public static int getSum(){
    return shapes.size();
}

main:

1. Shape shape1 = FlyweightFactory.getShape("红色");

2. shape1.draw();

策略模式：

刘备要到江东娶老婆了，走之前诸葛亮给赵云三个锦囊妙计，说是按天机拆开能解决棘手问题。场景中出现三个要素：三个妙计（具体策略类）、一个锦囊（环境类）、赵云（调用者）。

接口：策略 方法：行动的方法

三个实现类，都继承策略，并重写方法

环境类：Context ，策略是成员变量

模板方法模式：准备去学校所要做的工作（prepareGotoSchool）为例，假设需要分三步：穿衣服（dressUp），吃早饭（eatBreakfast），带上东西（takeThings）。学生和老师要做得具体事情肯定有所区别

//抽象类定义整个流程骨架
public abstract class AbstractPerson{
     //模板方法，使用final修改，防止子类改变算法的实现步骤
     public final void prepareGotoSchool(){
          dressUp();
          eatBreakfast();
          takeThings();
     }
     //以下是不同子类根据自身特性完成的具体步骤
     protected abstract void dressUp();
     protected abstract void eatBreakfast();
     protected abstract void takeThings();
}

实现类：学生、教师都继承AbstractPerso