设计模式之行为模式
设计模式之行为模式
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代码格式化设置
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
