设计模式笔记.doc

设计模式(Design Pattern)的原则1、开闭原则模块应对扩展开放，而对修改关闭。（最最核心的原则）2、里氏代换原则如果调用的是父类的话，那么换成子类也完全可以运行。里氏代换原则是继承复用的一个基础。子类 overload方法的访问权限不能小于父类对应方法的访问权限3、合成复用原则要少用继承，多用合成关系来实现。（合成包括：组合，聚合）4、依赖倒转原则抽象不应该依赖与细节，细节应当依赖与抽象。 要针对接口编程，而不是针对实现编程。传递参数，或者在组合聚合关系中，尽量引用层次高的类。5、接口隔离原则每一个接口应该是一种角色，不多不少，不干不该干的事，该干的事都要干。（单一职责）6、抽象类好的继承关系中，只有叶节点是具体类，其他节点应该都是抽象类，也就是说具体类是不被继承的。将尽可能多的共同代码放到抽象类中。7、迪米特法则最少知识原则。不要和陌生人说话。创建型设计模式简单工厂(静态工厂方法Static Factory Method模式)简单工厂模式是由一个工厂对象来决定创造哪一种产品类的实例简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断。/产品接口-水果接口public interface Fruit public void plant();/产品-苹果类public class Apple implements Fruitpublic void plant() System.out.println(plant apple!);/产品-草莓类public class Strawberry implements Fruitpublic void plant() System.out.println(plant Strawberry!);/工厂异常类public class BadFruitException extends Exceptionpublic BadFruitException(String msg) super(msg); /调用父类的构造方法 /工厂-园丁类public class FruitGardener /静态工厂方法 public static Fruit factory(String which) throws BadFruitException if (which.equalsIgnoreCase(apple) return new Apple(); else if(which.equalsIgnoreCase(strawberry) return new Strawberry(); else throw new BadFruitException(Bad fruit request); /测试类public class TestApp private void test(String fruitName) try Fruit f = FruitGardener.factory(fruitName); System.out.println(恭喜!生产了一个水果对象: + fruitName); catch (BadFruitException e) System.out.println(工厂目前不能生产产品: + fruitName);System.out.println(e.getMessage();/输出异常信息 public static void main(String args) TestApp t = new TestApp(); t.test(apple); t.test(strawberry); t.test(car); /此处会抛异常,水果工厂能生产car(轿车)吗! 工厂方法(Factory Method)定义一个用于创建对象的接口，让子类决定实例哪一个类。工厂方法使一个类的实例化延迟到其子类。在工厂方法模式中，核心的工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做。这个核心工厂则变为抽象工厂角色，仅负责给出工厂子类必须实现的接口，而不接触哪一产品创建的细节。工厂方法模式可以用来允许系统不修改具体工厂角色的情况下引进新产品在工厂方法模式中，一般都有一个平行的等级结构，抽象工厂对应抽象产品，具体工厂对应具体产品/水果工厂public interface FruitGardener /工厂接口 public Fruit factory();/苹果工厂public class AppleGardener implements FruitGardener /工厂方法 public Fruit factory() Fruit f = new Apple(); System.out.println(水果工厂成功创建一个水果：苹果！); return f; /草莓工厂public class StrawberryGardener implements FruitGardener /工厂方法 public Fruit factory() Fruit f = new Strawberry(); System.out.println(水果工厂成功创建一个水果：草莓！); return f;/测试类(客户端)public class TestApp private FruitGardener f1, f2, f3;private Fruit p1, p2, p3; private void test() /实力化水果工厂 f1 = new AppleGardener(); f3 = new StrawberryGardener(); /从水果工厂生产水果 p1 = f1.factory(); p3 = f3.factory(); public static void main(String args) TestApp test = new TestApp(); test.test(); 抽象工厂模式(AbstractFactory)每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结果。产品族：是指位于不同产品等级结构中，功能相关联的产品组成的家族。一般是位于不同的等级结构中的相同位置上。每一个产品等级结构中有多少个具体的产品，就有多少个产品族，也就会在工厂等级结构中发现多少个具体工厂。一般而言，有多少个产品等级结构，就会在工厂角色中发现多少个工厂方法。具体工厂(工厂类)中有工厂方法(工厂类中的方法)图： 抽象工厂在农场系统中的应用：/ 两种抽象产品(两个结构等级)：水果、蔬菜interface Fruit interface Veggie / 四种具体产品：北方水果，热带水果，北方蔬菜，热带蔬菜/ Northern Fruitclass NorthernFruit implements Fruit private String name;NorthernFruit(String name) String getName() return name;void setName(String name) = name;/ TropicalFruitclass TropicalFruit implements Fruit private String name;TropicalFruit(String name) String getName() return name;void setName(String name) = name;/ NorthernVeggieclass NorthernVeggie implements Veggie private String name;NorthernVeggie(String name) String getName() return name;void setName(String name) = name;/ TropicalVeggieclass TropicalVeggie implements Veggie private String name;TropicalVeggie(String name) String getName() return name;void setName(String name) = name;/ 抽象工厂角色public interface Gardener public Fruit createFruit(String name);public Veggie createVeggie(String name);/ 具体工厂角色：北方工厂，热带角色class NorthernGardener implements Gardener Fruit createFruit(String name) return new NorthernFruit(name);Veggie createVeggie(String name) return new NorthernVeggie(name);class TropicalGardener implements Gardener Fruit createFruit(String name) return new TropicalFruit(name);Veggie createVeggie(String name) return new TropicalVeggie(name);class TestApp private void test() Veggie tv, nv;Fruit tf, nf;TropicalGardener tg = new TropicalGardener();NorthernGardener ng = new NorthernGardener();tv = tg.createVeggie(热带菜叶);nv = ng.createVeggie(东北甜菜);tf = tg.createFruit(海南椰子);nf = ng.createFruit(雪梨);public static void main(String args) TestApp test = new TestApp();test.test();建造者模式原型模式单例模式(Singleton)在一个系统要求一个类只有个实例时才应当使用单例模式单例类(singleton)可以保证系统中只可能由该类的一个对象，而且这个对象由类自行初始化懒汉式单例类public class LazySingleton private static LazySingleton singleton=null;private LazySingleton()/静态工场方法使用了同步化，以处理多线程环境。synchronized public static LazySingleton getInstance()if(singleton=null)singleton=new LazySingleton();return singleton;(1)这个类被加载时，静态变量singleton会被初始化，此时类的私有构造器会被调用,单例类的惟一实例就被创建出来了。(2)Java语言中单例类的个最重要的特点是类的构造于是私有的，从而避免外界利用构造子直接创建出任意多的实例。由于构造于是私有的，因此此类不能被继承。饿汉式单例类class EagerSingletonprivate static final EagerSingleton singleton=new EagerSingleton();private EagerSingleton()public static EagerSingleton getInstance()return singleton;(1)单从资源利用效率角度来讲，这个比懒汉式单例类稍差些从速度和反应时间角度来讲，则比懒汉式单例类稍好。(2)然而，懒汉式单例类在实例化时，必须处理好在多个线程同时首次引用此类时的访问限制问题，特别是当单例类作为资源控制器在实例化时必然涉及资源初始化而资源初始化很有可能耗费时间。这意味着出现多线程同时首次引用此类的几率变得较大。结构型模式适配器模式桥接模式(Bridge)将抽象部分与实现部分分离，使它们都可以独立的变化。在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度的变化”？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就要使用Bridge模式。效果及实现要点：(1)Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。(2)Bridge模式的应用一般在“两个非常强的变化维度”，有时候即使有两个变化的维度，但是某个方向的变化维度并不剧烈换言之两个变化不会导致纵横交错的结果，并不一定要使用Bridge模式。拿汽车在路上行驶的来说。即有小汽车又有公共汽车，它们都不但能在市区中的公路上行驶，也能在高速公路上行驶。这你会发现，对于交通工具（汽车）有不同的类型，然而它们所行驶的环境（路）也在变化，在软件系统中就要适应两个方面的变化？怎样实现才能应对这种变化呢？/ 抽象路public abstract class AbstractRoad protected AbstractCar car;public AbstractCar getCar() return car;public void setCar(AbstractCar car) this.car = car;public abstract void run();/ 高速公路public class SpeedWay extends AbstractRoad public void run() car.run();System.out.println(高速公路上行驶);/ 市区街道public class Street extends AbstractRoad public void run() car.run();System.out.println(市区街道上行驶);/ 抽象汽车public abstract class AbstractCar public abstract void run();/ 小汽车;public class Car extends AbstractCar public void run() System.out.println(小汽车在);/ 公共汽车public class Bus extends AbstractCar public void run() System.out.println(公共汽车在);public class Client public static void main(String args) / 小汽车在高速公路上行驶;AbstractRoad road1 = new SpeedWay();road1.setCar(new Car();road1.run();/ 公共汽车在高速公路上行驶;AbstractRoad road2 = new SpeedWay();road2.setCar(new Bus();road2.run();增加一个维度人,不同的人开着不同的汽车在不同的路上行驶(三个维度)public abstract class People protected AbstractRoad road;public AbstractRoad getRoad() return road;public void setRoad(AbstractRoad road) this.road = road;public abstract void run();public class Man extends People public void run() System.out.println(男人开着);road.run();public class WoMan extends People public void run() System.out.println(女人开着);road.run();public class Client public static void main(String args) / 男人开着公共汽车在高速公路上行驶;AbstractRoad road3 = new SpeedWay();road3.setCar(new Bus();People p = new Man();p.setRoad(road3);p.run();桥接模式很好的符合了开放-封闭原则和优先使用合成(而不是继承)这两个面向对象原则组合模式装饰模式外观模式(Facade)为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。解决的问题是：组件的客户和组件中各种复杂的子系统有了过多的耦合，随着外部客户程序和各子系统的演化，这种过多的耦合面临很多变化的挑战。/汽车引擎public class Engine public String engineWork() return BMWs Engine is Working;public String EngineStop() return BMWs Engine is stopped;/汽车轮子public class Wheel public String WheelCircumrotate() return BMWs Wheel is Circumrotating;public String WheelStop() return BMWs Wheel is stoped;public class Body public Wheel wheels = new Wheel4;public Engine engine = new Engine();public Body()for (int i = 0; i wheels.length; i+)wheelsi = new Wheel();public class CarFacadeBody body = new Body(); public void Run() body.engine.engineWork(); for(int i = 0; i body.wheels.length; i+) body.wheelsi.WheelCircumrotate(); public void Stop() body.engine.EngineStop(); for (int i = 0; i body.wheels.length; i+) body.wheelsi.WheelStop(); public class Test public static void main(String args) CarFacade car = new CarFacade(); car.Run(); car.Stop();外观模式完美地体现了依赖倒转原则和迪米特法则思想依赖倒转原则： 高层模块不应该依赖低层模块，两个都应该依赖抽象；抽象不应该依赖细节，细节应该依赖抽象迪米特法则： 只与你直接的朋友们通信； 不要跟“陌生人”说话； 每一个软件单位对其他的单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位。享元模式代理模式(Proxy)为其他对象提供一种代理以控制对这个对象的访问。它的特征是代理类与委托类有同样的接口角色：抽象角色：声明真实对象和代理对象的共同接口；代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等静态代理public interface Subject public void request(String s);public class RealSubject implements Subject public void request(String s) System.out.println(realSubject request!+s);class ProxySubject implements Subjectprivate RealSubject realSubject;public void request(String s) if(realSubject=null)realSubject=new RealSubject();realSubject.request(a);public class Client public static void main(String args) Subject proxy=new ProxySubject ();proxy.request(a);动态代理java.lang.reflect包中的Proxy类和InvocationHandler接口提供了生成动态代理类的能力。(1) Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method, Object args)。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request()，args为该方法的参数数组。这个抽象方法在代理类中动态实现。(2)Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：Protected Proxy(InvocationHandler h)：构造函数，估计用于给内部的h赋值。Static Class getProxyClass (ClassLoader loader, Class interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。Static Object newProxyInstance(ClassLoader loader, Class interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。/抽象角色和真实角色同上/代理角色public class DynamicSubject implements InvocationHandler private Object sub;public DynamicSubject() public DynamicSubject(Object obj) sub = obj;public Object invoke(Object proxy, Method method, Object args)throws Throwable System.out.println(before calling + method);System.out.println(args0.toString();method.invoke(sub, args);System.out.println(after calling + method);return null;public class Clientpublic static void main(String args) throws ThrowableRealSubject rs = new RealSubject(); / 在这里指定被代理类InvocationHandler ds = new DynamicSubject(rs); / 初始化代理类Class cls = rs.getClass();/ 以下是分解步骤/* Class c =Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces() ;* Constructor ct=c.getConstructor(new ClassInvocationHandler.class);* Subject subject =(Subject) ct.newInstance(new Objectds);*/ 以下是一次性生成Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(), ds);subject.request(Hello);行为型模式观察者模式(Observer)定义了对象间的一种一对多依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。Observer模式提供给关联对象一种同步通信的手段，使某个对象与依赖它的其他对象之间保持状态同步。Observer模式的角色：抽象主题（Subject）角色：主题角色把所有的观察者对象的引用保存在一个列表里；每个主题都可以有任何数量的观察者。主题提供一个接口可以加上或撤销观察者对象；主题角色又叫做抽象被观察者(Observable)角色；具体主题（ConcreteSubject）角色,：保存对具体观察者对象有用的内部状态；在这种内部状态改变时给其观察者发出一个通知；具体主题角色又叫作具体被观察者角色；抽象观察者（Observer）角色：为所有的具体观察者定义一个接口，在得到通知时更新自己；具体观察者（ConcreteObserver）角色： 保存一个指向具体主题对象的引用；和一个与主题的状态相符的状态。具体观察者角色实现抽象观察者角色所要求的更新自己的接口，以便使本身的状态与主题的状态自恰。abstract class Subject private List observers = new ArrayList();public void attach(Observer observer) observers.add(observer);public void detach(Observer observer) observers.remove(observer);public void Notify() for (Observer o : observers) o.update();class ConcreteSubject extends Subject private String subjectState;public String getSubjectState() return subjectState;public void setSubjectState(String subjectState) this.subjectState = subjectState;interface Observer public void update();class ConcreteObserver implements Observer private String name;private String observerState;private ConcreteSubject subject;public ConcreteSubject getSubject() return subject;public void setSubject(ConcreteSubject subject) this.subject = subject;public ConcreteObserver(ConcreteSubject subject, String name) = name;this.subject = subject;public void update() observerState = subject.getSubjectState();public class Test public static void main(String args) ConcreteSubject s = new ConcreteSubject();s.attach(new ConcreteObserver(s, X);s.attach(new ConcreteObserver(s, Y);s.attach(new ConcreteObserver(s, Z);s.setSubjectState(ABC);s.Notify();模板方法命令模式状态模式职责链模式解释器模式中介者模式访问者模式策略模式(Strategy)定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。该模式使得算法可独立于它们的客户变化。抽象策略(Strategy)角色：策略类，通常由一个接口或者抽象类实现具体策略(ConcreteStrategyA)角色：包装了相关的算法和行为环境(Context)角色：持有一个策略类的引用，最终给客户端调用的。/ 抽象策略角色 public abstract class AbstractStrategy public abstract String calculate(float a,float b); /具体策略角色 public class AddStrategy extends AbstractStrategy public String calculate(float a,float b) float resul