java笔记整理

165
★★★★Java 集合是 Java 1.2 版提出来的。多个对象聚在一起形成的总体称之为集合（Aggregate），集合对象是能够包容一组对象的
容器对象。所有的 Java 集合都实现 java.util.Collection 接口，这个接口规定所有的 Java 聚集必须提供一个 iterator()
方法，返还一个 Iterator 类型的对象一 个具体的 Java 聚集对象会通过这个 iterator()方法接口返还一个具体的 Iterator
类。可以看出，这个 iterator()方法就是一个工厂方法。
★在微软公司所提倡的COM（Component Object Model）技术架构中， 工厂方法模式起着关键的作用。
★在 EJB 技术架构中，工厂方法模式也起着关键的作用
★JMS（Java Messaging Service） 技术架构中的工厂方法模式
2222，，，，单例单例单例单例（（（（SingletonSingletonSingletonSingleton））））模式模式模式模式，，，，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单
例类。单例模式有以下三个的特点：
฀ ★ 单例类只可有一个实例。
฀ ★单例类必须自己创建自己这惟一的实例。
฀ ★ 单例类必须给所有其他对象提供这一实例。
注意注意注意注意：：：：虽然单例模式中的单例类被限定只能有一个实例，但是单例模式和单例类可以很容易被推广到任意且有限多个实例的情况，
这时候称它为多例模式（Multiton Pattern）和多例类（Multiton Class），
一个例子一个例子一个例子一个例子：：：：WindowsWindowsWindowsWindows 回收站回收站回收站回收站
在整个视窗系统中，回收站只能有一个实例，整个系统都使用这个惟一的实例，而且
回收站自行提供自己的实例。因此，回收站是单例模式的应用。
单列模式的实现主要有两种：饿汉式单例类和懒汉式单例类
1111））））饿汉式单例类饿汉式单例类饿汉式单例类饿汉式单例类
代码清单 1：饿汉式单例类
public class EagerSingleton{
private static final EagerSingleton m_instance = new EagerSingleton();
/*** 私有的默认构造子*/
private EagerSingleton() { }private EagerSingleton() { }private EagerSingleton() { }private EagerSingleton() { }
/*** 静态工厂方法*/
public static EagerSingleton getInstance(){
return m_instance;
}
}
读者可以看出，在这个类被加载时，静态变量 m_instance 会被初始化，此时类的私有
构造子会被调用。这时候，单例类的惟一实例就被创建出来了。
Java 语言中单例类的一个最重要的特点是类的构造子是私有的，从而避免外界利用构
造子直接创建出任意多的实例。值得指出的是，由于构造子是私有的，因此，此类不能被
继承。
2222））））懒汉式单例类懒汉式单例类懒汉式单例类懒汉式单例类。。。。与饿汉式单例类相同之处是，类的构造子是私有的。与饿汉式单例类不同的是，懒汉
式单例类在第一次被引用时将自己实例化。如果加载器是静态的，那么在懒汉式单例类被
加载时不会将自己实例化
代码清单 2：懒汉式单例类
package com.javapatterns.singleton.demos;
public class LazySingleton{
private static LazySingletonprivate static LazySingletonprivate static LazySingletonprivate static LazySingleton m_instance = null;m_instance = null;m_instance = null;m_instance = null; 加载时并不创建对象加载时并不创建对象加载时并不创建对象加载时并不创建对象，，，，而是在需要的时候在创建而是在需要的时候在创建而是在需要的时候在创建而是在需要的时候在创建
/**
* 私有的默认构造子，保证外界无法直接实例化
*/
private LazySingleton() { }
/*** 静态工厂方法，返还此类的惟一实例*/
synchronized public static LazySingleton
getInstance(){
if (m_instance == null)
{ m_instance = new LazySingleton();
}
return m_instance;
}
}
读者可能会注意到，在上面给出懒汉式单例类实现里对静态工厂方法使用了同步化，
以处理多线程环境。有些设计师在这里建议使用所谓的“双重检查成例”。必须指出的是，
“双重检查成例”不可以在 Java 语言中使用。
166
3333））））登记式单例类登记式单例类登记式单例类登记式单例类
登记式单例类是 GoF 为了克服饿汉式单例类及懒汉式单例类均不可继承的缺点而设计的
这样做的缺点
由于子类必须允许父类以构造子调用产生实例，因此，它的构造子必须是公开的。
这样一来，就等于允许了以这样方式产生实例而不在父类的登记中。
这是登记式单例类的一个缺点。
GoF 曾指出，由于父类的实例必须存在才可能有子类的实例，这在有些情况下是一个
浪费。 这是登记式单例类的另一个缺点。
3,3,3,3,多例模式多例模式多例模式多例模式
所谓的多例模式（Multiton Pattern），实际上就是单例模式的自然推广。作为对象的创
建模式，多例模式或多例类有以下的特点：
（1）多例类可有多个实例。
（2）多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。
1)有上限多例模式。一个实例数目有上限的多例类已经把实例的上限当做逻辑的一部分，并建造到了多例
类的内部，这种多例模式叫做有上限多例模式。
比如每一麻将牌局都需要两个色子，因此色子就应当是双态类。这里就以这个系统为
例，说明多例模式的结构。色子的类图如下所示。
下面就是多例类 Die（色子）的源代码。
代码清单 3：多例类的源代码
package com.javapatterns.multilingual.dice;
import java.util.Random;
import java.util.Date;
public class Die{
private static Die die1 = new Die();
private static Die die2 = new Die();
/**
* 私有的构造子保证外界无法
* 直接将此类实例化
*/
private Die(){ }
/*** 工厂方法*/
public static Die getInstance(int whichOne) {
if (whichOne == 1) {
return die1;
}
else{
return die2;
}
}/*** 掷色子，返还一个在 1～6 之间的* 随机数*/
public synchronized int dice(){
Date d = new Date();
Random r = new Random( d.getTime() );
int value = r.nextInt();
value = Math.abs(value);
value = value % 6;
value += 1;
return value;
}
}代码清单 4：客户端的源代码
package com.javapatterns.multilingual.dice;
public class Client{
private static Die die1, die2;
public static void main(String[] args) {
die1 = Die.getInstance(1);
die2 = Die.getInstance(2);
167
die1.dice();
die2.dice();
}
}
2)无上限多例模式, 由于没有上限的多例类对实例的数目是没有限制的，因此，虽然这种多例模式是单例模式的推广，但是这种
多例类并不一定能够回到单例类。
应用：序列键生成器与单例及多例模式
4,4,4,4,原始模式原始模式原始模式原始模式，通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。
这就是原始模型模式的用意。Java 语言的构件模型直接支持原始模型模式。所有的 JavaBean 都继承自 java.lang.Object，而
Object 类提供一个 clone()方法，可以将一个 JavaBean 对象复制一份；但是这个 JavaBean 必须实现一个标示接口 Cloneable
表 明 这 个 JavaBean 支 持 复 制 。 如 果 一 个 对 象 没 有 实 现 这 个 接 口 而 调 用 clone() 方 法 ， Java 编 译 器 会 抛 出
CloneNotSupportedException 异常。
5555 建造模式建造模式建造模式建造模式，，，，建造模式的定义为：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。可以将建
造模式的精髓概括为：将构造复杂对象的过程和对象的部件解耦。这是对降低耦合、提高可复用性精神的一种贯彻。其实这种
精神贯彻在 GOF 几乎所有的设计模式中。
2）各类的说明如下：
i）抽象建造者（Builder）角色：给出一个抽象接口，以规范产品对象的各个组成成分的构造；
ii）具体建造者（ConcretBuilder）角色：它在应用程序的调用下创建产品的实例。完成任务为;
a) 实现抽象建造者 Builder 接口，给出一步步完成创建产品实例的操作；
b) 在创建完成后，提供产品的实例。
iii) 导演者（Director 角色）：调用具体建造者角色以创建产品对象；
iv）产品（Product）角色：建造中的复杂对象。一般情况下，一个系统不止一个产品类。
JJJJavaavaavaava 中的应用中的应用中的应用中的应用：：：：javamailjavamailjavamailjavamail 中使用建造者模式中使用建造者模式中使用建造者模式中使用建造者模式
6666，，，，适配器模式适配器模式适配器模式适配器模式
目的：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r 模式使得原本由于接口不兼容而不能一起工作的那些类
可以一起工作。适配器的两种模式：类的适配器模式和对象的适配器模式
1111））））类的适配器模式，类的适配器模式把适配的类的 API 转换成目标类的 API。
目标(Target)角色：这就是所期待得到的接口。
源(Adaptee)角色：现有需要适配的接口。
适配器(Adapter)角色：适配器类是本模式的核心。适配器把源接口转换成目标接口。
显然这一角色不可以是接口，而必须是具体类。
/*** 定义 Client 使用的与特定领域相关的接口 */
public interface Target {
void sampleOperation1();
void sampleOperation2();
}
/*** 定义一个已经存在的接口，这个接口需要适配*/
public class Adaptee {
public void sampleOperation1() {
// ......
}
}
/*** 对 Adaptee 与 Target 接口进行适配*/
public class Adapter extends Adaptee implements Target {
public void sampleOperation2() {
// ......
}
}
2222））））对象的适配器对象的适配器对象的适配器对象的适配器，，，，与类的适配器模式一样，对象适配器模式把适配的类的 API
转换成为目标类的 API，与类的适配器模式不同的是，对象的适配器模式不是使用继承关系连接到 Adaptee 类，而是使用委派关
系连接到 Adaptee 类。示意代码如下：
/** * 定义 Client 使用的与特定领域相关的接口*/
public interface Target {
void sampleOperation1();
void sampleOperation2();
}
/** * 定义一个已经存在的接口，这个接口需要适配*/
public class Adaptee {
public void sampleOperation1() {
// ......
168
}
}
/** * 对 Adaptee 与 Target 接口进行适配 */
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
super();
this.adaptee = adaptee;
}
public void sampleOperation1() {
adaptee.sampleOperation1();
}
public void sampleOperation2() {
// ......
}
}
类适配器模式和对象适配器模式的异同：Target 接口和 Adaptee 类都相同，不同的是类适配器的 Adapter 继承 Adaptee 实现
Target，对象适配器的 Adapter 实现 Target 聚集 Adaptee。
应用：1JDBC 驱动软件与适配器模式.JDBC 给出一个客户端通用的界面，每个数据库引擎的 JDBC 驱动软件都是一个介于 JDBC 接
口和数据库引擎接口之间的适配器软件
2 JDBC/ODBC 如果没有合适的 jdbc 软件驱动，用户也可以用 ODBC 驱动软件把 JDBC 通过一个 JDBC/ODBC 桥梁软件与 ODBC
连接起来从而达到连接数据库的目的，JDBC 的库不可能和 ODBC 的库有相同的接口，因此使用适配器模式将 ODBC 的 api 接
口改为 JDBC 的接口，因此 JDBC/ODBC 桥梁是适配器模式的应用。
3333，，，，XMLPropertiesXMLPropertiesXMLPropertiesXMLProperties 使用了适配器模式使用了适配器模式使用了适配器模式使用了适配器模式
6666，，，， 观 察 者 模 式观 察 者 模 式观 察 者 模 式观 察 者 模 式 ，，，， 观 察 者 模 式 又 叫 作 发 布 - 订 阅 模 式 (publish-subscribe) ， 模 型 - 视 图 (model-view) 模 式 ， 源 - 监 听 者
(source-listener)模式，或者从属者(dependents)模观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某
一个主题对象。这个主题对象在状态上发生改变时，会通知所有的观察者对象，使他们能够自动更新自己。
这种观察模式在理解上相当于报社与订阅者之间的关系。出版者相当于“主题 Subuject”，订阅者相当于“Observer”。主题
对象管理某些数据，当主题内的数据改变时就会通知观察者，观察者（已经订阅的/ 注册了的）就会收到更新。
发布者叫事件源，订阅者叫事件监听器，在 java 里时间用类代表
java.util 包内包含最基本的 Observer 接口与 Observable 类，如果使用该内置的支持，就只需要写一个类去扩展（继承）
Observable，并告诉它何时该通知观察者， 一切就完成了，剩下的 API 会帮你做。你可以根据需要编写具体的观察者的类，
在这个类中定义 update()方法，去实现 Observer 接口。
publicpublicpublicpublic classclassclassclass ObservableObservableObservableObservable {{{{
private boolean changed = false;
private Vector obs;
//创建被观察者时就创建一个它持有的观察者列表，
//注意，这个列表是需要同步的。
public Observable() {
obs = new Vector();
}
/** * 添加观察者到观察者列表中去*/
public synchronized void addObserver(Observer o) {
if (o == null)
throw new NullPointerException();
if (!obs.contains(o)) {
obs.addElement(o);obs.addElement(o);obs.addElement(o);obs.addElement(o);
}
}
/** * 删除一个观察者 */
public synchronized void deleteObserver(Observer o) {
obs.removeElement(o);
}
/** * 通知操作，即被观察者发生变化，通知对应的观察者进行事先设定的操作，不传参数的通知方法 */
public void notifyObservers() {
notifyObservers(null);
}
/** * 与上面的那个通知方法不同的是，这个方法接受一个参数，这个参数一直传到观察者里，以供观察者使用*/
public void notifyObservers(Object arg) {
169
Object[] arrLocal;
synchronized (this) {
if (!changed)
return;
arrLocal = obs.toArray();
clearChanged();
}
for (int i = arrLocal.length-1; i>=0; i--)
((Observer)arrLocal[i]).update(this, arg);
}
}
public interface Observer {
void update(Observable o, Object arg);
}
}
这是一个接口，接口中就只有一个方法，update，方法中有两个参数，Observable 和一个 object，第一个参数就是被观察的对象，
而第二个参数就得看业务需求了 ，需要什么就传进去什么。我们自己的观察者类必须实现这个方法，这样在被观察者调 用
notifyObservers 操作时被观察者所持有的所有观察者都会执行 update 操作了（当然如果你 override 这个方法，你甚至可以指定何
种情况下只执行某种 observer 了，是不是比较像责任链模式了）。
首先让我们来实现一个发送邮件的观察者：
Java 代码
publicpublicpublicpublic classclassclassclass MailObserverMailObserverMailObserverMailObserver implementsimplementsimplementsimplements ObserverObserverObserverObserver{
/** 这个类取名为 MailObserver，顾名思义，她是一个用来发送邮件的观察者 */
public void update(Observable o, Object arg) {
System.out.println("发送邮件的观察者已经被执行");
}
}
接下来让我们再来实现被观察者，示例如下：
Java 代码
public class Subject extends Observable{
/** * 业务方法，一旦执行某个操作，则通知观察者 */
public void doBusiness(){
if (true) {
super.setChanged();
}
notifyObservers("现在还没有的参数");
}
public static void main(String [] args) {
//创建一个被观察者
Subject subject = new Subject();
//创建两个观察者
Observer mailObserver = new MailObserver();
Observer jmsObserver = new JMSObserver();
//把两个观察者加到被观察者列表中
subject.addObserver(mailObserver);
subject.addObserver(jmsObserver);
//执行业务操作
subject.doBusiness();
}
}
观察者模式与观察者模式与观察者模式与观察者模式与 AWTAWTAWTAWT 中的事件处理中的事件处理中的事件处理中的事件处理。。。。Java1.0 的事件处理机制是建立在责任链模式的基础之上的，但是这种不能满足打应用系统的需求，
在 java1.1 后改为建立在观察者模式之上的以事件的委派为特征的委派事件模型（Delegation Event Model DEM）,这种 DEM 的机制
不仅在 AWT 中使用还在 Swing 中使用
在 AWT 中的观察者模式 DEM 的结构（三要素）
1）事件源对象 ，一个类要成为事件源不需要实现任何接口和继承任何类，但是一个事件源要保持一个事件监听器的列表。调用
addXXXListener（）方法增加一个监听器，调用 removeXXXListener（）方法删除一个监听器。不同的事件就要不同的监听器
170
2）事件对象，每一个事件都有一个事件对象与他对应，所有的 AWT 中的事件对象都是从 java.util.EventObject 继承而来的
常用的有 ActionEvent MourseEvent
3）事件监听器对象，当事件发生时被调用的对象，一个对象要想成为一个事件监听对象，必须要实现事件监听接口，AWT 中的
事件接口都是 java.util.EventListener
实例实例实例实例
import java.awt.Frame;
import java.awt.event.MouseListener;
public class ConcreteSubject extends Frame{
private static MouseListener m;
public ConcreteSubject(){}
public static void main(String[] argv)
{
ConcreteSubject s = new ConcreteSubject();
m = new ConcreteListener();
s.setBounds(100, 100, 100 , 100);
s.addMouseListener(m);
s.show();
}}
public class ConcreteListener
implements MouseListener{
ConcreteListener(){ }
public void mouseClicked(MouseEvent e) {
System.out.println(e.getWhen());
}
public void mousePressed(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
}
7777，，，， 代理模式代理模式代理模式代理模式
1）代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个
对象，而代理对象可以在客户端和目标对象之间起到中介的作用。利用中间对象起到加强对象功能的模式还有，装饰模式，适配器模
式
代理模式有以下几种：远程代理（EJB Spring 的远程代理） 虚拟代理 保护代理 同步代理 防火墙代理 智能代理
抽象角色：声明真实对象和代理对象的共同接口；没有共同的接口那就是委托
2222））））代理模式的结构代理模式的结构代理模式的结构代理模式的结构
abstract public class Subject{abstract public class Subject{abstract public class Subject{abstract public class Subject{
abstract public void request();abstract public void request();abstract public void request();abstract public void request();
}}}}
package com.javapatterns.proxy;package com.javapatterns.proxy;package com.javapatterns.proxy;package com.javapatterns.proxy;
public class RealSubject extends Subject {public class RealSubject extends Subject {public class RealSubject extends Subject {public class RealSubject extends Subject {
public RealSubject(){ }public RealSubject(){ }public RealSubject(){ }public RealSubject(){ }
ppppublic void request(){ublic void request(){ublic void request(){ublic void request(){
System.out.println("From real subject.");System.out.println("From real subject.");System.out.println("From real subject.");System.out.println("From real subject.");
}}}}
}}}}
public claspublic claspublic claspublic class ProxySubject extends Subjects ProxySubject extends Subjects ProxySubject extends Subjects ProxySubject extends Subject {{{{
pppprivate RealSubject realSubject;rivate RealSubject realSubject;rivate RealSubject realSubject;rivate RealSubject realSubject;
public ProxySubject(){public ProxySubject(){public ProxySubject(){public ProxySubject(){}}}}
public void request()public void request()public void request()public void request(){{{{
preRequest();preRequest();preRequest();preRequest();
if( realSubject == null )if( realSubject == null )if( realSubject == null )if( realSubject == null ) {{{{
rrrrealSubject = new RealSubject();ealSubject = new RealSubject();ealSubject = new RealSubject();ealSubject = new RealSubject();
}}}}
realSubject.request();realSubject.request();realSubject.request();realSubject.request();
postRequest();postRequest();postRequest();postRequest();
}}}}
private void preRequest(){private void preRequest(){private void preRequest(){private void preRequest(){
//something you want to do before requesting//something you want to do before requesting//something you want to do before requesting//something you want to do before requesting
}}}}
private void postRequest(){private void postRequest(){private void postRequest(){private void postRequest(){
//something you want to do after re//something you want to do after re//something you want to do after re//something you want to do after requestingquestingquestingquesting
}}}}
}}}}
public class Clientpublic class Clientpublic class Clientpublic class Client{{{{
private static Subject subject;private static Subject subject;private static Subject subject;private static Subject subject;
staticstaticstaticstatic public void main(String[] args)public void main(String[] args)public void main(String[] args)public void main(String[] args){{{{
subject = new ProxySubject();subject = new ProxySubject();subject = new ProxySubject();subject = new ProxySubject();
subject.request();subject.request();subject.request();subject.request();
subject.request();subject.request();subject.request();subject.request();
}}}}
}}}}
批注批注批注批注 [U101]: 应用应用应用应用：：：：在在在在 ejbejbejbejb 和和和和
springspringspringspring 的大量使用的大量使用的大量使用的大量使用，，，，java2.0java2.0java2.0java2.0
对代理的支持对代理的支持对代理的支持对代理的支持：：：：自自自自 jdk1.3jdk1.3jdk1.3jdk1.3 以以以以
来来来来 javajavajavajava 通过通过通过通过
java.lang.reflectjava.lang.reflectjava.lang.reflectjava.lang.reflect 提供三提供三提供三提供三
个直接的代理模式个直接的代理模式个直接的代理模式个直接的代理模式：：：：ProxyProxyProxyProxy ，，，，
InvocationHandlerInvocationHandlerInvocationHandlerInvocationHandler ，，，，
MethodMethodMethodMethod
171
8888，，，， 装饰模式装饰模式装饰模式装饰模式又叫包装模式又叫包装模式又叫包装模式又叫包装模式，，，，装饰模式是对对象功能增强时，平时使用继承的一种替代方案
模式结构和代码模式结构和代码模式结构和代码模式结构和代码
public interface Component{
void sampleOperation();
}
public class Decorator implements Component{
public Decorator(Component component){
// super();
this.component = component;
}
public Decorator() {}
public void sampleOperation(){
component.sampleOperation();
}
private Component component;
}
public class ConcreteComponent implements Component{
public void sampleOperation(){
// Write your code here
}
}
public class ConcreteDecorator extends Decorator{
public void sampleOperation() {
super.sampleOperation();
}
}
装饰模式的电信创建模式
new Decorator1(
new Decorator2(
new ConcreteComponent())); 所以装饰模式常常也叫包裹模式
注意注意注意注意： 1,InputStreamReader 是把 InputStream 包装起来，把 InputStreamReader 的 API 转换成 Reader 的 api，所以它是适配器模
式，而不是桥梁模式。只是相当一个桥梁。
2,在 java.io 中的 BufferedReader 是一个装饰类，也可以看成半个适配器模式(因为它提供了一个 readLine（）新方法)一个
装饰类实现的新方法越多，就离装饰类越远
3，在 java.io 中充满了装饰模式和适配器模式。
9999，，，，门面模式门面模式门面模式门面模式：：：：外部与一个子系统的通信必须通过一个统一的门面对象进行，这就是门面模式。一般而言，Facade 模式是为了降低子
系统之间，客户端与实现化层之间的依赖性。当在构建一个层次化的系统时，也可以同过使用 Facade 模式定义
系统中每一层的入口，从而简化层与层之间的依赖关系。
应用：struts 的 action 就是相当一个门面，参考 ejb java ee 的结构
172
10，桥梁模式。桥梁模式的用意是把抽象化与实现化脱耦。脱耦是说把抽象和实现之间的耦合解脱，或者说把强关联变成弱关联。桥
梁模式的脱耦指的就是把抽象和实现之间的继承/实现关系变成组合/聚合关系。从而可以使两者可以相对独立的变化。
这就是桥梁模式的本意。
结构图如下
桥梁模式的关键是找出抽象化角色和具体化角色。典型应用是 JDBC 驱动器的应用。
11111111，，，，不变模式不变模式不变模式不变模式
不变模式可增强对象的强壮性(robustness)。不变模式允许多个对象共享某一对象，降低对该对象进行并发访问的同
步化开销。如果需要修改一个不变对象的状态，就需要建立一个新的同类型对象，并在创建时将这个新的状态存储在
新对象里。
不变模式之设计一个类。一个类的内部状态创建后，在整个生命期内都不会发生变化时，这个类被称为不变类。这种
使用不变类的做法叫作不便模式。
弱不变模式：一个类的实例状态不可改变，但是子类的实例具有可能会变化的状态。对象没有任何方法可以修改对象
的状态 所有的属性都应该是私有的
强不变模式：一个类的实例不可改变，子类的实例也不可改变，满足弱不变模式还要满足
1 类所有的方法都应当是 final，这样这个类的子类不能够换掉此类的方法
2 这个类本身就是 final 的，不存在子类
在 java 中的应用：最著名的就是 String 类，它是一个强不变类，
12121212，，，，策略模式策略模式策略模式策略模式。策略模式（Strategy Pattern）中体现了两个非常基本的面向对象设计的基本原则：封装变化的概念；编程中使用接
口，而不是对接口实现。策略模式的定义如下：
定义一组算法，将每个算法都封装起来，并且使它们之间可以互换。策略模式使这些算法在客户端调用它们的时候能够互不影
响地变化。
策略模式的好处在于你可以动态的改变对象的行为。
public class Context{public class Context{public class Context{public class Context{
public void contextInterface(){
strategy.strategyInterface();
}
private Strategy strategy;
}
abstract public class Strategabstract public class Strategabstract public class Strategabstract public class Strategyyyy{
public abstract void strategyInterface();
}
public class Copublic class Copublic class Copublic class ConcreteStrategyncreteStrategyncreteStrategyncreteStrategy1111 extends Strategyextends Strategyextends Strategyextends Strategy{
public void strategyInterface(){
//write you algorithm code here
//写自己独特的算法
}
}
从中可以看出，策略模式并不负责安排哪种情况应用哪种算法，
需要客户端来指定。策略模式只能同时应用一种策略。
在 Java 中 BorderLayout，排序算法等地方都应用了 Strategy 模式。
可以应用在不同商品的打折算法不一样上可以应用在不同商品的打折算法不一样上可以应用在不同商品的打折算法不一样上可以应用在不同商品的打折算法不一样上