設計模式之行爲模式
設計模式之行爲模式
1、概述
1.1 簡介
java設計模式的分類中建立模式管理類在jvm中的生成和存在方式，結構模式能夠看做是對存在的功能類的加強和延伸，充分利用了面向對象的三大特性：封裝、繼承、多態。那麼個行爲模式則是對不一樣功能類相互引用，相互聯繫作了示範做用，能夠看做是結構模式的典型應用。java
2、實例
2.1 父類和子類
總結：
一、在抽象類中提供一個公共功能，在其它子類中實現相同方法名、不一樣做用的功能（方法重寫）。
二、策略模式是利用接口、模版模式利用了抽象類的抽象方法（和接口同樣）。
三、利用裝飾模式來構建功能模塊，查看框架源碼可，能夠發現不少功能模塊都是這麼寫的。
策略模式：
//功能
public interface ICalculator {
public int calculate(String exp);
}
//公共抽象類
public 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;
}
}
//子類實現
public class Minus extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp, "\\*");
return arrayInt[0] * arrayInt[1];
}
}
public class Multiply extends AbstractCalculator implements ICalculator {
@Override
public int calculate(String exp) {
int arrayInt[] = split(exp, "\\+");
return arrayInt[0] + arrayInt[1];
}
}
//使用
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);
}
//對同類問題的封裝，一個抽象類實現公共功能，在利用不一樣子類實現不一樣實現功能
}
模版模式：
//公共抽象類
public 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;
}
// 主要方法
public final int calculate(String exp, String opt) {
int array[] = split(exp, opt);
return calculate(exp, opt);
}
// 子類從新的方法
public abstract int calculator(int num1, int num2);
}
//子類
public class Minus extends AbstractCalculator {
@Override
public int calculator(int num1, int num2) {
// TODO Auto-generated method stub
return num1 * num2;
}
}
public class Multiply extends AbstractCalculator {
@Override
public int calculator(int num1, int num2) {
// TODO Auto-generated method stub
return num1 * num2;
}
}
//測試
public class StrategyTest {
public static void main(String[] args) {
String exp = "2+8";
AbstractCalculator avcal = new Plus();
int result = avcal.calculate(exp, "\\+");
System.out.println(result);
}
// 一個抽象類實現公共功能，利用抽象方法子類必須重寫，來實現接口功能，固然能夠不寫接口
}
2.2 多個類之間
總結：這4種模式是java面向對象思想的很經典使用，各大框架都很經常使用。
1.觀察者模式：利用一個觀察類，存放全部相同接口的子類，當一個類發生變化，進行輪訓改變全部的類
//觀察類接口
public interface Subject {
// 增長觀察者
public void add(Observer observer);
// 刪除觀察者
public void del(Observer observer);
// 通知所用的觀察者
public void notifyObserver();
// 自身的操做
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 notifyObserver() {
// 輪循
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!");
//這裏能夠添加咱們須要的改變觸發形式
notifyObserver();
}
}
//相同功能、固然也能夠叫作掛載點
public interface Observer {
public void update();
}
//具體的子類
public class Observer2 implements Observer {
@Override
public void update() {
System.out.println("observer2 has received");
}
}
public class Observer1 implements Observer {
@Override
public void update() {
System.out.println("observer1 has received");
}
}
//測試
public class ObserverTest {
// 觀察模式：經過一個觀察類實現來遍歷通知
public static void main(String[] args) {
Subject sub = new MySubject();
sub.add(new Observer1());
sub.add(new Observer2());
sub.operation();
}
}
2.迭代模式：將公共方法單獨拿出來，對原有的功能強化。主要是對一類模塊的功能添加
// 迭代器功能
public interface Interator {
// 迭代功能
public Object previous();
// 後移
public Object next();
public boolean hasNext();
// 取得第一個元素
public Object first();
}
//迭代器實現類：就像java裏面的集合，若是須要添加新的公共功能，則能夠利用這種方式
public class MyIterator implements Interator {
private Collection collection;
private int pos = -1;
// 採用的裝飾模式，將聚合類放入
public MyIterator(Collection collection) {
this.collection = collection;
}
@Override
public Object previous() {
if (pos > 0) {
pos--;
}
return collection.get(pos);
}
@Override
public Object next() {
if (pos < collection.size() - 1) {
pos++;
}
return collection.get(pos);
}
@Override
public boolean hasNext() {
if (pos < collection.size() - 1) {
return true;
} else {
return false;
}
}
@Override
public Object first() {
pos = 0;
return collection.get(pos);
}
}
//彙集對象
public interface Collection {
//裝飾模式
public Interator iterator();
// 取得集合對象
public Object get(int i);
// 集合大小
public int size();
}
//彙集對象實現
public class MyCollection implements Collection {
public String string[] = { "A", "B", "C", "D", "E" };
@Override
public Interator iterator() {
// 用裝飾模式，在迭代器中操做功能
// 使用代理模式：在聚合類中實現迭代器
// 只要實現了聚合類必然實現了迭代器
return new MyIterator(this);
}
@Override
public Object get(int i) {
return string[i];
}
@Override
public int size() {
return string.length;
}
}
//測試
public class Test {
public static void main(String[] args) {
Collection collection = new MyCollection();
Interator it = collection.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
3.責任鏈模式：利用裝飾模式(java接口能夠看成變量引用)，來相互嵌套
//掛載點
public interface Handler {
public void operater();
}
//抽象類實現
public abstract class AbstractHandler {
// 對操做類進行封裝
// ？能夠直接在子類中封裝
private Handler handler;
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
}
//具體子類
public class MyHandler extends AbstractHandler implements Handler {
private String name;
public MyHandler(String name) {
this.name = name;
}
// 操做
@Override
public void operater() {
System.out.println(name + "deal!");
if (getHandler() != null) {
getHandler().operater();
}
}
}
//測試
public class Test {
public static void main(String[] args) {
MyHandler h1 = new MyHandler("h1");
MyHandler h2 = new MyHandler("h1");
MyHandler h3 = new MyHandler("h1");
// 經過接口引用，將有相方法的類，經過地址連接起來
h1.setHandler(h2);
h2.setHandler(h3);
h1.operater();
}
}
// 也能夠直接在子類中實現
public class MyHandler2 {
private String name;
// 對操做類進行封裝
// ？能夠直接在子類中封裝
private Handler handler;
public Handler getHandler() {
return handler;
}
public void setHandler(Handler handler) {
this.handler = handler;
}
public MyHandler2(String name) {
this.name = name;
}
// 操做
public void operater() {
System.out.println(name + "deal!");
if (getHandler() != null) {
getHandler().operater();
}
}
}
4.命令模式：講一個事件的每個部分都分開實現，而後在相互調用。從而達到相互不影響
//命令接口：功能一
public interface Command {
public void exe();
}
//接受者接口：功能二
public interface Recevier {
public void action();
}
//執行者接口：功能三
public interface Invoker {
public void send();
}
//命令實現
public class MyCommand implements Command {
private Recevier reciver;
// 裝飾器
public MyCommand(Recevier reciver) {
this.reciver = reciver;
}
@Override
public void exe() {
reciver.action();
}
}
//接受這實現
public class FirestReceiver implements Recevier {
@Override
public void action() {
System.out.println(" first: commond reciver!");
}
}
//發送者實現
public class MyInvoker implements Invoker{
// 執行者
private Command command;
public MyInvoker(Command command) {
this.command = command;
}
public void send() {
command.exe();
}
}
//測試
public class Test {
public static void main(String[] args) {
Recevier receiver = new FirestReceiver();
Command cmd = new MyCommand(receiver);// 命令
Invoker invoker = new MyInvoker(cmd);// 命令發佈者
invoker.send();// 執行
// 先將發佈者、命令、接受者都解耦。而後經過裝飾器：執行結果
// 和責任模式類似、都是經過對（相同接口）的來相互調用。
}
}
2.3 類的狀態
主要經過中間類存放類的狀態，而後經過狀態複製恢復。
設計模式
2.4 中間類
經過中間類組合來各類功能類，下降不一樣功能之間的耦合，組合的靈活應用。通常做爲框架的主類，包含了不一樣模塊的全部功能。
框架
相關文章
- 1. 設計模式之行爲型模式
- 2. 26、設計模式之行爲模式
- 3. 設計模式之(四) 行爲模式
- 4. 設計模式之行爲模式（一）
- 5. OOAD之設計模式-行爲模式
- 6. 【JavaScript設計模式】行爲型設計模式--策略模式
- 7. 設計模式(5) -行爲型模式之 - 策略模式
- 8. 【設計模式系列】行爲型模式之Null Object模式
- 9. 【設計模式系列】行爲型模式之Template Method模式
- 10. 【設計模式系列】行爲型模式之Strategy模式
- 更多相關文章...
- • Scala 模式匹配 - Scala教程
- • SVN 啓動模式 - SVN 教程
- • 委託模式
- • IntelliJ IDEA代碼格式化設置
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
