设计模式总结

设计模式

强烈推荐这个网站，设计模式讲的很好！：http://c.biancheng.net/view/1376.html
常见的设计模式：
创建型：单例模式，简单工厂模式，工厂方法模式，抽象工厂模式，建造者模式，原型模式
结构型：代理模式，适配器模式，装饰器模式
行为型：模板方法模式，观察者模式，迭代器模式

创建型

单例模式

确保一个类只有一个实例【该单例对象必须由单例类自行创建】，并提供该实例的全局访问点。使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。
适用场景：

• 需要频繁创建的一些类，使用单例可以降低系统的内存压力，减少 GC。
• 频繁访问数据库或文件的对象。
• 某类需要频繁实例化，而创建的对象又频繁被销毁的时候，如多线程的线程池、网络连接池等。

简单工厂模式

创建一个对象时不向客户暴露内部细节，在工厂类中提供一个创建对象的通用接口，包含必要的逻辑判断，工厂类根据参数来决定创建哪一个产品的实例。这样客户端无需知道所创建具体产品的类名，只需知道参数即可【解耦】【进一步可以引入配置文件，从而不用修改客户端代码】。
角色组成：简单工厂+抽象产品+具体产品
适用场景：产品种类相对较少的情况。

public class SimpleFactory { 
	public Product createProduct(int type) { 
		if (type == 1) { 
			return new ConcreteProduct1(); 
		} else if (type == 2) { 
			return new ConcreteProduct2(); 
		}
		return new ConcreteProduct(); 
	} 
}
// 客户端调用
SimpleFactory simpleFactory = new SimpleFactory(); 
Product product = simpleFactory.createProduct(1);

工厂方法模式

定义了一个创建对象的接口，但由子类（继承自工厂Factory类）决定要实例化哪个类。工厂方法把实例化操作推迟到子类。【使用了继承】
角色组成：抽象工厂+简单工厂+抽象产品+具体产品

public abstract class Factory {
	abstract public Product factoryMethod();
}
public class ConcreteFactory extends Factory { 
	public Product factoryMethod() { 
		return new ConcreteProduct(); 
	} 
}
public class ConcreteFactory1 extends Factory { 
	public Product factoryMethod() { 
		return new ConcreteProduct1(); 
	} 
}

抽象工厂模式

提供一个接口，用于创建 相关的对象家族，抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象。【使用了组合】
角色组成：抽象工厂【包含多个创建产品的方法】+简单工厂+抽象产品+具体产品
适用场景：当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。

public abstract class AbstractFactory { 
	abstract AbstractProductA createProductA(); 
	abstract AbstractProductB createProductB(); 
}
public class ConcreteFactory1 extends AbstractFactory { 
	AbstractProductA createProductA() { 
		return new ProductA1(); 
	}AbstractProductB createProductB() { 
		return new ProductB1(); 
	} 
}public class ConcreteFactory2 extends AbstractFactory { 
	...
}

建造者模式

将一个复杂的对象分解为多个简单的对象，然后一步一步构建，产品的组成部分是不变的，但每一部分是可以灵活选择的，使得同样的构建过程可以创建不同的表示。建造者模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成。
适用场景：产品类非常复杂，由多个部件或零件组成，不同的组合方式，产生的结果不相同。

class Product {		// 产品：包含多个组成部件的复杂对象
    private String partA;
    private String partB;
    private String partC;
    public void setPartA(String partA) {
        this.partA = partA;
    }
    public void setPartB(String partB) {
        this.partB = partB;
    }
    public void setPartC(String partC) {
        this.partC = partC;
    }
    public void show() {
        //显示产品的特性
    }
}
abstract class Builder {	// 抽象建造者：包含创建产品各个子部件的抽象方法
    //创建产品对象
    protected Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    //返回产品对象
    public Product getResult() {
        return product;
    }
}
public class ConcreteBuilder extends Builder {	// 具体建造者：实现了抽象建造者接口
    public void buildPartA() {
        product.setPartA("建造 PartA");
    }
    public void buildPartB() {
        product.setPartB("建造 PartB");
    }
    public void buildPartC() {
        product.setPartC("建造 PartC");
    }
}
class Director {	// 指挥者：调用建造者中的方法完成复杂对象的创建。
    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    //产品构建与组装方法
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

原型模式

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。这是因为，在有些系统中，存在大量相同或相似对象的创建问题，如果用传统的构造函数来创建对象，会比较复杂且耗时耗资源【比如，进行大量的数据库操作才能创建一个对象】，用原型模式生成对象就很高效【java中实现 Cloneable 接口，覆盖clone() 方法就可以实现复制啦~】。
适用场景：对象之间相同或相似，且创建对象成本较大，例如初始化时间长，占用CPU太多，或者占用网络资源太多，或者需要繁琐的数据准备或访问权限等。
缺点：clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。

//具体原型类
class Realizetype implements Cloneable {
    Realizetype() {
        System.out.println("具体原型创建成功！");
    }

    public Object clone() throws CloneNotSupportedException {
        System.out.println("具体原型复制成功！");
        return (Realizetype) super.clone();
    }
}
//原型模式的测试类
public class PrototypeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Realizetype obj1 = new Realizetype();
        Realizetype obj2 = (Realizetype) obj1.clone();
        System.out.println("obj1==obj2?" + (obj1 == obj2));
    }
}

结构型

描述如何将类或对象按某种布局组成更大的结构

代理模式

增加一个代理对象作为访问对象【客户端】和目标对象之间的中介，客户端通过代理间接地访问目标对象，从而限制、增强或修改该对象的一些特性。代理模式分为静态代理和动态代理。静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。动态：在程序运行时，运用反射机制动态创建而成。【JDK动态代理需要实现InvocationHandler，覆盖它的invoke(Object proxy, Method method, Object[] args)方法。Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this)】
主要角色：抽象主题+真实主题+代理
应用场景：一是保护目标对象，二是增强目标对象。

适配器（Adapter）模式

将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种。
主要角色：目标接口【所期待的接口】+适配者【被访问的组件接口】+适配器【转换器，把适配者接口转换成目标接口】
应用场景：使用第三方提供的组件，但组件接口定义和自己要求的接口定义不同。以前开发的系统存在满足新系统功能需求的类，但其接口同新系统的接口不一致。
对象适配器模式：

package adapter;
//对象适配器类
class ObjectAdapter implements Target
{
    private Adaptee adaptee;
    public ObjectAdapter(Adaptee adaptee)
    {
        this.adaptee=adaptee;
    }
    public void request()
    {
        adaptee.specificRequest();
    }
}
//客户端代码
public class ObjectAdapterTest
{
    public static void main(String[] args)
    {
        System.out.println("对象适配器模式测试：");
        Adaptee adaptee = new Adaptee();
        Target target = new ObjectAdapter(adaptee);
        target.request();
    }
}

桥接（Bridge）模式

将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现的，从而降低了抽象和实现这两个可变维度的耦合度。

装饰（Decorator）模式

在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。
主要角色：抽象构件 + 具体构件 + 抽象装饰 + 具体装饰。
应用场景：装饰器模式在 Java 中的最著名的应用莫过于 Java I/O 标准库的设计了。例如，InputStream 的子类 FilterInputStream，OutputStream 的子类 FilterOutputStream，Reader 的子类 BufferedReader 以及 FilterReader，还有 Writer 的子类 BufferedWriter、FilterWriter 以及 PrintWriter 等，它们都是抽象装饰类。

package decorator;
public class DecoratorPattern {
    public static void main(String[] args) {
        Component p = new ConcreteComponent();
        p.operation();
        System.out.println("---------------------------------");
        Component d = new ConcreteDecorator(p);
        d.operation();
    }
}

//抽象构件角色
interface Component {
    public void operation();
}

//具体构件角色
class ConcreteComponent implements Component {
    public ConcreteComponent() {
        System.out.println("创建具体构件角色");
    }

    public void operation() {
        System.out.println("调用具体构件角色的方法operation()");
    }
}

//抽象装饰角色
class Decorator implements Component {    // 实现了构件
    private Component component;

    public Decorator(Component component) {	 // 传入了被装饰的构件对象 
        this.component = component;
    }

    public void operation() {
        component.operation();
    }
}

//具体装饰角色
class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    public void operation() {
        super.operation();		// 原有的被装饰的构件的功能还在呢~
        addedFunction();		// 我还装饰【新增加】了其他的方法呢~
    }

    public void addedFunction() {
        System.out.println("为具体构件角色增加额外的功能addedFunction()");
    }
}

外观（Facade）模式

为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。

享元（Flyweight）模式

运用共享技术来有效地支持大量细粒度对象的复用。

组合（Composite）模式

将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。

行为型

行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。

模板方法（Template Method）模式

定义一个操作中的算法骨架，封装了不变部分，扩展可变部分，将算法的一些步骤延迟到子类中，使得子类在可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
主要角色：模板类（包括模板方法+具体方法【已实现】+抽象方法【未实现】） + 具体子类

public class TemplateMethodPattern {
    public static void main(String[] args) {
        AbstractClass tm = new ConcreteClass();
        tm.TemplateMethod();
    }
}

//抽象类
abstract class AbstractClass {
    //模板方法
    public void TemplateMethod() {	// 这就是算法骨架！具体的子类根据需求自己实现对应的方法。
        SpecificMethod();
        abstractMethod1();
        abstractMethod2();
    }

    //具体方法
    public void SpecificMethod() {
        System.out.println("抽象类中的具体方法被调用...");
    }

    //抽象方法1
    public abstract void abstractMethod1();

    //抽象方法2
    public abstract void abstractMethod2();
}

//具体子类
class ConcreteClass extends AbstractClass {
    public void abstractMethod1() {
        System.out.println("抽象方法1的实现被调用...");
    }

    public void abstractMethod2() {
        System.out.println("抽象方法2的实现被调用...");
    }
}

策略（Strategy）模式

定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。

命令（Command）模式

将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。

职责链（Chain of Responsibility）模式

把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。

状态（State）模式

允许一个对象在其内部状态发生改变时改变其行为能力。

观察者（Observer）模式

多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。又称为发布-订阅模式、模型-视图模式。
主要角色：抽象主题+具体主题+抽象观察者+具体观察者
代码思想：在被观察的对象中使用集合保存所有的观察者对象，当对象发生变化时，遍历集合中的每一个观察者，调用观察者的反应方法。
应用场景：实现类似广播机制的功能。

//抽象目标
abstract class Subject {
    protected List<Observer> observers = new ArrayList<Observer>();		
    //增加观察者方法
    public void add(Observer observer) {
        observers.add(observer);
    }
    //删除观察者方法
    public void remove(Observer observer) {
        observers.remove(observer);
    }
    public abstract void notifyObserver(); //通知观察者方法
}
//具体目标
class ConcreteSubject extends Subject {
    public void notifyObserver() {
        System.out.println("具体目标发生改变...");
        System.out.println("--------------");
        for (Object obs : observers) {
            ((Observer) obs).response();
        }
    }
}
//抽象观察者
interface Observer {
    void response(); //反应
}

中介者（Mediator）模式

定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。

迭代器（Iterator）模式

在现实生活以及程序设计中，经常要访问一个聚合对象中的各个元素，如“数据结构”中的链表遍历，通常的做法是将链表的创建和遍历都放在同一个类中，但这种方式不利于程序的扩展，如果要更换遍历方法就必须修改程序源代码，这违背了 “开闭原则”。
迭代器模式在客户访问类与聚合类之间插入一个迭代器，这分离了聚合对象与其遍历行为，对客户也隐藏了其内部细节，且满足“单一职责原则”和“开闭原则”，如 Java 中的 Collection、List、Set、Map 等都包含了迭代器。

访问者（Visitor）模式

在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。

备忘录（Memento）模式

在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。

解释器（Interpreter）模式

提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。