1、命令模式
是一种数据驱动的设计模式,属于行为型模式。请求以命令的形式包裹在对象中,并传给调用对象。调用对象寻找可以处理该明林的适合的对象,并把该命令传给相应的对象,该对象执行命令。
创建一个命令接口
public interface Order { void execute(); }
创建一个请求类
public class Stock { private String name="ABC"; private int quantity=10; public void buy(){ System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] bought"); } public void sell(){ System.out.println("Stock [ Name: "+name+", Quantity: " + quantity +" ] sold"); } }
创建接口的实现实体类
public class BuyStock implements Order { private Stock stock; public BuyStock(Stock stock) { this.stock = stock; } @Override public void execute() { stock.buy(); } }
public class SellStock implements Order { private Stock stock; public SellStock(Stock stock) { this.stock = stock; } @Override public void execute() { stock.sell(); } }
创建命令调用类
public class Broker { private List<Order> orderList = new ArrayList<Order>(); public void takeOrder(Order order){ orderList.add(order); } public void placeOrder(){ for (Order order : orderList) { order.execute(); } orderList.clear(); } }
使用命令调用类来接受并执行命令
public class Main { public static void main(String[] args) { Stock stock = new Stock(); BuyStock buyStock = new BuyStock(stock); SellStock sellStock = new SellStock(stock); Broker broker = new Broker(); broker.takeOrder(buyStock); broker.takeOrder(sellStock); broker.placeOrder(); } }
2、中介者模式
用来降低多个类和对象之间的通信复杂性,处理多个类之间的通信,支持松耦合。
创建中介类
public class ChatRoom { public static void showMessage(User user,String message) { System.out.println(new Date().toString()+" ["+user.getName()+"] : "+message); } }
创建实体类
public class User { private String name; public User(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void showMessage(String message){ ChatRoom.showMessage(this,message); } }
使用User对象来显示他们之间的通信
public class Main { public static void main(String[] args) { User rober = new User("Rober"); User john = new User("john"); rober.showMessage("Hi,john"); john.showMessage("Hello rober"); } }
3、观察者模式
当对象间存在一对多关系时,使用观察者模式,当一个对象被改变时,所有依赖于他的对象都得到通知并被自动更新,该种模式属于行为模式。
创建Subject类
public class Subject { private List<Observer> observerList = new ArrayList<Observer>(); private int state; public int getState() { return state; } public void setState(int state) { this.state = state; notifyAllObservers(); } public void notifyAllObservers(){ for (Observer ob:observerList) { ob.update(); } } public void attach(Observer observer){ observerList.add(observer); } }
创建observer类
public abstract class Observer { private Subject subject; public abstract void update(); }
创建实体观察者类
public class BinaryObserver extends Observer{ private Subject subject; public BinaryObserver(Subject subject) { this.subject = subject; this.subject.attach(this); } @Override public void update() { System.out.println("Binary String: "+Integer.toBinaryString(subject.getState())); } }
public class OctalObserver extends Observer{ private Subject subject; public OctalObserver(Subject subject) { this.subject = subject; this.subject.attach(this); } @Override public void update() { System.out.println("Octal String: "+Integer.toOctalString(subject.getState())); } }
使用实体观察者对象
public class Main { public static void main(String[] args) { Subject subject = new Subject(); new OctalObserver(subject); new BinaryObserver(subject); System.out.println("First state change: 15"); subject.setState(15); System.out.println("Second state change: 10"); subject.setState(10); } }
4、状态模式
在状态模式中,类的行为是基于它的状态改变的,允许对象在内部状态发生改变时改变他的行为。
创建接口及其实现类
public interface State { public void doAction(Context context); }
public class StartState implements State{ @Override public void doAction(Context context) { System.out.println("Player is in start state"); context.setState(this); } @Override public String toString() { return "Start State"; } }
public class StopState implements State{ @Override public void doAction(Context context) { System.out.println("Player is in stop state."); context.setState(this); } @Override public String toString() { return "Stop State"; } }
创建context类
public class Context { private State state; public Context() { state = null; } public State getState() { return state; } public void setState(State state) { this.state = state; } }
使用context类查看当状态state改变时的行为变化
public class Main { public static void main(String[] args) { Context context = new Context(); State startState = new StartState(); startState.doAction(context); System.out.println(context.getState().toString()); State stopState = new StopState(); stopState.doAction(context); System.out.println(context.getState().toString()); } }
5、策略模式
一个类的行为或算法可以在运行时被更改。这种类型的设计模式属于行为模式。
创建一个接口及其实现类
public interface Strategy { public int doOperation(int num1,int num2); }
public class OperationAdd implements Strategy{ @Override public int doOperation(int num1, int num2) { return num1+num2; } }
public class OperationSubstract implements Strategy { @Override public int doOperation(int num1, int num2) { return num1-num2; } }
public class OperationMultiply implements Strategy { @Override public int doOperation(int num1, int num2) { return num1*num2; } }
创建context对象
public class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public int executeStrategy(int num1, int num2){ return strategy.doOperation(num1,num2); } }
使用context来查看当它改变策略strategy时的行为变化
public class Main { public static void main(String[] args) { Context context = new Context(new OperationAdd()); System.out.println("10+5="+context.executeStrategy(3,5)); context = new Context(new OperationSubstract()); System.out.println("5-19="+context.executeStrategy(5,19)); context = new Context(new OperationMultiply()); System.out.println("4*4="+context.executeStrategy(4,4)); } }