策略模式
策略模式定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户
公司做了一个模拟鸭子的游戏，这些鸭子可以叫和游泳，现在想让这些鸭子飞
这样做会让橡皮鸭也具备飞的行为，虽然在fly()中可以不做任何动作，如果每次进来一个鸭子就覆盖方法，很不好，例如：诱饵鸭不会飞也不会叫，橡皮鸭不会飞也不会叫
将飞和叫的行为弄成接口会造成代码无法复用
把飞行和交的行为弄成接口，具体的叫法由类具体实现
public interface FlyBehavior {
/*
* 飞行行为接口
*/
public void fly();
}public class FlyNoWay implements FlyBehavior
/*
* 不能飞行的行为
*/
@Override
public void fly() {
System.out.println("I can't fly");
}
}
public class FlyWithWings implements FlyBehavior
/*
* 可以飞行的行为
*/
@Override
public void fly() {
System.out.println("I'm flying");
}
}
public interface QuackBehavior {
/*
* 叫的行为接口
*/
public void quack();
}public class Quack implements QuackBehavior
/*
* 嘎嘎叫
*/
@Override
public void quack() {
System.out.println("quack");
}
}
public class Squeak implements QuackBehavior{
/*
* 吱吱叫
*/
@Override
public void quack() {
System.out.println("squeak");
}
}public abstract class Duck {
/*
* 鸭子抽象类
*/
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public Duck() {};
public abstract void displaly();
public void performFly() {
flyBehavior.fly();
}
public void performQuack() {
quackBehavior.quack();
}
public void swim() {
System.out.println("All ducks float");
}
//可以动态设置鸭子的行为
public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}
public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}
}public class MallardDuck extends Duck{
/*
* 绿头鸭实现类
*/
public MallardDuck() {
quackBehavior = new Quack();
flyBehavior = new FlyWithWings();
}
@Override
public void displaly() {
System.out.println("I'm a real Mallard duck");
}
}public class MiniDuckSimulator {
/*
* 测试类
*/
public static void main(String[] args) {
Duck mallard = new MallardDuck();
//I'm flying
mallard.performFly();
//quack加上一个模型鸭，使模型鸭可以动态改变行为，在后期使模型鸭具有火箭动力
public class FlyRocketPowered implements FlyBehavior
/*
* 具有火箭动力的飞行
*/
@Override
public void fly() {
System.out.println("I'm flying with a rocket");
}
}
public class ModelDuck extends Duck
/*
* 模型鸭
*/
public ModelDuck() {
flyBehavior = new FlyNoWay();
quackBehavior = new Quack();
}
@Override
public void displaly() {
System.out.println("I'm a model duck");
}
}
public class MiniDuckSimulator {
/*
* 测试类
*/
public static void main(String[] args) {
Duck mallard = new MallardDuck();
//I'm flying
mallard.performFly();
//quack
mallard.performQuack();
Duck model = new ModelDuck();
//I can't fly
model.performFly();
model.setFlyBehavior(new FlyRocketPowered());
//I'm flying with a rocket观察者模式
观察者模式定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新
为了展示气象数据而封装了一个数据对象WeatherData，当气象数据更新的时候，所有布告板上的显示都得发生改变，这时系统调用WeaherData对象的measurementsChanged()方法，错误的示例如下：
定义观察者模式
最终的类图
public interface Subject {
/*
* 主题对象实现的接口
*/
//注册观察者
public void registerObserver(Observer o);
//删除观察者
public void removeObserver(Observer o);
//当主题状态改变时，这个方法会被调用，以通知所有的的观察者
public void notifyObservers();
}public interface Observer {
/*
* 观察者对象实现的接口
*/
public void update(float temp, float humidity, floatpublic interface DisplayElement {
/*
* 展示行为的接口
*/
public void display();
}实现气象数据对象
public class WeatherData implements Subject{
private ArrayList observers;
private float temperature;
private float humidity;
private float pressure;
public WeatherData() {
observers = new ArrayList();
}
@Override
public void registerObserver(Observer o) {
observers.add(o);
}
@Override
public void removeObserver(Observer o) {
int i = observers.indexOf(o);
if (i >= 0) {
observers.remove(i);
}
}
@Override
public void notifyObservers() {
for (int i=0; i<observers.size(); i++) {
Observer observer = (Observer)observers.get(i);
observer.update(temperature, humidity, pressure);
}
}
public void measurementsChanged() {
notifyObservers();
}
public void setMeasurements(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged();
}
}实现布告板
public class CurrentConditionsDisplay implements Observer, DisplayElement{
private float temperature;
private float humidity;
private Subject weatherData;
public CurrentConditionsDisplay(Subject weatherData) {
this.weatherData = weatherData;
weatherData.registerObserver(this);
}
@Override
public void display() {
System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
}
@Override
public void update(float temp, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
display();
}
}测试类
public class WeatherStation {
public static void main(String[] args) {
WeatherData weatherData = new WeatherData();
CurrentConditionsDisplay currentConditionsDisplay = new CurrentConditionsDisplay(weatherData);
//Current conditions: 80.0F degrees and 65.0% humidity
weatherData.setMeasurements(80, 65, 30.4f);
}
}装饰者模式
装饰者模式动态的将责任附加到对象上。想要扩展功能，装饰者提供有别于继承的另一种选择，可以在不修改底层代码的情况下，给对象赋予新的职责
咖啡店的类设计原来是这样的
但是顾客会要求加入各种调料，如蒸奶(Steamed Milk)，豆浆(Soy)
用父类计算调料的价钱，子类计算饮料的价钱
哪些需求或因素改变时会影响这个设计
以装饰者构造饮料订单
装饰者模式动态的将责任附加到对象上，若要扩展功能，装饰者提供了比继承更有弹性的替代方案
public abstract class Beverage {
/*
* Beverage类
*/
String description = "Unknown Beverage";
public String getDescription() {
return description;
}
public abstract double cost();
}public abstract class CondimentDecorator extends Beverage{
/*
* 调料装饰抽象类
*/
@Override
public abstract String getDescription();
}public class Espresso extends Beverage
/*
* 浓缩咖啡类
*/
public Espresso() {
description = "Espresso";
}
@Override
public double cost() {
return 1.99;
}
}
public class HouseBlend extends Beverage
/*
* 另一种咖啡类
*/
public HouseBlend() {
description = "House Blend Coffee";
}
@Override
public double cost() {
return 0.89;
}
}
已经有了抽象组件（Beverage），具体组件（HouseBlend）,抽象装饰者（CondimentDecorator），下面实现具体装饰者
public class Mocha extends CondimentDecorator
/*
* 摩卡装饰者
*/
Beverage beverage;
public Mocha(Beverage beverage) {
this.beverage = beverage;
}
@Override
public String getDescription() {
return beverage.getDescription() + ", Mocha";
}
@Override
public double cost() {
return 0.20
public class Whip extends CondimentDecorator
/*
* 奶油装饰者
*/
Beverage beverage;
public Whip(Beverage beverage) {
this.beverage = beverage;
}
@Override
public String getDescription() {
return beverage.getDescription() + ", Whip";
}
@Override
public double cost() {
return 0.58
public class StarBuzzCoffee {
public static void main(String[] args) {
/*
* 测试类
*/
Beverage beverage = new Espresso();
//Espresso $1.99
System.out.println(beverage.getDescription() + " $" + beverage.cost());
Beverage beverage2 = new HouseBlend();
beverage2 = new Mocha(beverage2);
beverage2 = new Mocha(beverage2);
beverage2 = new Whip(beverage2);
//House Blend Coffee, Mocha, Mocha, Whip $1.87
System.out.println(beverage2.getDescription() + " $"
装饰Java io类
test.txt
This Is Just For
public class LowerCaseInputStream extends FilterInputStream
/*
* 自己的装饰类,将大写字母转为小写字母
*/
protected LowerCaseInputStream(InputStream in) {
super(in);
}
@Override
public int read() throws IOException {
int c = super.read();
return (c == -1 ? -1 : Character.toLowerCase((char)c));
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
int result = super.read(b, off, len);
for (int i=off; i<=off+result; i++) {
b[i] = (byte)Character.toLowerCase((char)b[i]);
}
return
public class InputTest {
public static void main(String[] args) {
/*
* 测试自己的装饰类
*/
int c;
try {
InputStream in = new LowerCaseInputStream(new BufferedInputStream(new FileInputStream("test.txt")));
while ((c = in.read()) >= 0) {
//this is just for test
System.out.print((char)c);
}
in.close();
} catch工厂模式
工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类
有订购披萨的工具如下
当披萨菜单发生改变时，代码必须进行修改。我们可以把创建对象移到orderPizza()之外，如下所示
public abstract class Pizza {
/*
* 披萨类
*/
String name;
//面团
String dough;
//酱
String sauce;
//糕点上的装饰配料
ArrayList toppings = new ArrayList();
void prepare() {
System.out.println("Preparing " + name);
System.out.println("Tossing dough...");
System.out.println("Adding sauce...");
System.out.println("Adding toppings : ");
for (int i = 0; i < toppings.size(); i++) {
System.out.println(" " + toppings.get(i));
}
}
//烤
void bake() {
System.out.println("Bake for 25 minutes at 350");
}
void cut() {
System.out.println("Cutting the pizza into diagonal slices");
}
void box() {
System.out.println("Place pizza in official PizzaStore box");
}
String getName() {
returnpublic class NYStyleCheesePizza extends Pizza{
/*
* 纽约风味的芝士披萨类
*/
public NYStyleCheesePizza() {
//大蒜番茄酱和薄饼
name = "NY Style Sauce and Chees Pizza";
dough = "Thin Crust Dough";
sauce = "Marinara Sauce";
toppings.add("Grated Reggiano Cheese");
}
}public class ChicagoStyleCheesePizza extends Pizza
/*
* 芝加哥风味的芝士披萨
*/
public ChicagoStyleCheesePizza() {
//小番茄厚饼
name = "Chicago Style Deep Dish Cheese Pizza";
dough = "Extra Thick Crust Dough";
sauce = "Plum Tomato Sauce";
toppings.add("Shredded Mozzarella Cheese");
}
void cut() {
//覆盖了cut()方法，将披萨切成正方形
System.out.println("Cutting the pizza into square slices");
}
}
public abstract class PizzaStore {
/*
* 披萨店的抽象类
*/
public Pizza orderPizza(String type) {
Pizza pizza;
pizza = createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
//工厂方法是抽象的
protected abstract Pizza createPizza(String type);
}public class NYPizzaStore extends PizzaStore{
/*
* 纽约风味的披萨店
*/
@Override
protected Pizza createPizza(String type) {
if (type.equals("cheese")) {
return new NYStyleCheesePizza();
} else if (type.equals("veggie")) {
//没有写这个类，只是举一个例子，动态的创建类
//return new NYStyleVeggiePizza();
}
return null;
}
}public class ChicagoPizzaStore extends PizzaStore{
/*
* 芝加哥风味的披萨店
*/
@Override
protected Pizza createPizza(String type) {
if (type.equals("cheese")) {
return new ChicagoStyleCheesePizza();
} else if (type.equals("veggie")) {
//根据要求动态创建类
//return new ChicagoStyleVeggiePizza();
}
return null;
}
}测试类
public class PizzaTestDrive {
public static void main(String[] args) {
PizzaStore nyStore = new NYPizzaStore();
PizzaStore chicagoStore = new ChicagoPizzaStore();
/*Preparing NY Style Sauce and Chees Pizza
Tossing dough...
Adding sauce...
Adding toppings :
Grated Reggiano Cheese
Bake for 25 minutes at 350
Cutting the pizza into diagonal slices
Place pizza in official PizzaStore box*/
Pizza pizza = nyStore.orderPizza("cheese");
//order a NY Style Sauce and Chees Pizza
System.out.println("order a " + pizza.getName() + "\n");
/*Preparing Chicago Style Deep Dish Cheese Pizza
Tossing dough...
Adding sauce...
Adding toppings :
Shredded Mozzarella Cheese
Bake for 25 minutes at 350
Cutting the pizza into square slices
Place pizza in official PizzaStore box*/
pizza = chicagoStore.orderPizza("cheese");
//order a Chicago Style Deep Dish Cheese Pizza
System.out.println("order a " + pizza.getName() + "\n");
}
}抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类
现在，我们要建造一个工厂来生产原料，这个工厂负责创建原料家族中的每一种原料，因为每个地区所需要的原料是不同的
public interface PizzaIngredientFactory {
/*
* 披萨原料工厂的抽象类
*/
//面团
public Dough createDough();
//酱
public Sauce createSauce();
//奶酪
public Cheese createCheese();
//蔬菜
public Veggies[] createVeggies();
//意大利辣味香肠
public Pepperoni createPepperoni();
//蛤
public Clams createClam();
}public class NYPizzaIngredientFactory implements PizzaIngredientFactory{
/*
* 纽约披萨原料工厂类
*/
@Override
public Dough createDough() {
return new ThinCrustDough();
}
@Override
public Sauce createSauce() {
return new MarinaraSauce();
}
@Override
public Cheese createCheese() {
return new ReggianoCheese();
}
@Override
public Veggies[] createVeggies() {
//里面的原料实现Veggies的接口类
Veggies veggies[] = { new Garlic(), new Onion(), new Mushroom(), new RedPepper() };
return veggies;
}
@Override
public Pepperoni createPepperoni() {
return new SlicedPepperoni();
}
@Override
public Clams createClam() {
return newpublic abstract class Pizza {
/*
* 修改后的披萨类
*/
String name;
//可以将dough弄为一个接口，让具体的类实现它
Dough dough;
//同理将sauce弄为一个接口
Sauce sauce;
//将veggies弄为一个接口
Veggies veggies[];
Cheese cheese;
Pepperoni pepperoni;
Clams clam;
//把prepare方法声明成抽象。在这个方法中，我们需要收集披萨所需的原料，而这些原料当然是来自原料工厂了
abstract void prepare();
void bake() {
System.out.println("Bake for 25 minutes at 350");
}
void cut() {
System.out.println("Cutting the pizza into diagonal slices");
}
void box() {
System.out.println("Place pizza in official PizzaStore box");
}
void setName(String name) {
this.name = name;
}
String getName() {
returnpublic class CheesePizza extends Pizza{
PizzaIngredientFactory ingredientFactory;
public CheesePizza(PizzaIngredientFactory ingredientFactory) {
this.ingredientFactory = ingredientFactory;
}
@Override
void prepare() {
System.out.println("Preparing "public class NYPizzaStore extends PizzaStore
/*
* 修改后的纽约风味的披萨店
*/
@Override
protected Pizza createPizza(String type) {
Pizza pizza = null;
PizzaIngredientFactory ingredientFactory =
new NYPizzaIngredientFactory();
if (type.equals("cheese")) {
pizza = new CheesePizza(ingredientFactory);
pizza.setName("New York Style Cheese Pizza");
} else if (type.equals("veggie")) {
pizza = new VeggiePizza(ingredientFactory);
pizza.setName("New York Style Veggie Pizza");
} else if (type.equals("clam")) {
pizza = new ClamPizza(ingredientFactory);
pizza.setName("New York Style Clam Pizza");
}
return
看类图了解关系
从PizzaStore的观点来看
单例模式
单例模式确保一个类只有一个实例，并提供全局访问点
经典的单例模式实现
public class Singleton {
//独特的实例
private static Singleton uniqueInstance;
//私有化构造函数，这样就不能通过new来创建这个对象
private Singleton() {}
//声明为静态方法，这样就可通过Singleton.getInstance()方法来获得Singleton对象
public static Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return如果是多线程则会造成问题，解决方法一
public static synchronized Singleton getInstance() {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
return这样会对性能造成问题，解决方法二
public class Singleton {
private static Singleton uniqueInstance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return加载类时直接创建，解决方法三
public class Singleton {
//volatile关键字确保，当uniqueInstance变量被初始化成Singleton实例时，
//多个线程正确地处理uniqueInstance变量
private volatile static Singleton uniqueInstance;
private Singleton() {}
public static Singleton getInstance() {
if (uniqueInstance == null) {
synchronized (Singleton.class) {
if (uniqueInstance == null) {
uniqueInstance = new Singleton();
}
}
}
return命令模式
命令模式将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作
有一个遥控器，有7个插槽，每个插槽有开和关2个按钮用来操作电器，类似如下实现是非常糟糕的，有新厂商进来就得修改代码
if (slot1 == Light) {
light.on()
} else if一种借鉴的思路是去餐厅吃饭，服务员把你想吃的东西写到菜单上，然后把菜单给了厨师，厨师按照菜单做就行，而不是让服务员直接告诉厨师应该做哪些东西，先写一个简单的Demo
public interface Command {
/*
* 命令接口
*/
public void execute();
}public class Light {
/*
* 灯类
*/
public Light() {
}
public void on() {
System.out.println("Light is on");
}
public void off() {
System.out.println("Light is off");
}
}public class LightOnCommand implements Command{
/*
* 打开灯的命令
*/
Light light;
public LightOnCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.on();
}
}public class SimpleRemoteControl {
/*
* 简单遥控器类
*/
Command slot;
public SimpleRemoteControl() {}
public void setCommand(Command command) {
slot = command;
}
public void buttonWasPressed() {
slot.execute();
}
}测试类
public class RemoteControlTest {
public static void main(String[] args) {
SimpleRemoteControl remote = new SimpleRemoteControl();
Light light = new Light();
LightOnCommand lightOn = new LightOnCommand(light);
remote.setCommand(lightOn);
//Light is on命令模式的作用：
- 队列请求–>日程安排，线程池，工作队列，想象有一个工作队列：你在某一端添加命令，然后另一端是线程。线程进行下面的动作：从嘟列中取出一个命令，调用它的execute()方法，等待这个调用完成，然后将此命令丢弃，再取出下一个命令，这样工作队列类和进行计算的对象之间是完全解耦的，此刻线程可能进行财务运算，下一刻却在读取网路数据。工作队列只知道取出命令对象，然后调用其execute()方法。
- 日志请求–>某些应用需要我们将所有的动作都记录在日志中，并能在系统死机之后，重新调用这些动作恢复到之前的状态
适配器模式
适配器模式将一个类的接口，装换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间
包装了鸭子适配器的火鸡
public interface Duck {
/*
* 鸭子接口
*/
public void quack();
public void fly();
}public interface Turkey {
/*
* 火鸡接口
*/
public void gobble();
public void fly();
}public class MallardDuck implements Duck
/*
* 野鸭类
*/
@Override
public void quack() {
System.out.println("Quack");
}
@Override
public void fly() {
System.out.println("I'm flying");
}
}
public class WildTurkey implements Turkey
/*
* 野生火鸡类
*/
@Override
public void gobble() {
System.out.println("Gobble gobble");
}
@Override
public void fly() {
System.out.println("I'm flying a short distance");
}
}
public class TurkeyAdapter implements Duck
/*
* 适配器类
*/
Turkey turkey;
public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}
@Override
public void quack() {
turkey.gobble();
}
@Override
public void fly() {
//多飞几次模拟鸭子
for (int i=0; i<3; i++)
turkey.fly();
}
}
public class DuckTest {
/*
* 测试类
*/
public static void main(String[] args) {
Duck duck = new MallardDuck();
//Quack
duck.quack();
//I'm flying
duck.fly();
WildTurkey turkey = new WildTurkey();
Duck turkeyAdapter = new TurkeyAdapter(turkey);
//Gobble gobble
turkeyAdapter.quack();
//I'm flying a short distance
//I'm flying a short distance
//I'm flying a short distance类图
外观模式
外观模式提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用
当我们在家庭影院观看电影时，要做很多事情，如打开爆米花机，开始爆米花，将灯光调暗，放下屏幕等，我们可以通过实现一个提供更合理的接口的外观类，将一个复杂的子系统变得容易使用
public class HomeTheaterFacade {
/*
* 家庭影院外观类
*/
Amplifier amp;
Tuner tuner;
DvdPlayer dvd;
CdPlayer cd;
Projector projector;
TheaterLights lights;
Screen screen;
PopcornPopper popper;
public HomeTheaterFacade(Amplifier amp,
Tuner tuner,
DvdPlayer dvd,
CdPlayer cd,
Projector projector,
Screen screen,
TheaterLights lights,
PopcornPopper popper) {
this.amp = amp;
this.tuner = tuner;
this.dvd = dvd;
this.cd = cd;
this.projector = projector;
this.screen = screen;
this.lights = lights;
this.popper = popper;
}
public void watchMovie(String movie) {
System.out.println("Get ready to watch a movie...");
popper.on();
popper.pop();
lights.dim(10);
screen.down();
projector.on();
projector.wideScreenMode();
amp.on();
amp.setDvd(dvd);
amp.setSurroundSound();
amp.setVolume(5);
dvd.on();
dvd.play(movie);
}
public void endMovie() {
System.out.println("Shutting movie theater down...");
popper.off();
lights.on();
screen.up();
projector.off();
amp.off();
dvd.stop();
dvd.eject();
dvd.off();当我们想看电影时，只要调用watchMovie()方法，关闭电影时只要调用endMovie()方法，省去了很多繁琐的操作
类图
模板方法模式
模板方法模式在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤
要开发咖啡和茶的冲泡方法，它们的过程如下：
刚开始我们想到的是抽取咖啡和茶
其中prepareRecipe()方法是包含四个方法的合集，接着我们对2步和第4步不同的部分进一步抽象，抽象出一个咖啡因饮料的类
public abstract class CaffeineBeverage {
/*
* 咖啡因饮料是一个抽象类
*/
//不希望子类覆盖这个方法，并且将步骤2和步骤4泛化为brew()和addCondiments()
final void prepareRecipe() {
boilWater();
brew();
pourInCup();
addCondiments();
}
protected abstract void brew();
protected abstract void addCondiments();
private void boilWater() {
System.out.println("Boiling water");
}
private void pourInCup() {
System.out.println("Pouring into cup");
}
}public class Tea extends CaffeineBeverage{
@Override
protected void brew() {
System.out.println("Steeping the tea");
}
@Override
protected void addCondiments() {
System.out.println("Adding Lemon");
}
}public class Coffee extends CaffeineBeverage{
@Override
protected void brew() {
System.out.println("Dripping Coffee through filter");
}
@Override
protected void addCondiments() {
System.out.println("Adding Sugar and Milk");
}
}测试类
public class BeverageTestDrive {
public static void main(String[] args) {
Tea tea = new Tea();
/*Boiling water
Steeping the tea
Pouring into cup
Adding Lemon*/看看抽象类可以有哪些类型的方法
接下来我们队模板方法进行挂钩（只写出了变化的部分）
public abstract class CaffeineBeverage
/*
* 咖啡因饮料是一个抽象类
*/
//不希望子类覆盖这个方法，并且将步骤2和步骤4泛化为brew()和addCondiments()
final void prepareRecipe() {
boilWater();
brew();
pourInCup();
//如果顾客想要调料，只有这时我们才调用addCondiments()
if (customerWantsClondiments()) {
addCondiments();
}
}
//定义了一个空的缺省实现，子类可以覆盖，但不见得一定要这么做
boolean customerWantsClondiments() {
return true;
}
}
public class Coffee extends CaffeineBeverage{
@Override
boolean customerWantsClondiments() {
String answer = getUserInput();
if (answer.toLowerCase().startsWith("y")) {
return true;
} else {
return false;
}
}
private String getUserInput() {
String answer = null;
System.out.println("Would you like milk and sugar with you coffee (y/n) ?");
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
try {
answer = in.readLine();
} catch (IOException e) {
System.err.println("IO error trying to read your answer");
}
if (answer == null) {
return "no";
}
return测试类
public class BeverageTestDrive {
public static void main(String[] args) {
Coffee coffee = new Coffee();
/*Boiling water
Dripping Coffee through filter
Pouring into cup
Would you like milk and sugar with you coffee (y/n) ? y
Adding Sugarand Milk*/用模板方法排序
迭代器模式
迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示
对象村餐厅和对象村煎饼屋进行合并，他们都同意菜单的表示方法，即MenuItem类，但煎饼屋是用ArrayList进行存储，餐厅是用数组存储，如果每次是获取容器在进行遍历，非常不方便，菜单的定义如下。
public class MenuItem
String name;
String description;
boolean vegetarian;
double price;
public MenuItem(String name,
String description,
boolean vegetarian,
double price)
{
this.name = name;
this.description = description;
this.vegetarian = vegetarian;
this.price = price;
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
public double getPrice() {
return price;
}
public boolean isVegetarian() {
return vegetarian;
}
public String toString() {
return (name + ", $" + price + "\n "
可以让菜单都继承Menu这个接口，接口的作用是使每个菜单都能通过统一的方法获得各自的Iterator
public interface Menu {
public Iterator createIterator();
}Iterator这个接口规定了遍历的方法
public interface
餐厅存储实现类
public class DinerMenu implements Menu
static final int MAX_ITEMS = 6;
int numberOfItems = 0;
MenuItem[] menuItems;
public DinerMenu() {
menuItems = new MenuItem[MAX_ITEMS];
addItem("Vegetarian BLT",
"(Fakin') Bacon with lettuce & tomato on whole wheat", true, 2.99);
addItem("BLT",
"Bacon with lettuce & tomato on whole wheat", false, 2.99);
addItem("Soup of the day",
"Soup of the day, with a side of potato salad", false, 3.29);
addItem("Hotdog",
"A hot dog, with saurkraut, relish, onions, topped with cheese",
false, 3.05);
addItem("Steamed Veggies and Brown Rice",
"Steamed vegetables over brown rice", true, 3.99);
addItem("Pasta",
"Spaghetti with Marinara Sauce, and a slice of sourdough bread",
true, 3.89);
}
public void addItem(String name, String description,
boolean vegetarian, double price)
{
MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
if (numberOfItems >= MAX_ITEMS) {
System.err.println("Sorry, menu is full! Can't add item to menu");
} else {
menuItems[numberOfItems] = menuItem;
numberOfItems = numberOfItems + 1;
}
}
public Iterator createIterator() {
return new DinerMenuIterator(menuItems);
}
// other menu methods here
餐厅存储遍历类
public class DinerMenuIterator implements Iterator
MenuItem[] items;
int position = 0;
public DinerMenuIterator(MenuItem[] items) {
this.items = items;
}
public Object next() {
MenuItem menuItem = items[position];
position = position + 1;
return menuItem;
}
public boolean hasNext() {
if (position >= items.length || items[position] == null) {
return false;
} else {
return true;
}
}
}
煎饼存储实现类
public class PancakeHouseMenu implements Menu
ArrayList menuItems;
public PancakeHouseMenu() {
menuItems = new ArrayList();
addItem("K&B's Pancake Breakfast",
"Pancakes with scrambled eggs, and toast",
true,
2.99);
addItem("Regular Pancake Breakfast",
"Pancakes with fried eggs, sausage",
false,
2.99);
addItem("Blueberry Pancakes",
"Pancakes made with fresh blueberries",
true,
3.49);
addItem("Waffles",
"Waffles, with your choice of blueberries or strawberries",
true,
3.59);
}
public void addItem(String name, String description,
boolean vegetarian, double price)
{
MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
menuItems.add(menuItem);
}
public Iterator createIterator() {
return new PancakeHouseMenuIterator(menuItems);
}
public String toString() {
return "Objectville Pancake House Menu";
}
// other menu methods here
当然，上述的createIterator方法可以用ArrayList的iterator()方法
煎饼遍历类
public class PancakeHouseMenuIterator implements Iterator
ArrayList items;
int position = 0;
public PancakeHouseMenuIterator(ArrayList items) {
this.items = items;
}
public Object next() {
Object object = items.get(position);
position = position + 1;
return object;
}
public boolean hasNext() {
if (position >= items.size()) {
return false;
} else {
return true;
}
}
}
服务员类
public class Waitress {
Menu pancakeHouseMenu;
Menu dinerMenu;
public Waitress(Menu pancakeHouseMenu, Menu dinerMenu) {
this.pancakeHouseMenu = pancakeHouseMenu;
this.dinerMenu = dinerMenu;
}
public void printMenu() {
Iterator pancakeIterator = pancakeHouseMenu.createIterator();
Iterator dinerIterator = dinerMenu.createIterator();
System.out.println("MENU\n----\nBREAKFAST");
printMenu(pancakeIterator);
System.out.println("\nLUNCH");
printMenu(dinerIterator);
}
private void printMenu(Iterator iterator) {
while (iterator.hasNext()) {
MenuItem menuItem = (MenuItem)iterator.next();
System.out.print(menuItem.getName() + ", ");
System.out.print(menuItem.getPrice() + " -- ");
System.out.println(menuItem.getDescription());
}
}
public void printVegetarianMenu() {
printVegetarianMenu(pancakeHouseMenu.createIterator());
printVegetarianMenu(dinerMenu.createIterator());
}
public boolean isItemVegetarian(String name) {
Iterator breakfastIterator = pancakeHouseMenu.createIterator();
if (isVegetarian(name, breakfastIterator)) {
return true;
}
Iterator dinnerIterator = dinerMenu.createIterator();
if (isVegetarian(name, dinnerIterator)) {
return true;
}
return false;
}
private void printVegetarianMenu(Iterator iterator) {
while (iterator.hasNext()) {
MenuItem menuItem = (MenuItem)iterator.next();
if (menuItem.isVegetarian()) {
System.out.print(menuItem.getName());
System.out.println("\t\t" + menuItem.getPrice());
System.out.println("\t" + menuItem.getDescription());
}
}
}
private boolean isVegetarian(String name, Iterator iterator) {
while (iterator.hasNext()) {
MenuItem menuItem = (MenuItem)iterator.next();
if (menuItem.getName().equals(name)) {
if (menuItem.isVegetarian()) {
return true;
}
}
}
return false;
}
}测试类
public class MenuTestDrive {
public static void main(String args[]) {
PancakeHouseMenu pancakeHouseMenu = new PancakeHouseMenu();
DinerMenu dinerMenu = new DinerMenu();
Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
/*
MENU
----
BREAKFAST
K&B's Pancake Breakfast, 2.99 -- Pancakes with scrambled eggs, and toast
Regular Pancake Breakfast, 2.99 -- Pancakes with fried eggs, sausage
Blueberry Pancakes, 3.49 -- Pancakes made with fresh blueberries
Waffles, 3.59 -- Waffles, with your choice of blueberries or strawberries
LUNCH
Vegetarian BLT, 2.99 -- (Fakin') Bacon with lettuce & tomato on whole wheat
BLT, 2.99 -- Bacon with lettuce & tomato on whole wheat
Soup of the day, 3.29 -- Soup of the day, with a side of potato salad
Hotdog, 3.05 -- A hot dog, with saurkraut, relish, onions, topped with cheese
Steamed Veggies and Brown Rice, 3.99 -- Steamed vegetables over brown rice
Pasta, 3.89 -- Spaghetti with Marinara Sauce, and a slice of类图如下
组合模式
组合模式允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合
新的问题来了，每次加入新的菜单时，服务员的printMenu(Iterator)方法就得被调用，如上2个菜单调用了2次，3个菜单就得调用三次，这是一个不好的实现
然而我们不仅想支持多个菜单，还想支持菜单中的菜单，如下所示，将甜点菜单变成餐厅菜单集合的一个元素
组合模式的类图如下
改写餐厅菜单的类图
public abstract class MenuComponent {
/*
* 菜单组件抽象类
*/
public void add(MenuComponent menuComponent) {
throw new UnsupportedOperationException();
}
public void remove(MenuComponent menuComponent) {
throw new UnsupportedOperationException();
}
public MenuComponent getChild(int i) {
throw new UnsupportedOperationException();
}
public String getName() {
throw new UnsupportedOperationException();
}
public String getDescription() {
throw new UnsupportedOperationException();
}
public double getPrice() {
throw new UnsupportedOperationException();
}
public boolean isVegetarian() {
throw new UnsupportedOperationException();
}
public abstract Iterator createIterator();
public void print() {
throw newimport java.util.ArrayList;
import java.util.Iterator;
public class Menu extends MenuComponent{
/*
* 菜单类，即组合类
*/
ArrayList menuComponents = new ArrayList();
String name;
String description;
public Menu(String name, String description) {
this.name = name;
this.description = description;
}
public void add(MenuComponent menuComponent) {
menuComponents.add(menuComponent);
}
public void remove(MenuComponent menuComponent) {
menuComponents.remove(menuComponent);
}
public MenuComponent getChild(int i) {
return (MenuComponent)menuComponents.get(i);
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
@Override
public Iterator createIterator() {
return new CompositeIterator(menuComponents.iterator());
}
public void print() {
System.out.print("\n" + getName());
System.out.println(", " + getDescription());
System.out.println("---------------------");
Iterator iterator = menuComponents.iterator();
while
import java.util.Iterator;
public class MenuItem extends MenuComponent{
/*
* 菜单项类，这是组合类图里的叶类
*/
String name;
String description;
boolean vegetarian;
double price;
public MenuItem(String name,
String description,
boolean vegetarian,
double price)
{
this.name = name;
this.description = description;
this.vegetarian = vegetarian;
this.price = price;
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
public double getPrice() {
return price;
}
public boolean isVegetarian() {
return vegetarian;
}
@Override
public Iterator createIterator() {
return new NullIterator();
}
public void print() {
System.out.println(" " + getName());
if (isVegetarian()) {
System.out.println("(v)");
}
System.out.println(", " + getPrice());
System.out.println(" ----"
import java.util.Iterator;
import java.util.Stack;
public class CompositeIterator implements Iterator{
/*
* 组合迭代器，遍历菜单和子菜单
*/
Stack stack = new Stack();
public CompositeIterator(Iterator iterator) {
stack.push(iterator);
}
@Override
public boolean hasNext() {
if (stack.empty()) {
return false;
} else {
//peek方法不弹出栈顶
Iterator iterator = (Iterator) stack.peek();
if (!iterator.hasNext()) {
//子组合已经没有菜单项了，将栈顶元素弹出
stack.pop();
//返回下一个子组合的结果
return hasNext();
} else {
return true;
}
}
}
@Override
public Object next() {
if (hasNext()) {
//peek方法不弹出栈顶元素
Iterator iterator = (Iterator) stack.peek();
MenuComponent component = (MenuComponent) iterator.next();
if (component instanceof Menu) {
stack.push(component.createIterator());
}
return component;
} else {
return null;
}
}
@Override
public void remove() {
throw new
import java.util.Iterator;
public class NullIterator implements Iterator{
@Override
public boolean hasNext() {
return false;
}
@Override
public Object next() {
return null;
}
@Override
public void remove() {
throw new
我们可以让菜单项的createIterator()方法返回null，但是如果这么做，我们的客户代码就需要条件语句来判断返回值是否为null，因此我们创建一个迭代器，其作用是“没作用”
import java.util.Iterator;
public class Waitress {
/*
* 服务员类
*/
MenuComponent allMenus;
public Waitress(MenuComponent allMenus) {
this.allMenus = allMenus;
}
public void printMenu() {
allMenus.print();
}
public void printVegetarianMenu() {
Iterator iterator = allMenus.createIterator();
System.out.println("\nVEGETARIAN MENU\n----");
while (iterator.hasNext()) {
MenuComponent menuComponent = (MenuComponent)iterator.next();
try {
if (menuComponent.isVegetarian()) {
menuComponent.print();
}
} catch
测试类
public class MenuTestDrive {
public static void main(String args[]) {
MenuComponent dinerMenu = new Menu("DINER MENU", "Lunch");
MenuComponent cafeMenu = new Menu("CAFE MENU", "Dinner");
MenuComponent dessertMenu = new Menu("DESSERT MENU", "Dessert of course!");
MenuComponent allMenus = new Menu("ALL MENUS", "All menus combined");
allMenus.add(dinerMenu);
allMenus.add(cafeMenu);
dinerMenu.add(new MenuItem(
"Vegetarian BLT",
"(Fakin') Bacon with lettuce & tomato on whole wheat",
true,
2.99));
dinerMenu.add(new MenuItem(
"BLT",
"Bacon with lettuce & tomato on whole wheat",
false,
2.99));
//将dessertMenu作为dinerMenu的子菜单
dinerMenu.add(dessertMenu);
dessertMenu.add(new MenuItem(
"Apple Pie",
"Apple pie with a flakey crust, topped with vanilla icecream",
true,
1.59));
dessertMenu.add(new MenuItem(
"Cheesecake",
"Creamy New York cheesecake, with a chocolate graham crust",
true,
1.99));
cafeMenu.add(new MenuItem(
"Veggie Burger and Air Fries",
"Veggie burger on a whole wheat bun, lettuce, tomato, and fries",
true,
3.99));
cafeMenu.add(new MenuItem(
"Soup of the day",
"A cup of the soup of the day, with a side salad",
false,
3.69));
Waitress waitress = new输出
ALL MENUS, All menus combined
---------------------
DINER MENU, Lunch
---------------------
Vegetarian BLT
(v)
, 2.99
----(Fakin') Bacon with lettuce & tomato on whole wheat
BLT
, 2.99
----Bacon with lettuce & tomato on whole wheat
DESSERT MENU, Dessert of course!
---------------------
Apple Pie
(v)
, 1.59
----Apple pie with a flakey crust, topped with vanilla icecream
Cheesecake
(v)
, 1.99
----Creamy New York cheesecake, with a chocolate graham crust
CAFE MENU, Dinner
---------------------
Veggie Burger and Air Fries
(v)
, 3.99
----Veggie burger on a whole wheat bun, lettuce, tomato, and fries
Soup of the day
, 3.69
----A cup of the soup of the day, with a side salad
VEGETARIAN MENU
----
Vegetarian BLT
(v)
, 2.99
----(Fakin') Bacon with lettuce & tomato on whole wheat
Apple Pie
(v)
, 1.59
----Apple pie with a flakey crust, topped with vanilla icecream
Cheesecake
(v)
, 1.99
----Creamy New York cheesecake, with a chocolate graham crust
Apple Pie
(v)
, 1.59
----Apple pie with a flakey crust, topped with vanilla icecream
Cheesecake
(v)
, 1.99
----Creamy New York cheesecake, with a chocolate graham crust
Veggie Burger and Air Fries
(v)
, 3.99
----Veggie burger on a whole wheat bun, lettuce, tomato, and fries
状态模式
状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类
我们想让糖果机按照如下方式工作
系统从没有25分钱开始，刚开始实现如下：
public class GumballMachine {
//糖果售完状态
final static int SOLD_OUT = 0;
final static int NO_QUARTER = 1;
final static int HAS_QUARTER = 2;
final static int SOLD = 3;
int state = SOLD_OUT;
int count = 0;
public GumballMachine(int count) {
this.count = count;
if (count > 0) {
state = NO_QUARTER;
}
}
public void insertQuarter() {
if (state == HAS_QUARTER) {
System.out.println("You can't insert another quarter");
} else if (state == NO_QUARTER) {
state = HAS_QUARTER;
System.out.println("You inserted a quarter");
} else if (state == SOLD_OUT) {
System.out.println("You can't insert a quarter, the machine is sold out");
} else if (state == SOLD) {
System.out.println("Please wait, we're already giving you a gumball");
}
}
public void ejectQuarter() {
if (state == HAS_QUARTER) {
System.out.println("Quarter returned");
state = NO_QUARTER;
} else if (state == NO_QUARTER) {
System.out.println("You haven't inserted a quarter");
} else if (state == SOLD) {
System.out.println("Sorry, you already turned the crank");
} else if (state == SOLD_OUT) {
System.out.println("You can't eject, you haven't inserted a quarter yet");
}
}
public void turnCrank() {
if (state == SOLD) {
System.out.println("Turning twice doesn't get you another gumball!");
} else if (state == NO_QUARTER) {
System.out.println("You turned but there's no quarter");
} else if (state == SOLD_OUT) {
System.out.println("You turned, but there are no gumballs");
} else if (state == HAS_QUARTER) {
System.out.println("You turned...");
state = SOLD;
dispense();
}
}
public void dispense() {
if (state == SOLD) {
System.out.println("A gumball comes rolling out the slot");
count = count - 1;
if (count == 0) {
System.out.println("Oops, out of gumballs!");
state = SOLD_OUT;
} else {
state = NO_QUARTER;
}
} else if (state == NO_QUARTER) {
System.out.println("You need to pay first");
} else if (state == SOLD_OUT) {
System.out.println("No gumball dispensed");
} else if (state == HAS_QUARTER) {
System.out.println("No gumball dispensed");
}
}
public void refill(int numGumBalls) {
this.count = numGumBalls;
state = NO_QUARTER;
}
public String toString() {
StringBuffer result = new StringBuffer();
result.append("Inventory: " + count + " gumball");
if (count != 1) {
result.append("s");
}
result.append("\nMachine is ");
if (state == SOLD_OUT) {
result.append("sold out");
} else if (state == NO_QUARTER) {
result.append("waiting for quarter");
} else if (state == HAS_QUARTER) {
result.append("waiting for turn of crank");
} else if (state == SOLD) {
result.append("delivering a gumball");
}
result.append("\n");
return测试类
public class GumballMachineTestDrive {
public static void main(String[] args) {
GumballMachine gumballMachine = new GumballMachine(5);
//Inventory: 5 gumballs
//Machine is waiting for quarter
System.out.println(gumballMachine);
//You inserted a quarter
gumballMachine.insertQuarter();
//You can't insert another quarter
gumballMachine.insertQuarter();
//You turned...
//A gumball comes rolling out the slot
gumballMachine.turnCrank();
//Inventory: 4 gumballs
//Machine is waiting for quarter
System.out.println(gumballMachine);
}
}需求发生变更，当曲柄被转动时，有10%的几率掉下来的是两颗糖果，多送一个，我们可以把状态定义成单独的类，并且实现共同的接口
实现如下
public interface State {
/*
* 定义状态类的接口
*/
//投币
public void insertQuarter();
//退币
public void ejectQuarter();
//转动曲柄
public void turnCrank();
//发放糖果
public void dispense();
}public class HasQuarterState implements State
Random randomWinner = new Random(System.currentTimeMillis());
GumballMachine gumballMachine;
public HasQuarterState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
public void insertQuarter() {
System.out.println("You can't insert another quarter");
}
public void ejectQuarter() {
System.out.println("Quarter returned");
gumballMachine.setState(gumballMachine.getNoQuarterState());
}
public void turnCrank() {
System.out.println("You turned...");
//返回[0,10)之间均匀分布的int值
int winner = randomWinner.nextInt(10);
//只有糖果机至少有2个糖果时，才能变为幸运客户
if ((winner == 0) && (gumballMachine.getCount() > 1)) {
gumballMachine.setState(gumballMachine.getWinnerState());
} else {
gumballMachine.setState(gumballMachine.getSoldState());
}
}
public void dispense() {
System.out.println("No gumball dispensed");
}
public String toString() {
return "waiting for turn of crank";
}
}
public class WinnerState implements State
GumballMachine gumballMachine;
public WinnerState(GumballMachine gumballMachine) {
this.gumballMachine = gumballMachine;
}
public void insertQuarter() {
System.out.println("Please wait, we're already giving you a Gumball");
}
public void ejectQuarter() {
System.out.println("Please wait, we're already giving you a Gumball");
}
public void turnCrank() {
System.out.println("Turning again doesn't get you another gumball!");
}
public void dispense() {
//这个是书上的代码，不修改了，感觉可以直接出两个糖果，没必要判断为零的情况，因为只有糖果机中的糖果数大于1时
//状态才有可能变为WinnerSate
System.out.println("YOU'RE A WINNER! You get two gumballs for your quarter");
gumballMachine.releaseBall();
if (gumballMachine.getCount() == 0) {
gumballMachine.setState(gumballMachine.getSoldOutState());
} else {
gumballMachine.releaseBall();
if (gumballMachine.getCount() > 0) {
gumballMachine.setState(gumballMachine.getNoQuarterState());
} else {
System.out.println("Oops, out of gumballs!");
gumballMachine.setState(gumballMachine.getSoldOutState());
}
}
}
public String toString() {
return "despensing two gumballs for your quarter, because YOU'RE A WINNER!";
}
}
机器类的代码更改为如下
public class GumballMachine {
State soldOutState;
State noQuarterState;
State hasQuarterState;
State soldState;
State winnerState;
State state = soldOutState;
int count = 0;
public GumballMachine(int numberGumballs) {
soldOutState = new SoldOutState(this);
noQuarterState = new NoQuarterState(this);
hasQuarterState = new HasQuarterState(this);
soldState = new SoldState(this);
winnerState = new WinnerState(this);
this.count = numberGumballs;
if (numberGumballs > 0) {
state = noQuarterState;
}
}
public void insertQuarter() {
state.insertQuarter();
}
public void ejectQuarter() {
state.ejectQuarter();
}
public void turnCrank() {
state.turnCrank();
state.dispense();
}
void setState(State state) {
this.state = state;
}
void releaseBall() {
System.out.println("A gumball comes rolling out the slot...");
if (count != 0) {
count = count - 1;
}
}
int getCount() {
return count;
}
void refill(int count) {
this.count = count;
state = noQuarterState;
}
public State getState() {
return state;
}
public State getSoldOutState() {
return soldOutState;
}
public State getNoQuarterState() {
return noQuarterState;
}
public State getHasQuarterState() {
return hasQuarterState;
}
public State getSoldState() {
return soldState;
}
public State getWinnerState() {
return winnerState;
}
public String toString() {
StringBuffer result = new StringBuffer();
result.append("\nInventory: " + count + " gumball");
if (count != 1) {
result.append("s");
}
result.append("\n");
result.append("Machine is " + state + "\n");
return测试类和上面类似，状态模式的类图
责任链模式
AbstractLogger.java
public abstract class AbstractLogger {
public static int INFO = 1;
public static int DEBUG = 2;
public static int ERROR = 3;
protected int level;
protected AbstractLogger nextLogger;
public void setNextLogger(AbstractLogger nextLogger) {
this.nextLogger = nextLogger;
}
public void logMessage(int level, String message) {
if (this.level <= level) {
write(message);
}
if (nextLogger != null) {
nextLogger.logMessage(level, message);
}
}
abstract protected void writeInfoLogger.java
public class InfoLogger extends AbstractLogger
public InfoLogger(int level) {
this.level = level;
}
protected void write(String message) {
System.out.println("Ingo:Logger"
DebugLogger.java
public class DebugLogger extends AbstractLogger
public DebugLogger(int level) {
this.level = level;
}
protected void write(String message) {
System.out.println("Debug:Logger"
ErrorLogger.java
public class ErrorLogger extends AbstractLogger
public ErrorLogger(int level) {
this.level = level;
}
protected void write(String message) {
System.out.println("Error:Logger"
ChainPatternDemo.java
public class ChainPatternDemo {
private static AbstractLogger getChainOfLoggers() {
InfoLogger infoLogger = new InfoLogger(AbstractLogger.INFO);
DebugLogger debugLogger = new DebugLogger(AbstractLogger.DEBUG);
ErrorLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
errorLogger.setNextLogger(debugLogger);
debugLogger.setNextLogger(infoLogger);
return errorLogger;
}
public static void main(String[] args) {
AbstractLogger loggerChain = getChainOfLoggers();
//Ingo:Loggerinfo level
loggerChain.logMessage(AbstractLogger.INFO, "info level");
System.out.println();
//Debug:Loggerdebug level
//Ingo:Loggerdebug level
loggerChain.logMessage(AbstractLogger.DEBUG, "debug level");
System.out.println();
//Error:Loggererror level
//Debug:Loggererror level
//Ingo:Loggererror level
loggerChain.logMessage(AbstractLogger.ERROR, "error level");
}
}参考博客：
责任链模式
[2]http://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html
