1.观察者模式
一句话：各大语言的监听模式算是观察者模式吧，注册监听事件属于“借钱要债的名单注册”，触发事件属于“还钱操作”。
public class ObserverPattern{ public static void main(String[] args){ debit zhangSan = new ZhangSan(); zhangSan.borrow(new Wangwu()); zhangSan.borrow(new ZhaoSI); //张三判断自己状态改变，自己有钱了， zhangSan.notifyCredits(); } } interface Debit{ void borrow(Credit credit); void notifyCredits(); } class ZhangSan implementd debit{ private List<Credit>allCredits = new ArrayList<>(); private Integer state = 0;//1表示有钱 public void borrow(Credit credit){ allCredits.add(credit); } public void notifyCredits(){ allCredits.forEach(credit -> credit.takeMoney()); } } } interface Credit{ void takMoney(); } class Wangwuimplementd Credit{ void takMoney(){ sout(还钱了) } } class ZhaoSi implementd Credit{ void takMoney(){ sout(还钱了) } }
Debit:主体对象，负责调用和通知
Credit：观察者
2.状态模式
/** * 抽象状态类 * @author gh * */public abstract class State { public abstract void Handle(Context context); } public class ConcreteStateA extends State{ @Override public void Handle(Context context) { context.setState(new ConcreteStateB()); //设置A的下一个状态是B } } class ConcreteStateB extends State{ @Override public void Handle(Context context) { context.setState(new ConcreteStateA()); //设置B的下一个状态是A } } /** * 定义当前的状态 * @author gh * */public class Context { State state; public Context(State state) { //定义Context的初始状态 super(); this.state = state; } public State getState() { return state; } public void setState(State state) { this.state = state; System.out.println("当前状态为"+state); } public void request(){ state.Handle(this); //对请求做处理并且指向下一个状态 }}
3. 策略模式
类图和状态一样，但是不同的是：
状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。
public interface QuackBehavior { 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 class Duck { private QuackBehavior quackBehavior; public void performQuack() { if (quackBehavior != null) { quackBehavior.quack(); } } public void setQuackBehavior(QuackBehavior quackBehavior) { this.quackBehavior = quackBehavior; }} public class Client { public static void main(String[] args) { Duck duck = new Duck(); duck.setQuackBehavior(new Squeak()); duck.performQuack(); duck.setQuackBehavior(new Quack()); duck.performQuack(); }} squeak! quack!
4. 责任链模式
5. 模板方法设计模式
6. 命令设计模式
命令模式是对命令的封装。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。
每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。MVC模式
1.接受者角色类 public class Receiver { /** * 真正执行命令相应的操作 */ public void action(){ System.out.println("执行操作"); } } 2. 抽象命令角色类 public interface Command { /** * 执行方法 */ void execute(); } 3. 具体命令角色类 public class ConcreteCommand implements Command { //持有相应的接收者对象 private Receiver receiver = null; /** * 构造方法 */ public ConcreteCommand(Receiver receiver){ this.receiver = receiver; } @Override public void execute() { //通常会转调接收者对象的相应方法，让接收者来真正执行功能 receiver.action(); } } 4. 请求者角色类 public class Invoker { /** * 持有命令对象 */ private Command command = null; /** * 构造方法 */ public Invoker(Command command){ this.command = command; } /** * 行动方法 */ public void action(){ command.execute(); } } 5. 客户端角色类 public class Client { public static void main(String[] args) { //创建接收者 Receiver receiver = new Receiver(); //创建命令对象，设定它的接收者 Command command = new ConcreteCommand(receiver); //创建请求者，把命令对象设置进去 Invoker invoker = new Invoker(command); //执行方法 invoker.action(); } }
7.备忘录模式
8.迭代器模式
9.中介者模式
10.访问者模式
符合开闭原则.
