设计模式

1 目的：降低依赖，降低耦合。

  解耦，修改、增加部分，不影响其他。如继承。

  依赖倒转原则:真对接口编程，依赖于抽象而不依赖于具体。
  开闭原则就是说对扩展开放，对修改关闭。实现“开-闭”原则的关键步骤就是抽象化。
  接口隔离原则:使用多个隔离的接口，比使用单个接口要好。降低耦合度。
  里氏代换原则：父类和子类继承实现抽象化。
  迪米特法则（最少知道原则）：尽量少的与其他实体之间发生相互作用，使系统功能模块   相对   独立。
 合成/聚合复用原则：优先使用对象的合成/聚合将有助于你保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小的规模，并且不太可能增长为不可控制的庞然大物。

 

2、  不要忘记oo的目标，设计能达到oo的目标就行，到时候我们的设计自然往模式上靠拢。模式是达到oo目标的途径之一而已。最终的目的是为了让我们的程序更加符合oo的设计原则

 

3 常用的设计模式：

单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要目的是保持内存中只有1个对象。

 

工厂模式：主要功能是统一提供实例对象的引用。比如工厂里封装一个map

简单工程模式：根据不同的参数创建不同的对象。接口+实现+factory类create方法（if判断）

 

策略模式：

门面模式 ：像是Service层的一个翻版

 

代理模式：为其他对象提供一种代理以达到控制对这个对象的访问

场景：如 对于买家,也就是接口的调用者而言, 我并不关心你到底是代理商还生产商,我只要你能够跟我交易就可以. 从这角度理解的话,代理隔离了调用者和实现者直接的联系.

代理模式中，有三种角色：
抽象角色：声明真实对象和代理对象的共同接口
代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象

 

 

动态代理handler:

public class SecurityHandler implements InvocationHandler {
	//对真实角色的引用 
        private Object targetObject;
        //通过真实角色（目标对象）生成代理角色。
      	public Object newProxy(Object targetObject) {
		this.targetObject = targetObject;
           //targetObject.getClass().getInterfaces()真实角色需要实现接口。
		return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
				targetObject.getClass().getInterfaces(), this);
	}



	private void checkSecurity() {
		System.out.println("----------checkSecurity()------------");
	}


	//代理对象方法调用InvocationHandler方法，回调目标方法。
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		checkSecurity();
		Object ret = null;
		try {
	            //利用反射机制动态调用被代理对象的方法
                    ret = method.invoke(this.targetObject, args);
		} catch (Exception e) {
			e.printStackTrace();
			throw new java.lang.RuntimeException(e);
		}
		return ret;
	}
}

可以这么使用：工厂模式里面封装hashMap,get时候首先从map中取值。如果为null,去创建代理对象。

 

状态模式：当一个对象内在改变时允许其改变行为，这个对象看起来像改变了其类。

 

装饰器模式：实际上在一定程度上解决了一个问题, 那就是类继承的局限性,类爆炸. 由于这些装饰是可以随意组合的, 那么比如我又新添了一个装饰,那我就又要新增 N个子类.

 

 Observer 设计模式角色：Observer是观察者角色，Observable是被观察目标(subject)角色。

主题继承java.util.Observable,运行时（如main方法）添加订阅者 addObserver(Observer o) ，改变时候通知订阅者：this.setChanged();this.notifyObservers();

订阅者实现java.util.Observer接口，实现update(Observable o, Object arg)方法来接收通知。

代码参考百科：http://baike.baidu.com/link?url=6CVRK2f_OVb6g_Na6PsUemJERPrT7lWPMx6ns8tfVJZ5CJpT_GG5jcdky9P-kzbSFW0nzOpQZHgHuD9OtrZGga

 

适配器模式（Adapter），将一个类的接口转换成客户希望的另一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

如果开始能尽量保持规范一致，后期通过小的重构可以解决的，不需要用适配器模式。

 

备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可将该对象恢复到原先保存的状态。

场景：保持历史状态，可撤销恢复到以前的状态。

三个角色：发起人，备忘录（需要保存的状态），备忘录管理者（持有备忘录）

 

组合模式（Composite），将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性

场景：当你发现需求中是体现部分与整体层次的结构时，以及你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时，就应该考虑使用组合模式了。如：公司部门结构。

 

迭代器模式（Iterator）,提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露该对象的内部表示。

为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。

场景：java语言已经集成，如： Iterator<Integer> iterator = list.iterator();

 

桥接模式：实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这种多角度分离出来让它们独立变化，减少它们之间的耦合。

盲目使用继承会造成麻烦，因为继承是一种强耦合的结构，父类变，子类就必须要变。一定要是'is-a'的关系时候才使用继承。

场景：如pc硬件和软件