目录
1.观察者模式
package designPattern;
import java.util.ArrayList;
import java.util.List;
/**
* 行为模式：观察者模式
* 使用两个进制观察者，观察一个十进制数的变化，对应输出该十进制对应的二进制和十六进制
*/
public class ObserverPattern {
public static void main(String[] args) {
ObservationTarget observationTarget = new ObservationTarget();
BinObserver binObserver = new BinObserver(observationTarget);
HexObserver hexObserver = new HexObserver(observationTarget);
observationTarget.setNumber(23);
observationTarget.setNumber(65);
}
}
/**
* 观察目标
*/
class ObservationTarget {
//观察数
private int number;
//观察次对象的观察者列表
private List<Observer> observerList = new ArrayList<>();
public void setNumber(int number) {
this.number = number;
//通知观察者
notifyAllObserver();
}
public int getNumber() {
return number;
}
public void addObserver(Observer observer) {
observerList.add(observer);
}
//更新后通知所有观察者
public void notifyAllObserver() {
for (Observer observer : observerList) {
observer.update();
}
}
}
/**
* 观察者抽象类
*/
abstract class Observer {
//要观察的目标
protected ObservationTarget observationTarget;
//更新观察结果
public abstract void update();
}
/**
* 创建不同进制的观察者
*/
class BinObserver extends Observer {
public BinObserver(ObservationTarget observationTarget) {
this.observationTarget = observationTarget;
this.observationTarget.addObserver(this);
}
@Override
public void update() {
System.out.println("bin: " + Integer.toBinaryString(observationTarget.getNumber()));
}
}
class HexObserver extends Observer {
public HexObserver(ObservationTarget observationTarget) {
this.observationTarget = observationTarget;
this.observationTarget.addObserver(this);
}
@Override
public void update() {
System.out.println("hex: " + Integer.toHexString(observationTarget.getNumber()));
}
}
2.责任链模式
package designPattern;
/**
* 行为型设计模式：责任链模式
* 假设在一个工厂内有三种产品（编号A，B，C）需要被加工，此时有三名工人（1，2，3）,其中一号工人只能加工A产品，二号为B，三号为C，
* 现给一号工人一大堆该三种产品（打乱），开始进行加工，如果此产品自己不可加工，则传到下一个工人，依次直至产品加工完
*/
public class ResponsibilityPattern {
public static void main(String[] args) {
Work1 work1 = new Work1();
Work2 work2 = new Work2();
Work3 work3 = new Work3();
work1.setNextWorker(work2);
work2.setNextWorker(work3);
//五个产品
String[] products = {"B", "C", "A", "C", "B"};
for (String p : products) work1.work(p);
}
}
abstract class Worker {
//责任链上的下一个工人
protected Worker nextWorker;
public void setNextWorker(Worker nextWorker) {
this.nextWorker = nextWorker;
}
//工人们开始工作
abstract public void work(String product);
}
//三种类型的工人
class Work1 extends Worker {
@Override
public void work(String product) {
if (product.equalsIgnoreCase("A")) System.out.println("工人1加工了一个产品A");
else if (nextWorker != null) nextWorker.work(product);
}
}
class Work2 extends Worker {
@Override
public void work(String product) {
if (product.equalsIgnoreCase("B")) System.out.println("工人2加工了一个产品B");
else if (nextWorker != null) nextWorker.work(product);
}
}
class Work3 extends Worker {
@Override
public void work(String product) {
if (product.equalsIgnoreCase("C")) System.out.println("工人3加工了一个产品C");
else if (nextWorker != null) nextWorker.work(product);
}
}
3.命令模式
package designPattern;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
/**
* 行为型设计模式：命令模式
* 将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化
* 就拿windows的命令窗口举例
*/
public class CommandPattern {
public static void main(String[] args) {
CMD cmd = new CMD();
CLSOrder clsOrder = new CLSOrder(cmd);
DIROrder dirOrder = new DIROrder(cmd);
CDOrder cdOrder = new CDOrder(cmd);
CommandStack commandStack = new CommandStack();
commandStack.addOrder(clsOrder);
commandStack.addOrder(dirOrder);
commandStack.addOrder(cdOrder);
commandStack.executeAllOrder();
}
}
/**
* cmd类
*/
class CMD {
//执行命令
public void execute(String command) {
if (command.equalsIgnoreCase("cls")) System.out.println("执行cls命令");
else if (command.equalsIgnoreCase("dir")) System.out.println("执行dir命令");
else if (command.equalsIgnoreCase("cd")) System.out.println("执行cd命令");
}
}
interface Order {
void executeCommand();
}
class CLSOrder implements Order {
private CMD cmd;
public CLSOrder(CMD cmd) {
this.cmd = cmd;
}
@Override
public void executeCommand() {
cmd.execute("cls");
}
}
class DIROrder implements Order {
private CMD cmd;
public DIROrder(CMD cmd) {
this.cmd = cmd;
}
@Override
public void executeCommand() {
cmd.execute("dir");
}
}
class CDOrder implements Order {
private CMD cmd;
public CDOrder(CMD cmd) {
this.cmd = cmd;
}
@Override
public void executeCommand() {
cmd.execute("cd");
}
}
/**
* 命令栈
*/
class CommandStack {
List<Order> orderList = new ArrayList<>();
public void addOrder(Order order) {
orderList.add(order);
}
public void executeAllOrder() {
for (Order order : orderList) order.executeCommand();
orderList.clear();
}
}
4.迭代器模式
Java集合框架中的迭代器Iterator就是 迭代器模式的一个很好例子，以下模仿演示
public class Main {
public static void main(String[] args) {
NameRepository nameRepository = new NameRepository();
Iterator iterator = nameRepository.getIterator();
while (iterator.hasNext()) System.out.println(iterator.next());
}
}
interface Iterator {
public boolean hasNext();
public Object next();
}
interface Container {
public Iterator getIterator();
}
class NameRepository implements Container {
public String names[] = {"Robert", "John", "Julie", "Lora"};
@Override
public Iterator getIterator() {
return new NameIterator();
}
private class NameIterator implements Iterator {
int index;
@Override
public boolean hasNext() {
if (index < names.length) {
return true;
}
return false;
}
@Override
public Object next() {
if (this.hasNext()) {
return names[index++];
}
return null;
}
}
}
