【设计模式】初探设计模式

经典设计模式:
1. 创建型
单例模式(Singleton)
工厂模式(Factory)
生成器模式(Builder)
原型模式(Prototype)


2.结构型:
适配器模式(Adapter)
桥接模式(Bridge)
组合模式(Composite)
装饰器模式(Decorator)
门面模式(Facade)
享元模式(Flyweight)
代理模式(Proxy)


3.行为型:
职责链模式(Chain of Resposibility)
命令模式(Command)
解析器模式(Interpreter)
迭代器模式(Iterator)
中介模式(Mediator)
备忘录模式(Memento)
观察者模式(Observer)
状态模式(State)
策略模式(Strategy)
模板方法(Template Method)

访问者模式(Visitor)

 

 

1. 面向接口与抽象类
	Interface:思考顺序, Abstract:顺序+共享
	(1)柔性多态:(削弱字父类多态函数的关联性)
		Interface:{
			int query(String);//查询转发方法id
			Object dispatch(int methodId, Object args); //分支转发特有方法
		}
		Class:{
			private String[]methods;
			int query(method){
				return Arrays.binarySearch(methods,method);
			}
			Object dispatch(methodId,args){
				switch(methodId){
					case 0:return XX(args);
					case 1:return YY();
					default:return null;
				}
			}
		}
	(2)反射:自动加载 java.lang.reflect.*;
		获取Class对象:Class classObj = Class.forName("ClassName");//ClassName.class|obj.getClass();
		获取构造器:Constructor[]cons = classObj.getConstructors();//队:先写的下标更大
			生成类对象:obj = cons[0].newInstance(new Object[]{"string",2016});
		获取方法:Method f = classObj.getMethod("functionName",new Class[]{String.class,Integer.class});
			调用某对象方法: f.invoke(obj,new Object[]{"string",2016});
		获取字段:Field[]fields = classObj.getDeclaredFields();//所有声明字段
			获取某对象字段: fields[0].get(obj);
	
	(3)配置文件(*.properties , *.xml)
		Properties是Hashtable的子类(java.util.Hashtable)
		构造配置对象:Properties property = new Properties();
		加载配置文件:property.load(new FileInputStream(".\\system.properties"));
		获取键的值:String val = property.getProperty("key");//还可set键值后store保存
		Ps:	对于*.properties文件,格式:key=value
			对于*.xml文件(使用loadFromXML(inputStream)加载),格式如下:
			<?xml version="1.0" encoding="utf-8">
			<!DOCTYPE properties SYSTEM "http://java.sun/dtd/properties.dtd" >
			<properties>
				<comment>一条文件配置说明注释</commet>
				<entry key=class>ClassName</entry>
			</properties>
	
	最后:	利用反射("加载接口+构造对象")便于系统功能模块拓展(反射耗时大);
			利用配置文件系统自动运行;
			
经典设计模式:
1. 创建型
单例模式(Singleton)
	说明:程序的整个生命周期始终保持某个对象的唯一性
	目标:所有该对象的引用指向同一地址
	实现:
	私有化构造器;
	持有一个指向本类的字段,在类加载时初始化(饿汉式);
	提供一个getInstance方法返回对象地址;
	
工厂模式(Factory)
	说明:生成一系列的产品,它们有共通点但又各有不同;
	目标:该设计使得拓展新产品对原有代码冲击减少;
	实现:
	IProduct:产品接口,实际一系列的产品继承自该接口;
	IFactory:工厂接口,每个产品对应一个工厂,new出工厂后调用create方法创建产品;
	
生成器模式(Builder)
	说明:生成一个复杂的对象,它的内部有对象及其组合关系;
	目标:封装对象生成的过程,避免对象内部错误;
	实现:
	IProduct:产品接口,具体产品类实现该接口;
	IBuilder:创建器接口,该接口提供了产品创建方法(create()),具体创建器封在产品类内部,封装配件组装;
	ProductDirector:产品创建导航工具类,提供一个静态工具方法,根据传递过来的构造器参数创建产品对象

原型模式(Prototype)
	说明:解决在运行中根据已有对象生成新对象;
	目标:深度拷贝某个对象,使得对象之间互不干扰
	实现:
	实现Cloneable接口;
	复写clone方法(super.clone返回本身的浅拷贝对象);

2.结构型:
适配器模式(Adapter)
	说明:在旧功能的基础上满足新需求,使得类功能兼容
	目标:组合新旧类,类适配器Adapter继承Adaptee,对象适配Adapter持有Adaptee
	实现:
	Target:新需求
	Adapter:新功能实现类
	Adaptee:旧功能实现类

桥接模式(Bridge)
	说明:用于多维可变状态的设计
	目标:抽象部分和实现部分分离,可以各维独立变化;
	实现:
	Abstraction:抽象部分,持有实现部分对象的引用
	Implementor:实现部分,封装功能实现的方法,参数引用抽象部分对象

组合模式(Composite)
	说明:对于树形结构,结点类型不同导致操作不同;
	目标:把结点组合成统一类型进行处理;
	实现:
	Component:同一类接口,封装不同类型结点功能方法的并集;
	Composite:非叶子结点,复写自己的功能方法;
	Leaf:终端结点,对于不适用的方法抛出RuntimeException异常;
	
装饰器模式(Decorator)
	说明:已有数据处理功能,需要对处理数据修饰后再执行处理功能;
	目标:在不使用派生的基础上灵活地添加功能
	实现:
	Implementor:最高接口封装功能调用方法,所有类实现该接口;
	Decorator:装饰抽象类,持有一个接口引用;
	ImplementorX:旧有的数据处理功能类;
	DecoratorX:数据修饰类,继承自装饰器抽象类;

门面模式(Facade)
	说明:给一个复杂的子系统提供一个便于操作的API
	目标:给不需要定制的用户一个默认API,需要定制的用户可绕过这层门面;
	实现:
	Facade:门面类,维护一系列的服务接口对象引用;
	IService:服务接口,所有服务类的最高接口;
	ServiceX:具体服务类,实现服务接口;
	
享元模式(Flyweight)
	说明:一个数据中转,保存了大量细粒度的对象供系统共享;
	目标:减少不必要的系统内存开销;
	实现:
	IFlyweight:享元接口,提供分享的方法;
	ConcreteFlyweight:享元实现类,实现具体方法;
	UnShareConcreteFlyweight:不分享的类,把ConcreteFlyweight作为一个字段封装;
	FlyweightFactory:内部持有一个hashmap,保存了所有分享元,提供(静态)方法获取享元;

代理模式(Proxy)
	说明:代理类和实现类实现同一接口,代理转发功能请求;
	目标:分离客户对象和原始对象,由代理对象控制原始对象;
	实现:
	ISubject:代理和功能对象的接口;
	SubImp:功能类;
	SubProxy:代理类,持有一个功能类的对象引用,转发功能方法;
	
	
3.行为型:
职责链模式(Chain of Resposibility)
	说明:一个事件需要响应,每个对象都有响应的机会,知道事件被处理;
	目标:对于事件处理,解耦它的发送者和请求者;
	实现:
	定义事件响应辅助类,把所有可以处理事件的对象在逻辑上排列成一个队列;
	把消息发送给事件响应类;

命令模式(Command)
	说明:发布者(Invoker)通过'请求者'(Command) 控制 '接收者'(Recevier)的动作;
	目标:解耦请求者和接收者,使得易于支持请求排队/记录以及动作撤销,方便'请求/响应对'拓展
	实现:
	Invoker:发布者,持有一个请求器;
	AbsCommand:请求封装器,持有一个接收者(Receiver)响应对象,excute调用receiver的响应方法;
	Receiver:响应者,封装一个响应方法(receive),实现动作响应;
	
解析器模式(Interpreter)
	说明:对于一个命令,需要解释执行(对于一个高级语言的解释转换);
	目标:不对命令直接进行语法树解析,而是先转换后解析;
	实现:
	IExpress:命令接口,提供interpret方法原型;
	SimpleExpress:简单命令,实现简单的interpret方法;
	AdvanceExpress:高级命令,实现复杂的interpret方法;

迭代器模式(Iterator)
	说明:访问一个聚合对象的内容无需暴露它内部实现;
	目标:遍历不同的聚合结构,提供一个统一接口(多态迭代);
	实现:
	List:聚合对象接口;
	ListImp:聚合实现类;
	Iterator:迭代器接口;
	ListImp.ListIterator:迭代器实现类,一般持一个list对象;

中介模式(Mediator)
	说明:中介对象持有各同事(colleague)对象,封装这些对象的通信交互;
	目标:中介者使各对象不需要显式引用,使得其耦合松散,并可独立改变它们的交互;
	实现:
	Mediator:中介者接口,提供一个notice方法;
	ConcreteMediator:具体中介类,维护各个同事,协调同事行为;
	Colleague:同事接口;
	
备忘录模式(Memento)
	说明:对于有多个状态的对象,保存某个时刻的状态,并且在需要时候可以恢复状态;
	目标:在不破坏封装的情况下,保存/恢复对象的状态;
	实现:
	Memento:备忘录对象,内部持有一个状态对象;
	Originator:状态原发器,对状态的类;
	Caretaker:负责保护备忘录,不能检查不能修改;
	
观察者模式(Observer)
	说明:对象存在一对多的关系,当对象状态被改变时,通知多个对象;
	目标:一个抽象模型存在两个方面,一方面依赖于另一方面,分开封装降低耦合;
	实现:
	Subject:跟踪目标,持有一个状态和一些观察者;
	IObserver:跟踪者接口,封装action动作方法(推消息/拉消息);
	ConcreteObserver:具体跟踪者;
	

状态模式(State)
	说明:某个对象有N个状态,需要对不同状态及其转换进行处理;
	目标:把状态封装成一个接口,一种状态对应一个对象;
	实现:
	Context:和客户端相关的类,持有一个状态引用;
	IState:状态接口;
	ConcreteState:具体状态,实现了IState接口;

策略模式(Strategy)
	说明:定义一系列的算法封装起来,使得他们可以互相替换;
	目标:使得算法可以独立于使用者而变化;
	实现:
	Context:持有一个策略引用和一个callMethod方法;
	IStrategy:策略接口,提供一个method;
	ConreteStrategy:具体实现method方法;
	
模板方法(Template Method)
	说明:对于固定不变的算法,提取到父类中,变化的部分实现延迟到子类;
	目标:对方法的实现不需要改变算法结构就可以改变算法的具体内容;
	实现:
	TemplateMethod:父抽象类,变化的步骤抽象化,由子类复写实现;
	ConcreteTemplate:子实现类,复写应该改变的部分;
	
访问者模式(Visitor)
	说明:对于类中数据,需要对数据添加新操作;
	目标:对于结构很少变动的类,该类数据被共享,在不改变类结构的情况下对数据添加新操作(visitXXX);
	实现:
	Visible:可访问接口,实现一个accept(Visitor vis)方法,所有共享元素实现该接口;
	Element:元素类,实现accept为vis.visitXXX(this);
	Vistor:访问接口,封装一下访问方法(新操作);
	ConcreteVisitor:新操作的具体实现;