常见设计模式

一、概念

所谓设计模式，就是一套被人反复使用的代码设计经验的总结。

使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

二、设计模式总览

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

创建型模式（5 种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。

结构型模式（7 种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。

行为型模式（11 种）：策略模式，模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，状态模式，

                                          备忘录模式，访问者模式，中介者模式，解释器模式

三、常见模式（自认为/见得多的）详解

1、工厂方法模式：一个抽象工厂可以产生多个具体工厂，每个具体工厂都产生一种具体产品。

例如：一个抽象工厂 运算工厂 类，产生具体工厂（加减乘除）四个类，有四个类实现具体的加减乘除运算（具体产品），

而这四个类都继承一个抽象类 运算类。参考实例

2、抽象工厂模式：与工厂方法非常相似，但是更抽象、更一般，主要用于产品族。

例如：一个抽象工厂产生具体工厂A、B，工厂A可以生产产品 Plant 和 Fruit ，产品 Plant 又分 PlantA 和 PlantB，Fruit 产品同样分A、B。

B 工厂同 A 工厂。参考实例

区别： 参考文章

3、单例模式

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例

单例模式有很多种写法：参考文章

4、适配器模式

分为类的适配器模式和对象的适配器模式

适配器模式把一个类的接口转换成客户希望的接口（适配的类的 API 转换为目标类的 API）。

类的适配器模式中适配器类继承被适配的类，实现目标类

对象的适配器模式与类的适配器模式不同的是它不使用继承关系连接到被适配器类，而是使用委派关系。

package pattern_adapter;
//被适配器类
public class Adaptee {
	public void method1(){}
}

package pattern_adapter;
//目标类
public interface Target {
	public void method1();
	public void method2();
}

package pattern_adapter;
//类适配器
public class Adapter_class extends Adaptee implements Target{
	public void method2(){
		
	}
}

package pattern_adapter;
//对象适配器
public class Adapter_object {
	private Adaptee adaptee;
	
	public Adapter_object(Adaptee adaptee){
		this.adaptee = adaptee;
	}
	
	public void method1(){			//直接委派
		this.adaptee.method1();
	}
	
	public void method2(){}
}

package pattern_adapter;

public class Demo {
	public static void main(String[] args) {
/*		Adapter_class ac = new Adapter_class();
		
		ac.method1();
		ac.method2();*/
		
		Adaptee adaptee = new Adaptee();
		Adapter_object ao = new Adapter_object(adaptee);
		
		ao.method1();
		ao.method2();
	}
}

这个测试类并没有什么输出，因为方法是空的。

5、装饰器模式

装饰器模式实现动态地给对象添加功能，是从一个对象外部给对象添加功能。

package pattern_decorator;
//定义被装饰者
public interface Human {
	public void doHomework();
	public void entertainment();
}

package pattern_decorator;
//定义装饰者
public abstract class Decorator implements Human{
	private Human human;
	
	public Decorator(Human human){
		this.human = human;
	}
	
	public void doHomework(){
		human.doHomework();
	}
	
	public void entertainment(){
		human.entertainment();
	}
}

package pattern_decorator;
//第一种装饰
public class Decorator1 extends Decorator{
	public Decorator1(Human human){
		super(human);
	}
	
	public void football(){
		System.out.println("play football");
	}
	
	public void mathWork(){
		System.out.println("do homework of math");
	}
	
	public void doHomework(){
		super.doHomework();
		mathWork();
	}
	
	public void entertainment(){
		super.entertainment();
		football();
	}
}

package pattern_decorator;

public class Decorator2 extends Decorator{
	public Decorator2(Human human){
		super(human);
	}
	
	public void basketball(){
		System.out.println("play basketball");
	}
	
	public void englishWork(){
		System.out.println("do homework of english");
	}
	
	public void doHomework(){
		super.doHomework();
		englishWork();
	}
	
	public void entertainment(){
		super.entertainment();
		basketball();
	}
}

package pattern_decorator;
//定义被装饰者，初始状态拥有自身的装饰
public class Person implements Human{
	public void doHomework(){
		System.out.println("有什么作业");
	}
	
	public void entertainment(){
		System.out.println("休息一下");
	}
}

package pattern_decorator;

public class Demo {
	public static void main(String[] args) {
		Human person = new Person();
		
		Decorator decorator = new Decorator2(new Decorator1(person));
		
		decorator.doHomework();
		decorator.entertainment();
	}
}

6、代理模式

为其他对象提供一种代理，以控制对这个对象的访问。

组成：

抽象角色：通过接口或抽象类声明真实角色实现的业务方法。

代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

package pattern_proxy;
//抽象角色
public interface Network {

	public void browse();
	
}

package pattern_proxy;
//代理角色
public class Proxy implements Network{
	public Network network;
	
	public Proxy(Network network){
		this.network = network;
	}
	
	public void check(){
		System.out.println("检查用户是否合法");
	}
	
	public void browse(){
		this.check();
	}
}

package pattern_proxy;
//真实角色
public class Real implements Network{
	public void browse(){
		System.out.println("上网浏览信息");
	}
}

package pattern_proxy;

public class Demo {
	public static void main(String[] args) {
		Network net = null;
		net = new Proxy(new Real());
		net.browse();
	}
}

7、观察者模式

在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫

各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。

可以使用 Java util 包中的 Observable ；也可以自己写。

参考文章