9种java设计模式笔记
设计模式模板方法模式JAVA
设计模式模板方法模式JAVA 篇一：Java模板方法设计模式1. 什么是回调函数所谓回调，就是客户程序C调用服务程序S中的某个函数A，然后S又在某个时候反过来调用C中的某个函数B，对于C来说，这个B便叫做回调函数。
回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。
回调函数是一个工作流的一部分，由工作流来决定函数的调用（回调）时机。
一般说来，C不会自己调用B，C提供B的目的就是让S来调用它，而且是C不得不提供。
由于S并不知道C 提供的B姓甚名谁，所以S会约定B的接口规范（函数原型），然后由C提前通过S的一个函数R告诉S自己将要使用B函数，这个过程称为回调函数的注册，R称为注册函数。
Web Service以及Java 的RMI都用到回调机制，可以访问远程服务器程序。
回调函数包含下面几个特性：1、属于工作流的一个部分；2、必须按照工作流指定的调用约定来申明（定义）；3、他的调用时机由工作流决定，回调函数的实现者不能直接调用回调函数来实现工作流的功能；2. 回调机制回调机制是一种常见的设计模型，他把工作流内的某个功能，按照约定的接口暴露给外部使用者，为外部使用者提供数据，或要求外部使用者提供数据。
java回调机制：软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。
同步调用：一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；回调：一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；异步调用：一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。
回调和异步调用的关系非常紧密：使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。
实例：1、回调类接口/*** 回调类接口**/public interface CallBack {public String findCallBack();}2、调用者/*** 调用者**/public class AnotherFunction {CallBack findCallBack;// 调用实现类方法} public String doCallback() { returnfindCallBack.findCallBack(); } /* 业务需要的时候，通过委派，来调用实现类的具体方法 */ public void setCallback(CallBack findCallBack){ this.findCallBack = findCallBack; }3、测试回调函数/*** new CallBack给调用者anotherFunction对象传递了一个实现CallBack接口的匿名类，* 这样AnotherFunction类的对象就取得了一个实现接口的类，可以在任何时候调用接口中的方法*/public class CallMainTest {public static void main(String[] args) {// 创建调用者实现类 AnotherFunction anotherFunction = new AnotherFunction(); // 将回调类接口注册进实现类中anotherFunction.setCallback(new CallBack(){ @Override public String findCallBack(){return "在CallMainTest类中实现但不能被CallMainTest 的对象引用,而由AnotherFunction对象调用";}});}//接收回调函数返回的信息 String info = anotherFunction.doCallback(); //打印输出System.out.println(info); }上述的代码：1.两个类：匿名类和AnotherFunction2.匿名类实现接口CallBack(在CallMainTest测试的main方法中用匿名类的形式实现)3.AnotherFunction拥有一个参数为CallBack接口类型的函数setCallback(CallBack findCallBack)4.匿名类运行时调用AnotherFunction 中setCallBack函数,以自身传入参数5.AnotherFunction 已取得匿名类，就可以随时回调匿名类中所实现的CallBack接口中的方法回调方法的使用通常发生在“java接口”和“抽象类”的使用过程中。
23种设计模式记忆 口诀
23种设计模式记忆口诀1.单例模式：独一无二，最重要。
2.工厂模式：制造者，无需说。
3.抽象工厂：一族产品，同根源。
4.建造者模式：一步一步，建造家。
5.原型模式：克隆专家，快捷法。
6.适配器模式：转换者，聪明智。
7.桥接模式：结构优化，灵活性。
8.装饰模式：装饰者，美化家。
9.组合模式：树形结构，组合家。
10.外观模式：微缩封装，简洁家。
11.享元模式：享元工厂，节省家。
12.代理模式：替身幕后，保护家。
13.模板方法：算法继承，不变家。
14.策略模式：行为封装，灵活家。
15.命令模式：命令者，有权家。
16.职责链模式：可扩展，级别性。
17.状态模式：状态管理，干净家。
18.观察者模式：被观察，自主家。
19.中介者模式：中介者，沟通家。
20.迭代器模式：循环选择，简化家。
21.访问者模式：动态添加，扩展家。
22.备忘录模式：状态备份，还原家。
23.解释器模式：解释语言，特殊家。
以上23种设计模式，为了更好地记忆，我把它们组合成了一个口诀：最重要的单例模式，工厂与抽象同皇冠。
建造渐进如养家，克隆是原型美化家。
适配器桥接转化家，组合成树形结构家。
装饰装扮美化家，微缩封装外观家。
享元共用节省家，代理替身保护家。
策略模式灵活家，命令者有权家。
职责链扩展级别性，状态干净管理家。
被观察自主家，中介者沟通家。
循环迭代简化家，访问者动态扩展家。
备忘录变化还原家，解释语言特殊家。
这个口诀是通过把每个模式的主要特点和功能用简洁的语句表达出来，然后通过排列组合的方式形成的。
相信这个口诀会让你更容易地记忆这23种设计模式，并且可以在以后的工作中灵活地运用它们。
23种设计模式记忆口诀
23种设计模式记忆口诀设计模式是软件开发中常见的解决方案模板，它们能够解决许多常见的设计问题。
为了帮助记忆23种设计模式，可以使用下面这个口诀来记忆：Creational Patterns（创建型模式）:1. Singleton（单例模式）：一个类能产生一个实例，全局访问。
2. Builder（建造者模式）：分步骤创建复杂对象，易拓展。
3. Factory Method（工厂方法模式）：子类决定实例化哪个对象。
4. Abstract Factory（抽象工厂模式）：创建一组相关对象，不依赖具体类。
5. Prototype（原型模式）：通过复制现有对象来创建新对象。
Structural Patterns（结构型模式）:6. Adapter（适配器模式）：将类的接口转换为客户端希望的接口。
7. Bridge（桥接模式）：将抽象部分与实际部分分离。
将对象组合成树形结构来表示部分整体的层次结构。
9. Decorator（装饰器模式）：动态地给对象添加功能。
10. Facade（外观模式）：提供一个统一的接口，简化客户端使用。
11. Flyweight（享元模式）：共享细粒度对象，减少内存使用。
12. Proxy（代理模式）：控制对其他对象的访问。
Behavioral Patterns（行为型模式）:13. Chain Of Responsibility（责任链模式）：将请求的发送者和接收者解耦，多个对象都可能处理请求。
将请求封装成对象，可以用参数化方式处理。
15. Iterator（迭代器模式）：提供一种遍历集合的统一接口。
16. Mediator（中介者模式）：将多个对象之间的复杂关系解耦。
17. Memento（备忘录模式）：将对象的状态保存起来，以后可以恢复。
18. Observer（观察者模式）：当一个对象改变状态时，依赖它的对象都会收到通知。
19. State（状态模式）：对象的行为随状态的改变而改变。
java常用的设计模式及应用场景
java常用的设计模式及应用场景一、单例模式（Singleton）单例模式是一种对象创建型模式，它指的是设计一个类，使其只能生成一个实例。
它只提供一个类实例，保证只有一个实例存在。
有时候，只需要一个类的实例来控制整个系统，例如实现一个全局的缓存，或是建立一个共享的日志记录器，单例模式可以很好的实现这个目的。
应用场景：1、对于需要频繁创建和销毁的对象，可以考虑使用单例模式，以避免过多地重复创建和销毁造成系统开销。
2、对于某些资源比较宝贵的对象，例如数据库连接，则可以用单例模式进行封装，保证全局应用程序只有一个，从而避免重复创建，浪费资源。
二、工厂模式（Factory）工厂模式是一种类创建型模式，它把类的实例化推迟到子类来完成。
它用于隔离客户类和实例化对象，通过声明抽象类类来定义构造过程，将不同的定义转移到不同的子类中去，从而使用户不需要关心实例化过程。
1、在有大量不同对象需要创建和管理的情况下，可以利用工厂模式封装类的实例化和存储，将池中不同对象来进行统一管理。
2、在使用设计模式的情况下，复杂的类结构已经不适合用一个实例来创建，可以采用工厂模式实现多个类的实例化，让用户不用关心对象实例的创建过程。
抽象工厂模式是一种工厂模式的拓展，它把简单工厂模式的单一职责拆分为多个类，从而实现一个系列相关的或相互依赖的工厂，以满足比较复杂的对象创建需求。
1、在需要创建复杂对象，而复杂对象又由多个部件组成的情况下，例如计算机，单一工厂模式已经不能满足需求，那么可以通过抽象工厂模式来实现。
2、在需要产生大量不同类型的对象，或者存在一系列相互依赖的产品族，这种情况下可以使用抽象工厂模式，将工厂定义为不同维度组成的一个系列。
四、建造者模式（Builder）建造者模式是一种设计模式，它也叫构造子模式，通过使用建造者模式，客户端可以不必担心具体的生产过程，只需要给出具体的请求，由建造者来负责构造出请求的产品对象。
1、在有复杂的产品对象的时候，例如需要对多个部件进行拼装，以构造出复杂的对象，可以采用建造者模式将复杂的拼装过程进行封装，避免复杂的拼装过程变得混乱。
java 面向对象的常用设计模式
java 面向对象的常用设计模式java 面向对象的常用设计模式有：1、观察者模式观察者模式又称为发布-订阅模式，定义了对象之间一对多依赖关系，当目标对象(被观察者)的状态发生改变时，它的所有依赖者(观察者)都会收到通知。
2、抽象工厂模式抽象工厂模式主要用于创建相关对象的家族。
当一个产品族中需要被设计在一起工作时，通过抽象工厂模式，能够保证客户端始终只使用同一个产品族中的对象；并且通过隔离具体类的生成，使得客户端不需要明确指定具体生成类；所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。
3、单例设计模式单例设计模式可以确保系统中某个类只有一个实例，该类自行实例化并向整个系统提供这个实例的公共访问点，除了该公共访问点，不能通过其他途径访问该实例。
4、策略模式将类中经常改变或者可能改变的部分提取为作为一个抽象策略接口类，然后在类中包含这个对象的实例，这样类实例在运行时就可以随意调用实现了这个接口的类的行为。
比如定义一系列的算法，把每一个算法封装起来，并且使它们可相互替换，使得算法可独立于使用它的客户而变化，这就是策略模式。
5、适配器模式适配器模式主要用于将一个类或者接口转化成客户端希望的格式，使得原本不兼容的类可以在一起工作，将目标类和适配者类解耦；同时也符合“开闭原则”，可以在不修改原代码的基础上增加新的适配器类；将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性，但是缺点在于更换适配器的实现过程比较复杂。
6、命令模式命令模式的本质是将请求封装成对象，将发出命令与执行命令的责任分开，命令的发送者和接收者完全解耦，发送者只需知道如何发送命令，不需要关心命令是如何实现的，甚至是否执行成功都不需要理会。
命令模式的关键在于引入了抽象命令接口，发送者针对抽象命令接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。
设计模式——速记口诀
设计模式——速记⼝诀最近在学习设计模式的时候，感觉23种设计模式的名字好难记啊，晦涩难懂啊。
不过IT界好⼼⼈⼤有⼈在啊，下⾯是转载的⽂章，⼀个⼩⼝诀就帮助我们记牢23种设计模式。
真棒！其实我们应该⾼兴更应该反省，⾼兴的是不需要⾃⼰造轮⼦，反省的是为什么我们也遇到了同样的问题（名字不好记），但是我们没有去解决呢？或者说没有想办法去解决呢？对待问题的态度值得深思啊！设计模式常常被提起，不记住它们的名字怎能⾏？因此，我编写了这个顺⼝溜，希望您看了之后也能记得快、记得牢。
5 + 7 = 11；5个创建型，7个结构型，11个⾏为型1、创建型速记⼝诀抽⼯单建原Singleton，单例模式：保证⼀个类只有⼀个实例，并提供⼀个访问它的全局访问点Abstract Factory，抽象⼯⼚：提供⼀个创建⼀系列相关或相互依赖对象的接⼝，⽽⽆须指定它们的具体类。
Factory Method，⼯⼚⽅法：定义⼀个⽤于创建对象的接⼝，让⼦类决定实例化哪⼀个类，FactoryMethod使⼀个类的实例化延迟到了⼦类。
Builder，建造模式：将⼀个复杂对象的构建与他的表⽰相分离，使得同样的构建过程可以创建不同的表⽰。
Prototype，原型模式：⽤原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。
2、结构型速记⼝诀桥代理组装适配器，享元回家装饰外观。
解释：有个姓桥的代理组装适配器，他⼉⼦享元拿回家装饰外观去啦Composite，组合模式：将对象组合成树形结构以表⽰部分整体的关系，Composite使得⽤户对单个对象和组合对象的使⽤具有⼀致性。
Facade，外观模式：为⼦系统中的⼀组接⼝提供⼀致的界⾯，facade提供了⼀⾼层接⼝，这个接⼝使得⼦系统更容易使⽤。
Proxy，代理模式：为其他对象提供⼀种代理以控制对这个对象的访问Adapter,适配器模式：将⼀类的接⼝转换成客户希望的另外⼀个接⼝，Adapter模式使得原本由于接⼝不兼容⽽不能⼀起⼯作那些类可以⼀起⼯作。
java设计模式选择题复习
工厂系列模式的优缺点：1.让用户的代码和某个特定类的子类的代码解耦用户不必知道它所使用的对象是怎样创建的，只需知道该对象有哪些方法2.抽象工厂模式可以为用户创建一系列相关的对象，使用户和创建这些对象的类脱耦MVC模式是不是一种设计模式？为什么MVC不是设计模式，应该是框架/架构模式，因为它的定义是抽象的，没有足够的细节描述使你直接去实现，而只能根据MVC的概念和思想，用几个设计模式组合实现。
举出一个生活中使用装饰者模式的例子，用程序实现思路举个生活中的例子，俗话说“人在衣着马在鞍”，把这就话用装饰者模式的语境翻译一下，“人通过漂亮的衣服装饰后，男人变帅了，女人变漂亮了；”。
对应上面的类图，这里人对应于ConcreteComponent,而漂亮衣服则对应于ConcreteDecorator；设计模式如何分类，每一个类别都有什么特征？设计模式分为3类，分别是：创建型模式、行为型模式、结构型模式。
创建型特点：避免用户直接使用new运算符创建对象。
行为型特点：怎样合理的设计对象之间的交互通信，以及怎样合理的为对象分配职结构型特点：主要用于处理类或对象的组合Java jdk中使用了哪些设计模式1.单例2.静态工厂3.工厂方法4.抽象工厂5.构造者6.原型7.适配器8桥接9.组合10.装饰器11.外观12.享元14.代理15.迭代器16.观察者17.协调者18.模板方法19.策略20.责任链21.命令22.空对象25.解释器面向对象的设计原则有哪些？开闭原则、面向抽象的原则（依赖倒转原则）、多用组合少用继承原则、高内聚-低耦合原则。
观察者模式的推拉有什么不同？使用场景推，具体主题将变化后的数据全部交给具体观察者。
场景：当具体主题认为具体观察者需要这些变换后的数据时，往往采用推数据方式；拉，具体主题不将变化后的数据交给具体观察者，而是提供获得这些数据的方法。
场景：当具体主题不知道具体观察者是否需要这些变换后的数据时，往往采用拉数据的方式。
23种设计模式记忆口诀
23种设计模式记忆口诀
1.单例模式：唯一实例化，静态访问，线程不安全
2. 工厂方法模式：子类实现，工厂创建，扩展性强
3. 抽象工厂模式：创建一族产品，接口约束，扩展性强
4. 建造者模式：组合复杂对象，分步骤构建，灵活性高
5. 原型模式：克隆对象，避免重复创建，效率高
6. 适配器模式：兼容接口不同，类似转换器，易扩展
7. 桥接模式：抽象与实现分离，解耦合，易扩展
8. 装饰器模式：动态增强对象功能，不影响原有对象，易扩展
9. 组合模式：层次结构，统一访问，易扩展
10. 外观模式：简化复杂系统调用，易使用，易扩展
11. 享元模式：共享资源，避免重复创建，效率高
12. 代理模式：增强对象功能，控制对象访问，易扩展
13. 责任链模式：多个对象处理请求，自动传递，易扩展
14. 命令模式：将请求封装成对象，易扩展，易记录日志
15. 解释器模式：解释语言，易扩展，易维护
16. 迭代器模式：遍历集合，统一访问，易扩展
17. 中介者模式：分离对象间交互，降低耦合，易扩展
18. 观察者模式：对象状态改变，通知观察者，易扩展
19. 备忘录模式：保存对象状态，易恢复，易扩展
20. 状态模式：对象状态改变，自动改变行为，易扩展
21. 策略模式：选择不同策略，易切换，易扩展
22. 模板方法模式：定义操作流程，易扩展，易维护
23. 访问者模式：统一访问集合中对象，易扩展，易维护。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java设计模式笔记一．单例模式1.单例模式（Singleton）表示一个类只能生成一个对象。
2.典型应用：Servlet就是使用的单例模式，不管多少个用户访问一个Servlet都是访问的一个Servlet对象。
3.对于单例模式实现的想法：1）首先明确生成一个类的对象时肯定要调用该类的构造方法。
2）那么我们必须要从构造方法入手解决一个类只能生成一个对象这一问题。
3）假设不提供构造方法，该类会默认是一个不带参数的构造方法，显然生成该类对象时还是会调用默认的构造方法，还是无法解决问题4）则我们肯定是要通过提供构造方法来解决这一问题，那么现在我们的问题是到底该提供怎样的构造方法呢？5）那么我们就想到一般的构造方法都是public的，在类的外部（其他类）可以调用该构造方法生成多个对象，显然是不行的，那么我们就想到private关键字，private表示只能类的内部才能访问。
6）那么现在我们想到可以把构造方法定义成一个私有（private）的，只有该类的内部才能访问，但是在类的外面不能生成对象了，这样成为零例了，与单例很接近了。
7）那么我们需要在该类中提供一个返回唯一一个该类的对象供外部调用。
但是现在我们构造方法外部都不能访问，没有对象该怎么访问这个类的指定方法呢？8）那么我们想到把我们提供的方法定义成静态方法（非实例方法），就可以直接通过该类加点号访问该类的该方法了。
9）那么我们可以举一个单例的例子了：class Singleton{private static Singleton singleton=new Singleton();private Singleton(){}public static Singleton getInstance(){return singleton;}}以上例子便是实现了单例模式，注意两个红色地方，静态的方法只能访问静态的属性。
在类的外部直接通过类名加点号getInstance（）访问唯一一个对象了。
二．简单工厂模式1.简单工厂模式是类的创建模式，又叫做静态工厂方法（Static Factory Method）模式。
简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
通常它根据自变量的不同返回不同类的实例。
2.简单工厂模式的实质是由一个工厂类根据传入参数，动态的决定应该创建出哪一个产品类的实例。
3.简单工厂模式的构成：1）工厂类（Creator）角色：担任这个角色的是简单工厂模式的核心，含有与应用紧密相关的商业逻辑。
工厂类在客户端直接调用下创建产品对象，它往往由一个具体类实现。
2）抽象产品（Product）角色：担任这个角色的类是简单工厂模式所创建的对象的父类，或他们共同拥有的接口。
抽象产品角色可以用一个接口或抽象类实现。
3）具体产品（Concrete Product）角色：简单工厂模式所创建的任何对象都是这个角色的实例，具体产品角色由一个具体类实现。
4.自己实现简单工厂模式1）抽象产品角色2）具体产品角色3）工厂类角色4）客户端调用5）上例中有一个接口类型的Person作为抽象产品角色，他的两个产品（Chinese和American）实现了这个接口，作为具体的产品角色。
在工厂类PersonFactory中，提供了一个静态的工厂方法getPerson返回一个Person类型。
该方法根据传过来的参数决定到底生成哪一个类的实例。
在客户端如果需要使用Chinese和American这两个类的实例的时候，可以使用工厂方法PersonFactory来获得，只需要传入一定的参数就能生成对应的想要的对象。
这样在客户端根本就看不到new两个具体的产品的代码了，降低了代码的耦合性。
5.典型应用：Spring框架的IOC（依赖注入机制）就是很好的使用了这个设计模式，使用户需要使用一个类的时候无需自己new出一个实例。
只需要配置好后，提供一个参数就能获得对应的实例。
大大降低了代码之间的耦合性。
三．模板方法模式1.模板方法模式定义一个操作中的算法骨架，而将一些步骤延伸到子类中去，使得子类可以不改变一个算法的结构，即可重新定义该算法的某些特定步骤。
这里需要复用的是算法的结构，也就是步骤，而步骤的实现可以在子类中完成。
2.也就是父类只是规定一些步骤（方法的顺序），而不关注每一个步骤到底是怎么实现的。
3.模板方法的使用场合：1)一次性实现一个算法的不变部分，并且将可变的行为留给子类来完成。
2)各子类的公共的行为应该被提取出来并集中到一个公共父类中以避免代码的重复。
首先识别现在代码的不同之处，并且把不同之处分离成为新的操作，最后用一个调用这些新的操作的模板方法来替代这些不同的代码。
3)控制子类的扩展4.模板方法模式的组成：1）父类角色：提供模板（可以用抽象类但是不能用接口，因为接口无法规定步骤）。
2）子类角色：为模板提供实现。
5.实现自己的模板方法模式父类角色如下（一般是一个抽象方法）：子类角色如下以上两个角色就是模板方法模式的所有角色，使用如下：使用的时候直接调用父类规定好步骤的template方法就好。
6.对照上面的例子重新解释下最开始对模班方法的介绍：1）首先父类中的template方法规定了操作中算法的骨架（结构，步骤）。
2）定义的三个方法method1，method2，method3都是抽象的所以必然延伸到子类中去实现。
3）在子类中我们重写了三个抽象的方法，但是不会重写template方法，所以无法改变算法的结构（步骤），个人感觉为了防止template方法被改写可以在父类中定义的时候加上final关键字定义成终态方法（不能被重写的方法）。
4）Template方法（算法）的各个步骤需要到子类中去实现。
5）我们调用的时候是调用的子类继承下来的template方法，而不用去管具体的步骤。
7.在junit3中不管我们怎么写测试代码，所有测试方法都是按照先执行setUp（），再执行测试方法，再执行tearDown（），而这三个方法中的具体代码我们必须具体实现。
所以这里是典型用到了模板方法模式的地方。
当然在junit4中是使用注解但是核心还是一样，只不过是换成了注解@Before，@Test和@After。
8.其中JUnit3中实现了模板方法模式的那个template方法如下：四．策略模式JDK中涉及该模式的地方主要是TreeSet和TreeMap中需要传入一个指定的排序规则的地方1.策略模式（Strategy Pattern）中体现了两个非常基本的面向对象的设计的原则1）封装变化的概念2）编程中使用接口而不是对接口的实现2.策略模式的定义：1）定义了一组算法，将每个算法都封装起来，并且使他们之间可以互换。
2）策略模式使这些算法在客户端调用它们的时候能够互不影响的变化3.策略模式的组成1)抽象策略角色：策略类，通常由一个接口或者抽象类实现。
如JDK中的Comparator接口2)具体策略角色：包装了具体的算法和行为。
如我们自己实现的Comparator接口并实现compare（Object o1,Object o2）方法3)环境角色：持有一个策略类的引用，并最终给客户端调用的。
如JDK中的TreeSet，TreeMap，当我们要创建TreeSet对象时，我们一般需要传入一个Comparator接口类型的引用，用来接收自定义的实现类根据不同的实现类实现不同的排序方式。
4.策略模式的实现1）策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立类中，从而使他们可以相互替换。
2）策略模式使得算法可以在不影响客户端的情况下发生变化。
使用策略模式可以把行为和环境分割开来3）环境类负责维护和查询行为类，各种算法则在具体的策略中提供。
由于算法和环境独立开来，算法的修改都不会影响环境和客户端。
5.策略模式的编写步骤：1）对策略对象（具体的算法的类的对象）定义一个公共接口2）编写策略类（具体的算法），该类实现了上面的公共接口3）在使用策略对象的类中保存一个对策略对象（公共接口）的引用6.策略模式的缺点1）客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
2）造成很多策略类3）解决方法可以采用工厂方法。
7.实现自己的策略模式1）抽象的策略角色如下：2）具体的策略角色上面是两个具体的策略类，其中实现Comparator接口是为了让这个类是一个Comparator类型的，可以让自己实现的sort方法的Collections.sort()当成Comparator类型传到第二个参数中实现按照自己定义的compare 方法来排序。
与策略模式没有关系。
如果仅仅关注策略模式可以直接看实现的sort方法就可以了。
3）环境角色环境角色中持有一个对抽象策略类的一个引用，在自己定义的排序方法中调用了该引用的排序方法。
由于该引用是一个接口类型，那么到底调用的是哪个类的排序方法就看这个引用的实际类型了。
4）客户使用的代码和Person类（一些代码省略）客户端调用的时候，先new一个具体的角色，通过set方法或者是构造方法传入到环境角色的对象中然后直接调用环境角色的排序方法就可以了。
如果想使用不同的排序方法，只需要往环境变量中设置不同的具体策略角色对象就可以了。
五．代理模式1.代理模式的作用是：为其它对象提供一种代理以控制对这个对象的访问2.代理模式分为两种：静态代理和动态代理。
3.在某些情况下，一个客户不想或者不能直接引用另外一个对象，而代理模式可以在客户和目标之间起到中介的作用。
4.代理模式一般涉及到的角色有：1）抽象角色：声明真实对象和代理对象共同的接口2）代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口一边在任何时刻能代替真实对象同时，代理对象可以在执行真实对象操作时，附加其它的操作，相当与对真实对象进行封装。
3）真实角色：代理角色所代表的真实对象，使我们最终要引用的对象5.自己实现静态代理1）抽象角色如下2）真实角色如下：3）代理角色如下：4）客户端调用如下：6.实现自己的动态代理1）抽象角色如下2）真实角色如下3）动态代理角色如下3）客户端调用4）以上动态代码和静态代理的代码的区别主要在代理类和客户端调用两个地方。
动态代理类不需要实现那个抽象角色的接口了，在JDK中提供动态代理支持的接口是InvocationHandler。
实现该接口并且重写它的invoke方法。
5）以上例子从客户端的代码开始分析首先第一行通过动态代理类中定义的的factory方法获得一个RealSubject（真实对象）的代理对象（再来看看factory 这个方法，这个方法第一行获得了一个传入对象的Class对象在通过Proxy类的静态方法和传入对象的Class对象动态生成一个传入对象的代理对象。