3. 行為型模式：共包含十一種模式[1]
行為型模式各個關(guān)系
3.1 策略模式(strategy)
策略模式定義了一系列算法，并將每個算法封裝起來，使他們可以相互替換，且算法的變化不會影響到使用算法的客戶。需要設(shè)計一個接口，為一系列實現(xiàn)類提供統(tǒng)一的方法，多個實現(xiàn)類實現(xiàn)該接口，設(shè)計一個抽象類（可有可無，屬于輔助類），提供輔助函數(shù)
/**
* 策略模式
* ICalculator提供同意的方法，
AbstractCalculator是輔助類，
提供輔助方法，接下來，依次實現(xiàn)下每個類：
* @author Administrator
*
*/
public class StrategyTest {
public static void main(String[] args) {
String exp = "2+8";
ICalculator cal = new Plus();
int result = cal.calculate(exp);
System.out.println(result);
}
}
interface ICalculator{
public int calculate(String exp);
}
/**
* 輔助類
* @author Administrator
*
*/
abstract class AbstractCalculator{
public int[] split(String exp,String opt){
String array[]=exp.split(opt);
int arrayInt[]=new int[2];
arrayInt[0]=Integer.parseInt(array[0]);
arrayInt[1]=Integer.parseInt(array[1]);
return arrayInt;
}
}
class Plus extends AbstractCalculator implements ICalculator{
@Override
public int calculate(String exp) {
int arrayInt[]=split(exp, "\\+");
return arrayInt[0]+arrayInt[1];
}
}
class Minus extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp,"-");
return arrayInt[0]-arrayInt[1];
}
}
class Multiply extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp,"\\*");
return arrayInt[0]*arrayInt[1];
}
}
3.2 模板方法模式(Template Method)
一個抽象類中，有一個主方法，再定義1...n個方法，可以是抽象的，也可以是實際的方法，定義一個類，繼承該抽象類，重寫抽象方法，通過調(diào)用抽象類，實現(xiàn)對子類的調(diào)用
public abstract class AbstractCalculator {
/*主方法，實現(xiàn)對本類其它方法的調(diào)用*/
public final int calculate(String exp,String opt){
int array[] = split(exp,opt);
return calculate(array[0],array[1]);
}
/*被子類重寫的方法*/
abstract public int calculate(int num1,int num2);
public int[] split(String exp,String opt){
String array[] = exp.split(opt);
int arrayInt[] = new int[2];
arrayInt[0] = Integer.parseInt(array[0]);
arrayInt[1] = Integer.parseInt(array[1]);
return arrayInt;
}
}
public class Plus extends AbstractCalculator {
@Override
public int calculate(int num1,int num2) {
return num1 + num2;
}
}
public class StrategyTest {
public static void main(String[] args) {
String exp = "8+8";
AbstractCalculator cal = new Plus();
int result = cal.calculate(exp, "\\+");
System.out.println(result);
}
}
3.3 觀察者模式(Observer)
當(dāng)一個對象變化時，其它依賴該對象的對象都會收到通知，并且隨著變化！對象之間是一種一對多的關(guān)系。
例：
MySubject類就是我們的主對象，Observer1和Observer2是依賴于MySubject的對象，當(dāng)MySubject變化時，Observer1和Observer2必然變化。AbstractSubject類中定義著需要監(jiān)控的對象列表，可以對其進行修改：增加或刪除被監(jiān)控對象，且當(dāng)MySubject變化時，負責(zé)通知在列表內(nèi)存在的對象
public interface Observer {
public void update();
}
public class Observer1 implements Observer {
@Override
public void update() {
System.out.println("observer1 has received!");
}
}
public class Observer2 implements Observer {
@Override
public void update() {
System.out.println("observer2 has received!");
}
}
public interface Subject {
/*增加觀察者*/
public void add(Observer observer);
/*刪除觀察者*/
public void del(Observer observer);
/*通知所有的觀察者*/
public void notifyObservers();
/*自身的操作*/
public void operation();
}
public abstract class AbstractSubject implements Subject {
private Vector<Observer> vector = new Vector<Observer>();
@Override
public void add(Observer observer) {
vector.add(observer);
}
@Override
public void del(Observer observer) {
vector.remove(observer);
}
@Override
public void notifyObservers() {
Enumeration<Observer> enumo = vector.elements();
while(enumo.hasMoreElements()){
enumo.nextElement().update();
}
}
}
public class MySubject extends AbstractSubject {
@Override
public void operation() {
System.out.println("update self!");
notifyObservers();
}
}
public class ObserverTest {
public static void main(String[] args) {
Subject sub = new MySubject();
sub.add(new Observer1());
sub.add(new Observer2());
sub.operation();
}
}
輸出：
update self!
observer1 has received!
observer2 has received!
3.4 責(zé)任鏈模式
有多個對象，每個對象持有對下一個對象的引用，這樣就會形成一條鏈，請求在這條鏈上傳遞，直到某一對象決定處理該請求。但是發(fā)出者并不清楚到底最終那個對象會處理該請求，所以，責(zé)任鏈模式可以實現(xiàn)，在隱瞞客戶端的情況下，對系統(tǒng)進行動態(tài)的調(diào)整。
public class ChainofresponsibilityTest {
public static void main(String[] args) {
ChainofresponsibilityTest c=new ChainofresponsibilityTest();
MyHandler h1=c.new MyHandler("h1");
MyHandler h2=c.new MyHandler("h2");
MyHandler h3=c.new MyHandler("h3");
h1.setHandler(h2);
h2.setHandler(h3);
h2.operator();
}
interface Handler{
public void operator();
}
abstract class AbstractHandler{
private Handler handler;
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
}
class MyHandler extends AbstractHandler implements Handler{
private String name;
public MyHandler(String name) {
this.name=name;
}
@Override
public void operator() {
System.out.println(name+" ===deal");
if (getHandler()!=null) {
getHandler().operator();
}
}
}
}
3.5 命令模式
司令員下令讓士兵去干件事情，從整個事情的角度來考慮，司令員的作用是，發(fā)出口令，口令經(jīng)過傳遞，傳到了士兵耳朵里，士兵去執(zhí)行。這個過程好在，三者相互解耦，任何一方都不用去依賴其他人，只需要做好自己的事兒就行，司令員要的是結(jié)果，不會去關(guān)注到底士兵是怎么實現(xiàn)的。
例：Invoker是調(diào)用者（司令員），Receiver是被調(diào)用者（士兵），MyCommand是命令，實現(xiàn)了Command接口，持有接收對象，看實現(xiàn)代碼：
public class CommandTest {
public static void main(String[] args) {
CommandTest ct=new CommandTest();
Receiver receiver=ct.new Receiver();
Command c=ct.new MyCommand(receiver);
Invoker invoker=ct.new Invoker(c);
invoker.action();
}
interface Command{
public void exe();
}
class MyCommand implements Command{
private Receiver receiver;
public MyCommand(Receiver receiver) {
super();
this.receiver = receiver;
}
@Override
public void exe() {
receiver.action();
}
}
class Receiver{
public void action(){
System.out.println("reveiver is action");
}
}
class Invoker{
private Command command;
public Invoker(Command command) {
super();
this.command = command;
}
public void action(){
command.exe();
}
}
}
-
策略模式、模板方法模式、觀察者模式、迭代子模式、責(zé)任鏈模式、命令模式、備忘錄模式、狀態(tài)模式、訪問者模式、中介者模式、解釋器模式。 ?
