六：命令模式
适用的情况：一个调用者，可以调用好多不同类型的物件的命令，那么把这么多的物件的定义成一个统一的接口，这个接口有一个统一的执行方法。
public interface Command {
public void execute();
}子类：
public class LightOnCommand implements Command {
Light light;
public LightOnCommand(Light light) {
this.light = light;
}
public void execute() {
light.on();
}
}
public class LightOffCommand implements Command {
Light light;
public LightOffCommand(Light light) {
this.light = light;
}
public void execute() {
light.off();
}
}
具体类：
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 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);
remote.buttonWasPressed();
}
}
关键是每个动作都是以个动作类。(*^.^*)
七。适配器模式：
当你的代码是旧的代码，而用户使用的是新的接口，你的代码提供的接口不符合用户的接口，可以使用适配器模式，
适配器模式有两种，
一种是对象适配器，一种是类适配器（通过多重继承可以是实现，但java不允许多重继承）。
对象适配器：
用户接口 -------------》接口
有一个 ^
|
适配器-----》有一个 你的接口
这样在适配器种的方法就可以用你的具体类来实现了。
类适配器就是 适配器既实现用户的接口，又实现你的接口。这样用户就可以使用了。
外观模式：
把很多类变量放到一个接口中，当使用一个方法时，会调用很多的类变量，这样 就把复杂的业务封装到一个系统中只提供给用户已个使用方法。
public class prarent{
var1;
var2;
var3;
public void method()
{
var1.domethod();
var2.domethod();
var3.domethod();
}
}这样把复杂的业务就封装到了方法中，外部的用户看不到。
和适配器模式不一样，适配器要实现别的接口，要有被实现接口的实例，而外观则只是把复杂的子系统封装在，一个接口中，一个方法调用 实现中会有子的来实现。
八. 模板方法--封装算法。
public class parent{
public final do()
{
do1();
do2();
do3();
do4();
if(getAddDo5())//钩子
{
do5();
}
}
public do1(){ println("in do 1");}
public do2(){ println("in do 2");}
public abstract do3();
public do4(){println("in do 4");}
public boolean getAddDo5()
{
return true;
}
}子类：
public child extends parent{
public void do3()
{
println("in do3 ");
}
public boolean getaddDo5()//覆盖父类的钩子方法
{
//根据获取用户输入来返回
true
false;
}
}Arrays的
public static void sort(Object[] a) {//模板方法，虽然不是很正统 但是排序也是由传入的数组的compareTo实现的
Object[] aux = (Object[])a.clone();
mergeSort(aux, a, 0, a.length, 0);
}
以及IFrame extends JFrame
{
中的paint()方法
}八。迭代器：
继承自一个iterator 接口，
女招待，有个菜单接口，可以传入不同菜单实现，每个菜单有一个创建迭代器的接口，可以创建迭代器，最后菜单传入的时候最好是以个集合，这样可以执行中传入菜单。
菜单接口< ------------ 女招待------------> interface Iterator
^
|
^ ^ |
| \ |
| \ |
| \ |
菜单1 \ |
菜单2 |
| |
|
————————> createIterator--------------- 不同的Iterator 实现
当菜单中子菜单又有子菜单的时候这个时候这个就不适合了，要用树的概念来完成这个。整体是一个组合，包含组件，组件又分组合和叶子，这时候组件接口中有他们的功用方法
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 new UnsupportedOperationException();
}
}
菜单为：
import java.util.Iterator;
import java.util.ArrayList;
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;
}
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 (iterator.hasNext()) {
MenuComponent menuComponent =
(MenuComponent)iterator.next();
menuComponent.print();
}
}
}叶子节点为：
import java.util.Iterator;
import java.util.ArrayList;
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;
}
public Iterator createIterator() {
return new NullIterator();
}
public void print() {
System.out.print(" " + getName());
if (isVegetarian()) {
System.out.print("(v)");
}
System.out.println(", " + getPrice());
System.out.println(" -- " + getDescription());
}
//vv MenuItemCompositeV2Main
}
这样就实现了，获得一个总的菜单组合可以直接调用print()方法打印出来它所有的子菜单。
如果要想获得外部迭代的功能，如侍者打印所有的素食菜单。主要是在组件上加上createIterator()方法。
九。状态模式：
一个物件有很多种状态，对于每种状态的不同操作，会有不同的反应。这样把状态设计成类，都继承自已个状态接口，若想在状态类中操作物体的方法，则可以把物体传入，在物体类中分别有不同的状态，还有一个当前状态，这样对物体的操作变成对当前状态的操作，又委托给状态类来操作。
主部件：
public class GumballMachine {
State soldOutState;
State noQuarterState;
State hasQuarterState;
State soldState;
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);
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 String toString() {
StringBuffer result = new StringBuffer();
result.append("\nMighty Gumball, Inc.");
result.append("\nJava-enabled Standing Gumball Model #2004");
result.append("\nInventory: " + count + " gumball");
if (count != 1) {
result.append("s");
}
result.append("\n");
result.append("Machine is " + state + "\n");
return result.toString();
}
}状态接口：
public interface State {
public void insertQuarter();
public void ejectQuarter();
public void turnCrank();
public void dispense();
}
其中的有币状态：
import java.util.Random;
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...");
int winner = randomWinner.nextInt(10);
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";
}
}winer状态以及普通的只出来一个状态：
public class SoldState implements State {
GumballMachine gumballMachine;
public SoldState(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("Sorry, you already turned the crank");
}
public void turnCrank() {
System.out.println("Turning twice doesn't get you another gumball!");
}
public void dispense() {
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 "dispensing a gumball";
}
}
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() {
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!";
}
}其中的winer状态是后面添加的这样比if--else的修改省事多了。
