设计模式示例

黑备忘录

• 备忘抽象

public interface Memento {

}

• 需备忘类

public class GameRole {

	private int vit; //生命力
	private int atk; //攻击力
	private int def; //防御力

	//初始化状态
	public void initState() {
		this.vit = 100;
		this.atk = 100;
		this.def = 100;
	}

	//战斗
	public void fight() {
		this.vit = 0;
		this.atk = 0;
		this.def = 0;
	}

	//保存角色状态
	public Memento saveState() {
		return new RoleStateMemento(vit, atk, def);
	}

	//回复角色状态
	public void recoverState(Memento memento) {
		RoleStateMemento roleStateMemento = (RoleStateMemento) memento;
		this.vit = roleStateMemento.getVit();
		this.atk = roleStateMemento.getAtk();
		this.def = roleStateMemento.getDef();
	}

	public void stateDisplay() {
		System.out.println("角色生命力：" + vit);
		System.out.println("角色攻击力：" + atk);
		System.out.println("角色防御力：" + def);
	}

	public int getVit() {
		return vit;
	}

	public void setVit(int vit) {
		this.vit = vit;
	}

	public int getAtk() {
		return atk;
	}

	public void setAtk(int atk) {
		this.atk = atk;
	}

	public int getDef() {
		return def;
	}

	public void setDef(int def) {
		this.def = def;
	}

	private class RoleStateMemento implements Memento {

		private int vit;
		private int atk;
		private int def;

		public RoleStateMemento(int vit, int atk, int def) {
			this.vit = vit;
			this.atk = atk;
			this.def = def;
		}

		public int getVit() {
			return vit;
		}

		public void setVit(int vit) {
			this.vit = vit;
		}

		public int getAtk() {
			return atk;
		}

		public void setAtk(int atk) {
			this.atk = atk;
		}

		public int getDef() {
			return def;
		}

		public void setDef(int def) {
			this.def = def;
		}
	}
}

• 角色状态管理者类：提供备忘录的存取

//角色状态管理者类
public class RoleStateCaretaker {

	private Memento memento;

	public Memento getMemento() {
		return memento;
	}

	public void setMemento(Memento memento) {
		this.memento = memento;
	}
}

• 测试

public class Client {

	public static void main(String[] args) {
		System.out.println("------------大战Boss前------------");
		//大战Boss前
		GameRole gameRole = new GameRole();
		gameRole.initState();
		gameRole.stateDisplay();
		//保存进度
		RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
		roleStateCaretaker.setMemento(gameRole.saveState());
		System.out.println("------------大战Boss后------------");
		//大战Boss时，损耗严重
		gameRole.fight();
		gameRole.stateDisplay();
		System.out.println("------------恢复之前状态------------");
		//恢复之前状态
		gameRole.recoverState(roleStateCaretaker.getMemento());
		gameRole.stateDisplay();
	}
}

白备忘录

• 实体备忘录类

public class RoleStateMemento {

	private int vit;
	private int atk;
	private int def;

	public RoleStateMemento(int vit, int atk, int def) {
		this.vit = vit;
		this.atk = atk;
		this.def = def;
	}

	public int getVit() {
		return vit;
	}

	public void setVit(int vit) {
		this.vit = vit;
	}

	public int getAtk() {
		return atk;
	}

	public void setAtk(int atk) {
		this.atk = atk;
	}

	public int getDef() {
		return def;
	}

	public void setDef(int def) {
		this.def = def;
	}
}

• 需要等待备忘的类

//游戏角色类
public class GameRole {

	private int vit; //生命力
	private int atk; //攻击力
	private int def; //防御力

	//初始化状态
	public void initState() {
		this.vit = 100;
		this.atk = 100;
		this.def = 100;
	}

	//战斗
	public void fight() {
		this.vit = 0;
		this.atk = 0;
		this.def = 0;
	}

	//保存角色状态
	public RoleStateMemento saveState() {
		return new RoleStateMemento(vit, atk, def);
	}

	//回复角色状态
	public void recoverState(RoleStateMemento roleStateMemento) {
		this.vit = roleStateMemento.getVit();
		this.atk = roleStateMemento.getAtk();
		this.def = roleStateMemento.getDef();
	}

	public void stateDisplay() {
		System.out.println("角色生命力：" + vit);
		System.out.println("角色攻击力：" + atk);
		System.out.println("角色防御力：" + def);
	}

	public int getVit() {
		return vit;
	}

	public void setVit(int vit) {
		this.vit = vit;
	}

	public int getAtk() {
		return atk;
	}

	public void setAtk(int atk) {
		this.atk = atk;
	}

	public int getDef() {
		return def;
	}

	public void setDef(int def) {
		this.def = def;
	}
}

• 角色状态管理者类

//角色状态管理者类
public class RoleStateCaretaker {

	//(备忘录类)
	private RoleStateMemento roleStateMemento;

	public RoleStateMemento getRoleStateMemento() {
		return roleStateMemento;
	}

	public void setRoleStateMemento(RoleStateMemento roleStateMemento) {
		this.roleStateMemento = roleStateMemento;
	}
}

• 测试

public class Client {

	public static void main(String[] args) {
		System.out.println("------------大战Boss前------------");
		//大战Boss前
		GameRole gameRole = new GameRole();
		gameRole.initState();
		gameRole.stateDisplay();
		//保存进度
		RoleStateCaretaker roleStateCaretaker = new RoleStateCaretaker();
		roleStateCaretaker.setRoleStateMemento(gameRole.saveState());
		System.out.println("------------大战Boss后------------");
		//大战Boss时，损耗严重
		gameRole.fight();
		gameRole.stateDisplay();
		System.out.println("------------恢复之前状态------------");
		//恢复之前状态
		gameRole.recoverState(roleStateCaretaker.getRoleStateMemento());
		gameRole.stateDisplay();
	}
}

访问者

• 被访问

public interface Animal {

	//动物被人访问 param：访问者
	void accept(Person person);
}

• 访问实现

public class Cat implements Animal {

	@Override
	public void accept(Person person) {
		person.feed(this);
		System.out.println("好好吃，喵喵喵！！！");
	}
}

public class Dog implements Animal {

	@Override
	public void accept(Person person) {
		person.feed(this);
		System.out.println("好好吃，汪汪汪！！！");
	}
}

• 访问主体

public interface Person {
	//不同的主体对被访问者产生不同的行为
	void feed(Cat cat);
	void feed(Dog dog);
}

• 访问实现

public class Owner implements Person {
	@Override
	public void feed(Cat cat) {
		System.out.println("主人喂食猫");
	}
	@Override
	public void feed(Dog dog) {
		System.out.println("主人喂食狗");
	}
}

public class Someone implements Person {

	@Override
	public void feed(Cat cat) {
		System.out.println("其他人喂食猫");
	}

	@Override
	public void feed(Dog dog) {
		System.out.println("其他人喂食狗");
	}
}

• 访问关系构建

import java.util.ArrayList;
import java.util.List;

public class Home {

	private List<Animal> nodeList = new ArrayList<Animal>();

	//由访问者进行访问
	public void action(Person person) {
		for (Animal node : nodeList) {
			node.accept(person);
		}
	}

	//添加操作：被访问动作
	public void add(Animal animal) {
		nodeList.add(animal);
	}
}

• 测试

public class Client {

	public static void main(String[] args) {
		Home home = new Home();
		home.add(new Dog());
		home.add(new Cat());

		Owner owner = new Owner();
		home.action(owner);
		System.out.println("------------更换访问者------------");
		Someone someone = new Someone();
		home.action(someone);
	}
}

• 测试结果

主人喂食狗
好好吃，汪汪汪！！！
主人喂食猫
好好吃，喵喵喵！！！
------------更换访问者------------
其他人喂食狗
好好吃，汪汪汪！！！
其他人喂食猫
好好吃，喵喵喵！！！

中介

• 抽象中介帮助类

//抽象中介帮助类
public abstract class Person {

	protected String name;
	protected Mediator mediator;

	public Person(String name, Mediator mediator) {
		this.name = name;
		this.mediator = mediator;
	}
}

• 中介帮助类实现

//具体同事类 房屋拥有者
public class HouseOwner extends Person {

	public HouseOwner(String name, Mediator mediator) {
		super(name, mediator);
	}

	//与中介者联系
	public void constact(String message) {
		mediator.constact(message, this);
	}

	//获取信息
	public void getMessage(String message) {
		System.out.println("房主" + name + "获取到的信息：" + message);
	}
}

//具体同事类 承租人
public class Tenant extends Person {

	public Tenant(String name, Mediator mediator) {
		super(name, mediator);
	}

	//与中介者联系
	public void constact(String message) {
		mediator.constact(message, this);
	}

	//获取信息
	public void getMessage(String message) {
		System.out.println("租房者" + name + "获取到的信息：" + message);
	}
}

• 中介抽象

//抽象中介者
public abstract class Mediator {

	//申明一个联络方法

	/**
	 *
	 * @param message 给中介的信息
	 * @param person 和中介打交道的人
	 */
	public abstract void constact(String message, Person person);
}

• 中介实现

//中介机构
public class MediatorStructure extends Mediator {

	//首先中介结构必须知道所有房主和租房者的信息
	private HouseOwner houseOwner;
	private Tenant tenant;

	public HouseOwner getHouseOwner() {
		return houseOwner;
	}

	public void setHouseOwner(HouseOwner houseOwner) {
		this.houseOwner = houseOwner;
	}

	public Tenant getTenant() {
		return tenant;
	}

	public void setTenant(Tenant tenant) {
		this.tenant = tenant;
	}

	public void constact(String message, Person person) {
		if (person == houseOwner) { //如果是房主，则租房者获得信息
			tenant.getMessage(message);
		} else { //反正则是房主获得信息
			houseOwner.getMessage(message);
		}
	}
}

• 测试

//测试类
public class Client {

	public static void main(String[] args) {
		//一个房主、一个租房者、一个中介机构
		MediatorStructure mediator = new MediatorStructure();
		//房主和租房者只需要知道中介机构即可
		HouseOwner houseOwner = new HouseOwner("张三", mediator);
		Tenant tenant = new Tenant("李四", mediator);
		//中介结构要知道房主和租房者
		mediator.setHouseOwner(houseOwner);
		mediator.setTenant(tenant);

		tenant.constact("需要租三室的房子");
		houseOwner.constact("我这有三室的房子，你需要租吗？");
	}
}

• 测试结果

房主张三获取到的信息：需要租三室的房子
租房者李四获取到的信息：我这有三室的房子，你需要租吗？

观察者模式

• 观察方抽象

public interface Observer {
	void update(String message);
}

• 观察方抽象实现

public class WeixinUser implements Observer {
	// 微信用户名
	private String name;
	public WeixinUser(String name) {
		this.name = name;
	}
	@Override
	public void update(String message) {
		System.out.println(name + "-" + message);
	}
}

• 观察框架抽象

public interface Subject {
	//增加订阅者
	public void attach(Observer observer);
	//删除订阅者
	public void detach(Observer observer);
	//通知订阅者更新消息
	public void notify(String message);
}

• 观察框架抽象实现

import java.util.ArrayList;
import java.util.List;

public class SubscriptionSubject implements Subject {

	//储存订阅公众号的微信用户
	private List<Observer> weixinUserlist = new ArrayList<Observer>();

	@Override
	public void attach(Observer observer) {
		weixinUserlist.add(observer);
	}

	@Override
	public void detach(Observer observer) {
		weixinUserlist.remove(observer);
	}

	@Override
	public void notify(String message) {
		for (Observer observer : weixinUserlist) {
			observer.update(message);
		}
	}
}

• 测试

public class Client {
	public static void main(String[] args) {
		SubscriptionSubject mSubscriptionSubject=new SubscriptionSubject();
		//创建微信用户
		WeixinUser user1=new WeixinUser("孙悟空");
		WeixinUser user2=new WeixinUser("猪悟能");
		WeixinUser user3=new WeixinUser("沙悟净");
		//订阅公众号
		mSubscriptionSubject.attach(user1);
		mSubscriptionSubject.attach(user2);
		mSubscriptionSubject.attach(user3);
		//公众号更新发出消息给订阅的微信用户
		mSubscriptionSubject.notify("传智黑马的专栏更新了");
	}
}

• 测试结果

孙悟空-传智黑马的专栏更新了
猪悟能-传智黑马的专栏更新了
沙悟净-传智黑马的专栏更新了

迭代器

public class Student {

}

public interface StudentAggregate {

	//添加
	void addStudent(Student student);

	//移除
	void removeStudent(Student student);

	//获取迭代器
	StudentIterator getStudentIterator();
}

import java.util.ArrayList;
import java.util.List;

public class StudentAggregateImpl implements StudentAggregate {

	private List<Student> list = new ArrayList<Student>(); // 学生列表

	@Override
	public void addStudent(Student student) {
		this.list.add(student);
	}

	@Override
	public void removeStudent(Student student) {
		this.list.remove(student);
	}

	@Override
	public StudentIterator getStudentIterator() {
		return new StudentIteratorImpl(list);
	}
}

//迭代接口定义
public interface StudentIterator {

	boolean hasNext();

	Student next();
}

import java.util.List;

//迭代实现
public class StudentIteratorImpl implements StudentIterator {

	private List<Student> list;
	private int position = 0;//下一次读取位置

	public StudentIteratorImpl(List<Student> list) {
		this.list = list;
	}

	@Override
	public boolean hasNext() {
		return position < list.size();
	}

	@Override
	public Student next() {
		Student currentStudent = list.get(position);
		position++;
		return currentStudent;
	}
}

状态

• 状态抽象

//抽象状态类
public abstract class LiftState {

	//定义一个环境角色，也就是封装状态的变化引起的功能变化
	protected Context context;

	public void setContext(Context context) {
		this.context = context;
	}

	//电梯开门动作
	public abstract void open();

	//电梯关门动作
	public abstract void close();

	//电梯运行动作
	public abstract void run();

	//电梯停止动作
	public abstract void stop();
}

• 状态抽象实现

//开启状态
public class OpenningState extends LiftState {

	//开启当然可以关闭了，我就想测试一下电梯门开关功能
	@Override
	public void open() {
		System.out.println("电梯门开启...");
	}

	@Override
	public void close() {
		//状态修改
		super.context.setLiftState(Context.closeingState);
		//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
		super.context.getLiftState().close();
	}

	//电梯门不能开着就跑，这里什么也不做
	@Override
	public void run() {
		//do nothing
	}

	//开门状态已经是停止的了
	@Override
	public void stop() {
		//do nothing
	}
}

//关闭状态
public class ClosingState extends LiftState {

	@Override
	//电梯门关闭，这是关闭状态要实现的动作
	public void close() {
		System.out.println("电梯门关闭...");
	}

	//电梯门关了再打开，逗你玩呢，那这个允许呀
	@Override
	public void open() {
		super.context.setLiftState(Context.openningState);
		super.context.open();
	}

	//电梯门关了就跑，这是再正常不过了
	@Override
	public void run() {
		super.context.setLiftState(Context.runningState);
		super.context.run();
	}

	//电梯门关着，我就不按楼层
	@Override
	public void stop() {
		super.context.setLiftState(Context.stoppingState);
		super.context.stop();
	}
}

//运行状态
public class RunningState extends LiftState {

	//运行的时候开电梯门？你疯了！电梯不会给你开的
	@Override
	public void open() {
		//do nothing
	}

	//电梯门关闭？这是肯定了
	@Override
	public void close() {//虽然可以关门，但这个动作不归我执行
		//do nothing
	}

	//这是在运行状态下要实现的方法
	@Override
	public void run() {
		System.out.println("电梯正在运行...");

	}

	//这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
	@Override
	public void stop() {
		super.context.setLiftState(Context.stoppingState);
		super.context.stop();
	}
}

//停止状态
public class StoppingState extends LiftState {

	//停止状态，开门，那是要的！
	@Override
	public void open() {
		//状态修改
		super.context.setLiftState(Context.openningState);
		//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
		super.context.getLiftState().open();
	}

	@Override
	public void close() {//虽然可以关门，但这个动作不归我执行
		//状态修改
		super.context.setLiftState(Context.closeingState);
		//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
		super.context.getLiftState().close();
	}

	//停止状态再跑起来，正常的很
	@Override
	public void run() {
		//状态修改
		super.context.setLiftState(Context.runningState);
		//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
		super.context.getLiftState().run();
	}

	//停止状态是怎么发生的呢？当然是停止方法执行了
	@Override
	public void stop() {
		System.out.println("电梯停止了...");
	}
}

• 状态环境类(负责切换状态)

//环境角色
public class Context {

	//定义出所有的电梯状态
	//开门状态，这时候电梯只能关闭
	public final static OpenningState openningState = new OpenningState();

	//关闭状态，这时候电梯可以运行、停止和开门
	public final static ClosingState closeingState = new ClosingState();

	//运行状态，这时候电梯只能停止
	public final static RunningState runningState = new RunningState();//

	//停止状态，这时候电梯可以开门、运行
	public final static StoppingState stoppingState = new StoppingState();

	//定义一个当前电梯状态
	private LiftState liftState;

	public LiftState getLiftState() {
		return this.liftState;
	}

	//环境类，状态类相互持有
	public void setLiftState(LiftState liftState) {
		//当前环境改变
		this.liftState = liftState;
		//把当前的环境通知到各个实现类中
		this.liftState.setContext(this);
	}

	public void open() {
		this.liftState.open();
	}

	public void close() {
		this.liftState.close();
	}

	public void run() {
		this.liftState.run();
	}

	public void stop() {
		this.liftState.stop();
	}
}

• 测试

//测试类
public class Client {

	public static void main(String[] args) {
		Context context = new Context();
		context.setLiftState(new RunningState());
		context.open();
		context.close();
		context.run();
		context.stop();
	}
}

• 测试结果

运行的时候开电梯门？你疯了！电梯不会给你开的
虽然可以关门，但这个动作不归RunningState执行
电梯正在运行...
电梯停止了...

适配

//SD卡的接口
public interface SDCard {

	//读取SD卡方法
	String readSD();

	//写入SD卡功能
	void writeSD(String msg);
}

//SD卡实现类
public class SDCardImpl implements SDCard {

	public String readSD() {
		String msg = "sd card read a msg :hello word SD";
		return msg;
	}

	public void writeSD(String msg) {
		System.out.println("sd card write msg : " + msg);
	}
}

//电脑类
public class Computer {

	public String readSD(SDCard sdCard) {
		if (sdCard == null) {
			throw new NullPointerException("sd card null");
		}
		return sdCard.readSD();
	}
}

• 待适配抽象

//TF卡接口
public interface TFCard {

	//读取TF卡方法
	String readTF();

	//写入TF卡功能
	void writeTF(String msg);
}

//TF卡实现类
public class TFCardImpl implements TFCard {

	public String readTF() {
		String msg = "tf card read msg : hello word tf card";
		return msg;
	}

	public void writeTF(String msg) {
		System.out.println("tf card write a msg : " + msg);
	}
}

• 兼容

//定义适配器类（SD兼容TF）
public class SDAdapterTF extends TFCardImpl implements SDCard {

	public String readSD() {
		System.out.println("adapter read tf card ");
		return readTF();
	}

	public void writeSD(String msg) {
		System.out.println("adapter write tf card");
		writeTF(msg);
	}
}

• 测试

//测试类
public class Client {

	public static void main(String[] args) {
		Computer computer = new Computer();
		SDCard sdCard = new SDCardImpl();
		System.out.println(computer.readSD(sdCard));
		System.out.println("------------");
		SDAdapterTF adapter = new SDAdapterTF();
		System.out.println(computer.readSD(adapter));
	}
}

• 测试结果

sd card read a msg :hello word SD
------------
adapter read tf card 
tf card read msg : hello word tf card

装饰

//快餐接口
@Data
public abstract class FastFood {

	private float price;
	private String desc;

	public FastFood() {
	}

	public FastFood(float price, String desc) {
		this.price = price;
		this.desc = desc;
	}

	public abstract float cost(); //获取价格
}

//炒面
public class FriedNoodles extends FastFood {

	public FriedNoodles() {
		super(12, "炒面");
	}

	public float cost() {
		return getPrice();
	}
}

//炒饭
public class FriedRice extends FastFood {

	public FriedRice() {
		super(10, "炒饭");
	}

	public float cost() {
		return getPrice();
	}
}

//配料类：持有待装饰的抽象
public abstract class Garnish extends FastFood {

	private FastFood fastFood;

	/**
	 *
	 * @param fastFood
	 * @param price 配料价格
	 * @param desc 配料描述
	 */
	public Garnish(FastFood fastFood, float price, String desc) {
		super(price, desc);
		this.fastFood = fastFood;
	}

	public FastFood getFastFood() {
		return fastFood;
	}

	public void setFastFood(FastFood fastFood) {
		this.fastFood = fastFood;
	}
}

//培根配料
public class Bacon extends Garnish {

	/**
	 *
	 * @param fastFood 待装饰对象
	 */
	public Bacon(FastFood fastFood) {
		super(fastFood, 2, "培根");
	}

	@Override
	public float cost() {
		return getPrice() + getFastFood().getPrice();
	}

	@Override
	public String getDesc() {
		return super.getDesc() + getFastFood().getDesc();
	}
}

//鸡蛋配料
public class Egg extends Garnish {

	public Egg(FastFood fastFood) {
		super(fastFood, 1, "鸡蛋");
	}

	public float cost() {
		return getPrice() + getFastFood().getPrice();
	}

	@Override
	public String getDesc() {
		return super.getDesc() + getFastFood().getDesc();
	}
}

• 测试

//测试类
public class Client {

	public static void main(String[] args) {
		//点一份炒饭
		FastFood food = new FriedRice();
		//花费的价格
		System.out.println(food.getDesc() + " " + food.cost() + "元");
		System.out.println("========");
		//点一份加鸡蛋的炒饭
		FastFood food1 = new FriedRice();
		food1 = new Egg(food1);
		//花费的价格
		System.out.println(food1.getDesc() + " " + food1.cost() + "元");
		System.out.println("========");
		//点一份加培根的炒面
		FastFood food2 = new FriedNoodles();
		food2 = new Bacon(food2);
		//花费的价格
		System.out.println(food2.getDesc() + " " + food2.cost() + "元");
	}
}

• 测试结果

炒饭 10.0元
========
鸡蛋炒饭 11.0元
========
培根炒面 14.0元

组合

• 结构抽象

//菜单组件 不管是菜单还是菜单项，都应该继承该类
public abstract class MenuComponent {

	protected String name;
	protected int level;

	//添加菜单
	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() {
		return name;
	}

	public void print() {
		throw new UnsupportedOperationException();
	}
}

• 非叶子节点(包含对下级同类结构的增减)

public class Menu extends MenuComponent {

	private final List<MenuComponent> menuComponentList;

	public Menu(String name, int level) {
		this.level = level;
		this.name = name;
		menuComponentList = new ArrayList<MenuComponent>();
	}

	@Override
	public void add(MenuComponent menuComponent) {
		menuComponentList.add(menuComponent);
	}

	@Override
	public void remove(MenuComponent menuComponent) {
		menuComponentList.remove(menuComponent);
	}

	@Override
	public MenuComponent getChild(int i) {
		return menuComponentList.get(i);
	}

	@Override
	public void print() {
		for (int i = 1; i < level; i++) {
			System.out.print("--");
		}
		System.out.println(name);
		for (MenuComponent menuComponent : menuComponentList) {
			menuComponent.print();
		}
	}
}

• 叶子节点

public class MenuItem extends MenuComponent {

	public MenuItem(String name, int level) {
		this.name = name;
		this.level = level;
	}

	@Override
	public void print() {
		for (int i = 1; i < level; i++) {
			System.out.print("--");
		}
		System.out.println(name);
	}
}

• 测试

public class Client {

	public static void main(String[] args) {
		//顶级菜单
		MenuComponent topMenu = new Menu("顶级菜单", 1);

		//二级
		MenuComponent cd1 = new Menu("菜单1", 2);
		MenuComponent cd2 = new Menu("菜单2", 2);
		MenuComponent cd3 = new Menu("菜单3", 2);
		topMenu.add(cd1);
		topMenu.add(cd2);
		topMenu.add(cd3);

		//三级
		MenuComponent cd11 = new MenuItem("菜单11", 3);
		MenuComponent cd21 = new MenuItem("菜单21", 3);
		MenuComponent cd31 = new MenuItem("菜单31", 3);
		cd1.add(cd11);
		cd2.add(cd21);
		cd3.add(cd31);

		topMenu.print();
	}

}```
* 测试结果

```java
顶级菜单
--菜单1
----菜单11
--菜单2
----菜单21
--菜单3
----菜单31

责任链

• 待处理事件

//请假条
public class LeaveRequest {

	private final String name;//姓名
	private final int num;//请假天数
	private String content;//请假内容

	public LeaveRequest(String name, int num, String content) {
		this.name = name;
		this.num = num;
		this.content = content;
	}

	public String getName() {
		return name;
	}

	public int getNum() {
		return num;
	}

	public String getContent() {
		return content;

• 处理者抽象类

//处理者抽象类
public abstract class Handler {

	protected final static int NUM_ONE = 1;
	protected final static int NUM_THREE = 3;
	protected final static int NUM_SEVEN = 7;
	//该领导处理的请假天数区间
	private final int numStart;
	private int numEnd;
	//领导上面还有领导
	private Handler nextHandler;

	//设置请假天数范围 上不封顶
	public Handler(int numStart) {
		this.numStart = numStart;
	}

	//设置请假天数范围
	public Handler(int numStart, int numEnd) {
		this.numStart = numStart;
		this.numEnd = numEnd;
	}

	//设置上级领导
	public void setNextHandler(Handler nextHandler) {
		this.nextHandler = nextHandler;
	}

	//提交请假条
	public final void submit(LeaveRequest leave) {
		if (0 == this.numStart) {
			return;
		}
		//如果请假天数达到该领导者的处理要求
		if (leave.getNum() >= this.numStart) {
			this.handleLeave(leave);
			//如果还有上级 并且请假天数超过了当前领导的处理范围
			if (null != this.nextHandler && leave.getNum() > numEnd) {
				this.nextHandler.submit(leave);//继续提交
			} else {
				System.out.println("流程结束");
			}
		}
	}

	//各级领导处理请假条方法
	protected abstract void handleLeave(LeaveRequest leave);
}

• 处理具体实现

//小组长
public class GroupLeader extends Handler {

	public GroupLeader() {
		//小组长处理1-3天的请假
		super(Handler.NUM_ONE, Handler.NUM_THREE);
	}

	@Override
	protected void handleLeave(LeaveRequest leave) {
		System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
		System.out.println("小组长审批：同意。");
	}
}

//部门经理
public class Manager extends Handler {

	public Manager() {
		//部门经理处理3-7天的请假
		super(Handler.NUM_THREE, Handler.NUM_SEVEN);
	}

	@Override
	protected void handleLeave(LeaveRequest leave) {
		System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
		System.out.println("部门经理审批：同意。");
	}
}

//总经理
public class GeneralManager extends Handler {

	public GeneralManager() {
		//部门经理处理7天以上的请假
		super(Handler.NUM_SEVEN);
	}

	@Override
	protected void handleLeave(LeaveRequest leave) {
		System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
		System.out.println("总经理审批：同意。");
	}
}

• 测试

//测试类
public class Client {

	public static void main(String[] args) {
		//请假条来一张
		LeaveRequest leave = new LeaveRequest("小花", 100, "身体不适");
		//各位领导
		GroupLeader groupLeader = new GroupLeader();
		Manager manager = new Manager();
		GeneralManager generalManager = new GeneralManager();
		groupLeader.setNextHandler(manager);//小组长的领导是部门经理
		manager.setNextHandler(generalManager);//部门经理的领导是总经理
		//之所以在这里设置上级领导，是因为可以根据实际需求来更改设置，如果实战中上级领
		//导人都是固定的，则可以移到领导实现类中。
		//提交申请
		groupLeader.submit(leave);
	}
}

• 测试结果

小花请假100天,身体不适。
小组长审批：同意。
小花请假100天,身体不适。
部门经理审批：同意。
小花请假100天,身体不适。
总经理审批：同意。
流程结束