设计模式概述及详解-持续更新

(一)简单工厂模式和工厂模式

客户端提供一个条件给工厂，工厂根据条件返回客户端需要的对象。

它根据客户端传入的参数，生成不同的对象，调用对象的方法。

简单工厂模式中可以通过反射机制来简化if…else或switch的大量繁琐引用。

它的调用如下：

Calc add = CalcFactory.createCalc("add");
calc.calc(2,5);
Calc reduce = CalcFactory.createCalc("add");
calc.calc(6,5);

它的基本思想结构图如下：



工厂模式是简单工厂模式的一种扩展，一个工厂生产一个对象，符合设计模式的开闭原则。简单工厂模式是工厂模式的一种简单版本，不属于23种设计模式之一，工厂模式是创建型模式的一种。

AddFactory addFactory = new AddFactory();
Calc add=addFactory.createCalc();
add.calc(2,5);
ReduceFactory reduceFactory = new ReduceFactory();
Calc reduce=reduceFactory.createCalc();
reduce.calc(5,2);

它的基本思想结构图如下：



详解：http://blog.csdn.net/chijiandi/article/details/78841861

(二)抽象工厂模式

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

如果产品少而且基本不变动，用简单工厂模式。

如果产品单一，用工厂方法模式。

如果产品丰富，用抽象工厂模式。

抽象工厂模式引入了一个产品族与产品等级结构的概念。

它的基本思想结构图如下：



与工厂方法模式相比较，由一个具体工厂生产一个具体产品转化为一个具体工厂生产多个具体产品。

客户端的调用如下：

calcFactory = new AddFactory();
TwoNumberCalc twoAdd = calcFactory.createTwo();
ThreeNumberCalc threeAdd = calcFactory.createThree();

calcFactory = new MultiplyFactory();
TwoNumberCalc twoMultiply = calcFactory.createTwo();
ThreeNumberCalc threeMultiply = calcFactory.createThree();

详解：http://blog.csdn.net/chijiandi/article/details/78957827

(三)建造者模式

建造者模式将一个复杂的对象的具体构建过程封装，将构建与表示分离，使同一种构建方式能够创建不同的表现。

工厂模式是将不同产品的构建过程封装，而建造者模式是将同一产品的不同表示封装，他们都属于创建型模式，更关注于对象的创建。

建造者模式在这样的情况下使用：

1.当产品类的内部结构较复杂，不容易构建或易出错。

2.产品之间的属性相互依赖，即对产品的构造顺序有要求，

客户端通过一个指挥者类创建对象

PersonDirector pd = new PersonDirector();
Person person = pd.constructPerson(new FatPerson());
System.out.println(person.getHead()+person.getTummy()+person.getHand()+person.getFoot()+"的人");

详解：http://blog.csdn.net/chijiandi/article/details/79138991

(四)单例模式

对某个类来说，其实例化对象有且仅有一个，并只提供一个创建它的方式。

对于单例模式的写法很多，概述为

懒汉单例模式

饿汉单例模式

双重校验锁

静态内部类

枚举

详解：http://blog.csdn.net/chijiandi/article/details/78834661

(五)原型模式

原型模式就是从一个对象创建出另一个对象，而不必知道他的创建细节。或者可以把原型模式叫做-克隆。被复制的对象被叫做-原型。

原型模式分成浅复制和深复制。

浅复制是指复制了对象，数值类型的会直接复制，但是引用类型的变量复制的是对象的引用，所以浅复制对对象引用类型的改变也导致原对象的引用类型也同时改变，所以这被称作浅复制。

深复制的复制则代表产生一个新的与原有对象无关的复制对象。

深复制与浅复制的用法区别在深复制需要对类中用到的引用类型同时进行一次复制，需要引用类型也重写克隆方法。在克隆的类中同时调用引用类型的克隆方法。

@Override
protected Object clone() throws CloneNotSupportedException {
Resume resume = (Resume) super.clone();
resume.experience = (Experience) experience.clone();
return resume;
}

详解：http://blog.csdn.net/chijiandi/article/details/79235363

(六)策略模式

客户端提供一个对象策略给Context环境类,Context根据策略调用方法。

使用方法如下：

calcContest = new CalcContest(new AddStrategy());
int addResult = calcContest.getResult(3, 2);
calcContest = new CalcContest(new ReduceStrategy());
int reduceResult = calcContest.getResult(3, 2);

策略模式是一种行为模式，它根据客户端传入的对象，实施不同的策略，再调用具体的行为。与简单工厂模式的不同在简单工厂根据参数暴露了对象给客户端，策略模式根据策略暴露具体的方法，但是要求客户知道策略的名称，可与与工厂模式一起使用。

详解：http://blog.csdn.net/chijiandi/article/details/78949373

(七)适配器模式

当开发后期，两个功能相似的接口因为都不太容易改，或当调用别人类似功能的接口时，通过适配器模式返回客户端一致的接口。

比如两个接口分别是：

void SayChinese();

void SayEnglish();

那么创建一个适配器Translator翻译 实现sayChinese接口

private English english;
public Translator (English english){
this.english=english;
}
public void sayChinese(){
english.sayEnglish();
}

最后的实现效果即为：

People a = new Chinese();
Translator b = new Translator b(new English());
a.sayChinese();
b.sayChinese();


通俗的说就是把sayEnglish让适配器以sayChinese的形式展示给客户端。

详解：http://blog.csdn.net/chijiandi/article/details/78839376

(八)代理模式
代理模式把客户端不容易进行交互的类通过代理与之进行交互

简单的代理运用可以理解为代购买东西，别人看到的是代购买了很多东西，代购其实花的是你的钱买东西。

代理模式是开放-封闭原则的具体实现之一。

可以理解为，代理扩展了原类的方法而不改变原类，

又或者说，代理保护了原类。

我将其放在适配器模式下是因为他们有一些地方比较像

以下是代理类

/**
* @ClassName: Proxy
* @Description: 代购，帮Person买苹果
* @author cjd
* @date 2017年12月18日 下午5:02:49
*/
public class Proxy implements BuyApple {
private Person person;
public Proxy(Person buyer) {
this.person = buyer;
}
@Override
public void buyApple() {
System.out.println("出国");
person.buyApple();
System.out.println("回国把苹果8交给" + person.getName());
}
}


其中同样内置了一个对象，可代理模式是在实现Person的原功能下进行扩展，

而适配器模式是将一个接口转换成另一个接口，当类的功能多了，两者的差异也会变大。

详解：http://blog.csdn.net/chijiandi/article/details/78838885