浅谈java设计模式第三篇-CSDN博客

本文链接：https://blog.csdn.net/u012547613/article/details/79267491

该篇主要讲的行为型模式，包括策略模式，模板方法模式（这两类是父类与子类的作用关系）;观察者模式，迭代子模式，责任链模式，命令模式（这四类是类与类之间的作用关系）;备忘录模式，状态模式（这两类是类状态模式）；访问者模式，中介者模式,解释器模式（这三类是中间类和其它类的作用关系）

策略模式：

该模式主要分为多个算法模块和操作算法的用户，每个算法模块都是相互独立的并且可以相互替换，并且算法的改变不会影响使用的用户，决定权在用户

代码示例
public interface ICaculator {
public int Caculator(String exp);

}

public abstract class Caculator {

public int[] change(String exp,String str) {

  String[] array = exp.split(str);

  int[] arr = new int[2];

  arr[0] = Integer.parseInt(array[0]);
  arr[1] = Integer.parseInt(array[1]);

  return arr;
}
}

public class Minus extends Caculator implements ICaculator{

@Override
public int Caculator(String exp) {
int[] array = change(exp,"\\-");
return array[0] - array[1];
}

}

public class Multi extends Caculator implements ICaculator{

@Override
public int Caculator(String exp) {
int[] array = change(exp,"\\*");
return array[0]*array[1];
}

}

public class Plus extends Caculator implements ICaculator{

@Override
public int Caculator(String exp) {
int[] array = change(exp,"\\+");
return array[0]+array[1];
}

}

public class PatterTest {

public static void main(String[] args) {
  String splus = "8+2";
  ICaculator plus = new Plus();
  System.out.println(plus.Caculator(splus));

  String sminus = "8-2";
  ICaculator minus = new Minus();
  System.out.println(minus.Caculator(sminus));

  String smulti = "8*2";
  ICaculator multi = new Multi();
  System.out.println(multi.Caculator(smulti));
}
}

模板方法模式：

该模式主要由一个抽象类和继承该类的子类组成，其中模板类里有一个主方法，和n个抽象方法和实现的方法

代码示例：

public abstract class AbstractCaculator {

public final int caculator(String exp,String opt) {

  int[] array = change(exp,opt);
  return caculator(array[0],array[1]);

}

abstract int caculator(int x,int y);

    public int[] change(String exp,String opt) {
    String[] sarry = exp.split(opt);

    int[] array = new int[sarry.length];

    array[0] = Integer.parseInt(sarry[0]);
    array[1] = Integer.parseInt(sarry[1]);
    return array;
    }

}

public class Minus extends AbstractCaculator{

@Override
int caculator(int x, int y) {

return x-y;
}

}

public class Multi extends AbstractCaculator{

@Override
int caculator(int x, int y) {

return x*y;
}

}

public class Plus extends AbstractCaculator{

@Override
int caculator(int x, int y) {

return x+y;
}

}

public class PatternTest {

public static void main(String[] args) {
  String exp = "2+8";
  AbstractCaculator plus = new Plus();
  System.out.println(plus.caculator(exp,"\\+"));

  String exp1 = "8-2";
  AbstractCaculator minus = new Minus();
  System.out.println(minus.caculator(exp1,"\\-"));

  String exp2 = "8*2";
  AbstractCaculator multi = new Multi();
  System.out.println(multi.caculator(exp2,"\\*"));
}
}

观察者模式

该模式类似于邮件订阅和RSS订阅，当我们所订阅的邮件更新或者改变时，会收到通知；当某个对象发生改变时，其它依赖的对象也会收到通知并做出相应的改变，对应关系主要是一对多

代码示例：

public interface Observer {

public void receive();
}

public class Observer1 implements Observer{

@Override
public void receive() {
System.out.println("observer1已接收到");

}

}

public class Observer2 implements Observer{

@Override
public void receive() {
System.out.println("observer2已接收到");

}

}

public interface Subject {

public void add(Observer observer);

public void remove(Observer observer);

public void operation();

public void notifyAllObserver();

}

public abstract class AbstractSubject implements Subject{

    private Vector<Observer> vector = new Vector<Observer>();

public void add(Observer observer) {
   vector.add(observer);

}

public void remove(Observer observer) {

  vector.remove(observer);
}

public abstract void operation();

@Override
public void notifyAllObserver() {

  Enumeration<Observer> enume = vector.elements();

  while(enume.hasMoreElements()) {
   enume.nextElement().receive();
  }
}
}

public class MySubject extends AbstractSubject{

public void operation() {
System.out.println("update self.....");
notifyAllObserver();
}
}

public class PatterTest {

public static void main(String[] args) {
  Subject subject = new MySubject();

  subject.add(new Observer1());
  subject.add(new Observer2());

  subject.operation();
}
}

迭代子模式：

该模式主要讲的是顺序访问集合中的对象，一般要求两点：聚集对象（集合类）、迭代访问

代码示例：

public interface Iterator {

public String previous();

public String next();

public boolean hasNext();

public String first();
}

public class MyIterator implements Iterator{

private Collection collection;

public MyIterator(Collection collection) {

  this.collection = collection;
}

int pos = -1;
@Override
public String previous() {
    if(pos>0) {
       pos--;
    }
    return collection.getElement(pos);
}

@Override
public String next() {
   if(pos<collection.size()-1) {
    pos++;
   }
   return collection.getElement(pos);
}

@Override
public boolean hasNext() {
  if(pos>=-1&&pos<collection.size()-1) {
   return true;
  }else {
    return false;
  }
}

@Override
public String first() {
   pos = 0;

   return collection.getElement(pos);
}

}

public interface Collection {

public MyIterator iterator();

public int size();

public String getElement(int index);

}

public class MyCollection implements Collection{

private String[] str;


public MyCollection(String[] str) {
  this.str = str;

}

public MyIterator iterator() {
  return new MyIterator(this);

}

@Override
public int size() {

  return str.length;
}

@Override
public String getElement(int index) {

return str[index];
}

}

public class PatternTest {
public static void main(String[] args) {

     String[] sttr = new String[] {"A","B","C","D"};

  Collection collection = new MyCollection(sttr);
  Iterator iterator = collection.iterator();

  while(iterator.hasNext()) {
   String str = iterator.next();
   System.out.println(str);
  }

}

}

责任链模式

该模式的特点是某个对象会持有其它对象的引用，其它对象又持有另外的对象的引用，这样就会形成一条链，发出的请求会沿着这条链，但并不确定是哪个对象解决该请求

代码示例：

public interface Handle {

public void operate();
}

public abstract class AbstractHandle{

protected Handle handle;

public Handle getHandle() {
return handle;
}

public void setHandle(Handle handle) {
this.handle = handle;
}

}

public class MyHandle extends AbstractHandle implements Handle{

private String name;

public MyHandle(String name) {

  this.name = name;
}

@Override
public void operate() {
   System.out.println(name+"解决");

   if(handle!=null) {
    getHandle().operate();
   }

}

}

public class PatternTest {

public static void main(String[] args) {
  MyHandle handle1 = new MyHandle("A");
  MyHandle handle2 = new MyHandle("B");
  MyHandle handle3 = new MyHandle("C");

  handle1.setHandle(handle2);
  handle2.setHandle(handle3);

  handle1.operate();

}

}

命令模式

司令发出命令，命令经过传递，士兵接收到命令，三者只负责干自己的事，并不依赖其它者，命令模式就是实现这三者解耦，并不关心其它对象如何实现

代码示例

public interface Command {

public void exe();
}

public class Invoker {

private Command command;

public Invoker(Command command) {
  this.command = command;
}

public void action() {
  System.out.println("发出指令");
  command.exe();
}
}

public class MyCommand implements Command{

private Receiver receiver;

public MyCommand(Receiver receiver) {
   this.receiver=receiver;
}

@Override
public void exe() {
  receiver.action();

}

}

public class Receiver {

public void action() {

System.out.println("已收到指令");
}

}

public class PatterTest {

public static void main(String[] args) {

     Receiver receiver = new Receiver();

     Command command = new MyCommand(receiver);

     Invoker invoker = new Invoker(command);
     invoker.action();
}
}

备忘录模式

当需要存储某个对象的属性或者状态时，可以使用该模式，主要包括备忘录类和存储该备忘录的类

代码示例

public class Original {

private String name;

public Original(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setName(String name) {
  this.name = name;
}

public Memento createMemento() {
  return new Memento(name);
}

public void storageMemento(Memento memento) {
  this.name = memento.getName();
}
}

public class Memento {

private String name;

public Memento(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

}

public class Storage {

private Memento memento;

public Storage(Memento memento) {
this.memento = memento;
}

public Memento getMemento() {
return memento;
}

public void setMemento(Memento memento) {
this.memento = memento;
}

}

public class PatterTest {

public static void main(String[] args) {
  String string = "被存储的属性";
  String modString = "修改后的属性";

  Original original = new Original(string);
  Memento memento = original.createMemento();
  Storage storage = new Storage(memento);

  System.out.println(original.getName());
  original.setName(modString);
  System.out.println(original.getName());

  original.storageMemento(storage.getMemento());
  System.out.println(original.getName());
}
}

状态模式

当一个类的状态改变时，其操作行为也会发生改变，并且其它对象会收到通知，类似QQ,不同的用户状态会对应的不同的操作（隐身，在线，忙碌）

代码示例：

public class State {
protected String name;

public String getName() {
return name;
}

public void setName(String name) {
  this.name = name;
}

public void method1() {
  System.out.println("执行第一种状态的操作");
}

public void method2() {

  System.out.println("执行第二种状态的操作");
}

}

public class Context {

private State state;

public Context(State state) {
this.state = state;
}

public State getState() {
return state;
}

public void setState(State state) {
  this.state = state;
}

public void operation() {

  if(state.getName().equals("state1")){
   getState().method1();
  }else if(state.getName().equals("state2")) {
   getState().method2();
  }
}

}

public class PatternTest {

public static void main(String[] args) {
  State state = new State();

  Context context = new Context(state);
  state.setName("state1");
  context.operation();

  state.setName("state2");
  context.operation();
}
}

访问者模式

该模式进行数据结构和作用于结构上的操作解耦，使操作集合能够相对自由的演化，若数据结构易于变化，经常有新的结构对象添加进来则不适合该对象

代码示例：

public interface Visitor {

public void visit(Subject subject);
}

public interface Subject {

public void accept(Visitor visit);

public String subject();
}

public class MyVisitor implements Visitor{

@Override
public void visit(Subject subject) {
System.out.println(subject.subject());

}

}

public class MySubject implements Subject{

@Override
public void accept(Visitor visit) {
visit.visit(this);

}

@Override
public String subject() {
return "某数据结构";
}

}

public class PatternTest {
public static void main(String[] args) {
  Visitor visitor = new MyVisitor();
  Subject subject = new MySubject();

  subject.accept(visitor);

}

}

中介者模式

该模式主要降低类与类之间的耦合度，具体类与类之间的关系交个某个特定的类来维护（和外观者模式区别：中介者模式是把多对多的相互作用转化为一对多的相互作用，做的是简化的操作；而外观模式是提供一个高层次的接口，来统一管理子系统，方便外界调用）

代码示例

public interface Mediator {

public void createMediator();

public void workAll();
}

public class MyMediator implements Mediator{

private User user1;
private User user2;

@Override
public void createMediator() {
   user1 = new User1(this);
   user2 = new User2(this);

}

@Override
public void workAll() {
   user1.work();
   user2.work();

}

}

public abstract class User {

private Mediator mediator;

public User(Mediator mediator) {
this.mediator = mediator;
}

public abstract void work();

}

public class User1 extends User{

public User1(Mediator mediator) {
super(mediator);

}

@Override
public void work() {
System.out.println("user1执行。。。。。。");

}
}

public class User2 extends User{

public User2(Mediator mediator) {
  super(mediator);

}

@Override
public void work() {
   System.out.println("use2执行。。。。。。");

}

}

public class PatterTest {

public static void main(String[] args) {
  Mediator mediator = new MyMediator();
  mediator.createMediator();
  mediator.workAll();
}
}

解释器模式

该模式应用面比较窄，主要用在面向对象程序设计的解释器开发中，用来做成各种各种的解释器，如正则表达式解释器

代码示例

public class Context {

private int num1;
private int num2;

public Context(int num1,int num2) {
  this.num1 = num1;
  this.num2 = num2;
}

public int getNum1() {
  return num1;
}
public void setNum1(int num1) {
  this.num1 = num1;
}
public int getNum2() {
  return num2;
}
public void setNum2(int num2) {
  this.num2 = num2;
}

}

public interface Expression {

public int interpret(Context context);
}

public class Minus implements Expression{

@Override
public int interpret(Context context) {

return context.getNum1()-context.getNum2();
}

}

public class Plus implements Expression{

@Override
public int interpret(Context context) {
return context.getNum1()+context.getNum2();
}

}

public class PatterTest {

public static void main(String[] args) {
  Context context = new Context(9,6);

  Expression exp = new Plus();
  System.out.println(exp.interpret(context));

  Expression exp1 = new Minus();
  System.out.println(exp1.interpret(context));
}
}