设计模式之行为模式

模板方法模式
描述：通过继承抽象父类、实现接口来实现

继承抽象父类与实现接口的区别：
1.抽象父类中的方法可以是抽象的，也可以不是抽象的。子类只会对抽象的方法，进行重写。
2.接口里的方法都是抽象方法，实现类必须都进行重写
3.抽象父类可以存在自己特有的属性

//继承抽象父类
public abstract class Factory {
       abstract void runMechine();

}

ublic class 继承父类 extends Factory {
       @Override
       void runMechine() {
             // TODO Auto-generated method stub
             System.out.println("进行生产");
       }

       @Test
       public void test()
       {

             继承父类 factory=new 继承父类();
             factory.runMechine();
       }
}


//实现接口
import org.junit.Test;
public class 实现接口 implements FactoryA{
       @Override
       public void runMechine() {
             // TODO Auto-generated method stub
             System.out.println("开始生产");
       }

       @Test
       public  void test()
       {
             FactoryA factory=new 实现接口();
             factory.runMechine();
       }
}
interface FactoryA
{
 void  runMechine();
}

策略模式
描述：提供一种方式来应对某些需求的变化
与适配器模式的区别：
1.适配器模式方法名要相同
2.策略模式方法名可以不同

import org.junit.Test;
public class 策略模式 {
       private Factory factory;
       public void setFactory(Factory factory) {
             this.factory = factory;
       }

       //方法名可以不同
       public void run()
       {
             this.factory.runMechine();
       }


       @Test
       public void test001()
       {
             策略模式 c=new 策略模式();
             c.setFactory(new FactoryA());
             c.run();
       }

}
interface Factory
{
void runMechine();
}
class FactoryA implements Factory
{
       @Override
       public void runMechine() {
             // TODO Auto-generated method stub
             System.out.println("A工厂进行生产");
       }

       }
class FactoryB implements Factory
{
       @Override
       public void runMechine() {
             // TODO Auto-generated method stub
             System.out.println("B工厂进行生产");
       }
       }

状态模式
描述：当一个对象的内在状态发生改变时允许改变其行为，这个对象看起来像是改变了其类。
需要：
a.状态值 发生了状态对象的切换 类似于策略模式根据业务切换状态对象
b,设置状态值的方法
c.执行状态改变

实体类要包含状态对象 状态对象的改变要依托于实体对象

public interface State {
         void doAction(Soldier soldier);
}

public class StartState implements State {
       @Override
       public void doAction(Soldier soldier) {
             // TODO Auto-generated method stub
             System.out.println("士兵开始攻击");
             soldier.setState(this);
       }
       @Override
       public String toString() {
             return "士兵正在攻击";
       }

}

public class StopState implements State{
       @Override
       public void doAction(Soldier soldier) {
             // TODO Auto-generated method stub
             System.out.println("士兵停止攻击");
             soldier.setState(this);
       }
       @Override
       public String toString() {
             return "士兵已停止攻击";
       }
}

public class TestDemo {

      public static void main(String[] args) {

       //招募士兵
       Soldier soldier =new Soldier();
       //进攻指令
       State start=new StartState();
       start.doAction(soldier);
       System.out.println(soldier.getState());
       //停止攻击指令
       State stop=new StopState();
       stop.doAction(soldier);
       System.out.println(soldier.getState());


       }
}

观察者模式
描述：定义了一种一对多的依赖关系让多喝观察者同时监听某一个主体对象。这个主体对象当状态发生改变时，会通知所有观察者对象，使他们能够自动更新自己。
一个观察者，多个通知者。
应用场景：Serlvet基于此思想

控制反转：把改变自己权限给别人。

public interface State {
         void doAction(Soldier soldier);
}

public class StartState implements State {
       @Override
       public void doAction(Soldier soldier) {
             // TODO Auto-generated method stub
             System.out.println("士兵开始攻击");
             soldier.setState(this);
       }
       @Override
       public String toString() {
             return "士兵正在攻击";
       }

}

public class StopState implements State{
       @Override
       public void doAction(Soldier soldier) {
             // TODO Auto-generated method stub
             System.out.println("士兵停止攻击");
             soldier.setState(this);
       }
       @Override
       public String toString() {
             return "士兵已停止攻击";
       }
}

public class Soldier {
       private State state;
       public State getState() {
             return state;
       }
       public void setState(State state) {
             this.state = state;
       }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Observer {

       private List <Soldier>list=new ArrayList<>();

       private State state;

       //进入观察
       public void add(Soldier soldier)
       {
             list.add(soldier);
       }
    //离开观察
       public void  remove(Soldier soldier)
       {
             list.remove(soldier);
       }
       //设置情报
       public State getState() {
             return state;
       }
       //获取情报
       public void setState(State state) {
             this.state = state;
       }


       //通知获取情报
       public void inform()
       {
             for(Soldier s :list)
             {

                    if(this.state!=null)
                    {
                    this.state.doAction(s);
                    }else
                    {
                           System.out.println("请先设置状态");
                    }
             }

       }

}

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

             Soldier a =new Soldier();
             Soldier b=new Soldier();

             Observer observer=new Observer();

             //雇佣观察者
             observer.add(a);
             observer.add(b);

             //发出进攻指令
             observer.setState(new StartState());
             observer.inform();//进行通知
             System.out.println(a.getState());
             System.out.println(b.getState());


             //发出进攻指令
             observer.setState(new StopState());
             observer.inform();//进行通知
             System.out.println(a.getState());
             System.out.println(b.getState());
       }
}

备忘录模式
描述：提供状态存储即状态的恢复方法。
应用场景：游戏的存档

public class Game {
       private String username;//游戏名
       private int level;//等级
       private int pass;//关卡

       public Game(String username, int level, int pass) {
             super();
             this.username = username;
             this.level = level;
             this.pass = pass;
       }

       public String getUsername() {
             return username;
       }
       public void setUsername(String username) {
             this.username = username;
       }
       public int getLevel() {
             return level;
       }
       public void setLevel(int level) {
             this.level = level;
       }
       public int getPass() {
             return pass;
       }
       public void setPass(int pass) {
             this.pass = pass;
       }
       @Override
       public String toString() {
             return "Game [username=" + username + ", level=" + level + ", pass=" + pass + "]";
       }
}

import org.junit.Test;
public class Manager {
       private Game game;
       public Game getGame() {
             return game;
       }
       public void setGame(Game game) {
             this.game = game;
       }
       @Test
       public void test()
       {
             Manager manager=new Manager();
             Game game=new Game("luo", 99, 3);
             //保存记录
             manager.setGame(game);

             //读取记录
             System.out.println(manager.getGame());

       }
}

中介者模式
描述：与单例模式类似，都是将职责进行集中，但是中介模式仅仅把特定对象的职责进行集中，而单例模式是把所有的客户
的职责都集中起来。
客服来协调顾客与技术人员（给顾客安排技术人员）

这public class Custom {
       private Artisan artisan;
       public Artisan getArtisan() {
             return artisan;
       }
       public void setArtisan(Artisan artisan) {
             this.artisan = artisan;
       }

}

public class Artisan {
       public void solution(Custom custom)
       {
        System.out.println("技术人员与顾客进行沟通");
        custom.setArtisan(this);  
       }
}

import org.junit.Test;
public class CustomService {

       private Custom custom;
       private Artisan artisan;
       public Custom getCustom() {
             return custom;
       }
       public void setCustom(Custom custom) {
             this.custom = custom;
       }
       public Artisan getArtisan() {
             return artisan;
       }
       public void setArtisan(Artisan artisan) {
             this.artisan = artisan;
       }


       public void organize()
       {
             if(custom!=null&&artisan!=null)
             {
                    artisan.solution(custom);
             }

       }

       @Test
       public void test()
       {
             CustomService customService=new CustomService();
             customService.setArtisan(new Artisan());
             customService.setCustom(new Custom());
             System.out.println("组织技术人员与顾客见面");
             customService.organize();
       }

}

命令模式（别名：动作，事务）
描述:将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。
类似于观察模式将status 封装成一个类
也用到了控制反转的思想

可以将观察者理解为将军

public interface State {
         void doAction(Soldier soldier);
}

public class StartState implements State {
       @Override
       public void doAction(Soldier soldier) {
             // TODO Auto-generated method stub
             System.out.println("士兵开始攻击");
             soldier.setState(this);
       }
       @Override
       public String toString() {
             return "士兵正在攻击";
       }

}

public class StopState implements State{
       @Override
       public void doAction(Soldier soldier) {
             // TODO Auto-generated method stub
             System.out.println("士兵停止攻击");
             soldier.setState(this);
       }
       @Override
       public String toString() {
             return "士兵已停止攻击";
       }
}

public class Soldier {
       private State state;
       public State getState() {
             return state;
       }
       public void setState(State state) {
             this.state = state;
       }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Observer {

       private List <Soldier>list=new ArrayList<>();

       private State state;

       //进入观察
       public void add(Soldier soldier)
       {
             list.add(soldier);
       }
    //离开观察
       public void  remove(Soldier soldier)
       {
             list.remove(soldier);
       }
       //设置情报
       public State getState() {
             return state;
       }
       //获取情报
       public void setState(State state) {
             this.state = state;
       }


       //通知获取情报
       public void inform()
       {
             for(Soldier s :list)
             {

                    if(this.state!=null)
                    {
                    this.state.doAction(s);
                    }else
                    {
                           System.out.println("请先设置状态");
                    }
             }

       }

}

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

             Soldier a =new Soldier();
             Soldier b=new Soldier();

             Observer observer=new Observer();

             //雇佣观察者
             observer.add(a);
             observer.add(b);

             //发出进攻指令
             observer.setState(new StartState());
             observer.inform();//进行通知
             System.out.println(a.getState());
             System.out.println(b.getState());


             //发出进攻指令
             observer.setState(new StopState());
             observer.inform();//进行通知
             System.out.println(a.getState());
             System.out.println(b.getState());
       }
}

访问者模式
描述：表示一个作用于某个对象结构中的各元素的操作。它使得你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。
在被访问类中预留访问接口
通过实现接口，来实现不同访问者 进行不同的访问操作

public interface Bill {
       void accept(AccountBookViewer viewer);
}

//支出账单
public class ConsumeBill implements Bill{
    private double amount;
    private String item;
    public ConsumeBill(double amount, String item) {
        super();
        this.amount = amount;
        this.item = item;
    }
    public void accept(AccountBookViewer viewer) {
        viewer.view(this);
    }
    public double getAmount() {
        return amount;
    }
    public String getItem() {
        return item;
    }
}

//收入账单
public class IncomeBill implements Bill{
    private double amount;
    private String item;
    public IncomeBill(double amount, String item) {
        super();
        this.amount = amount;
        this.item = item;
    }
    public void accept(AccountBookViewer viewer) {
        viewer.view(this);
    }
    public double getAmount() {
        return amount;
    }
    public String getItem() {
        return item;
    }
}

//访问接口
public interface AccountBookViewer {
        //查看消费的单子
    void view(ConsumeBill bill);
    //查看收入的单子
    void view(IncomeBill bill);
}

//老板类，查看账本的类之一
public class Boss implements AccountBookViewer{
  private double totalIncome;
  private double totalConsume;
  //老板只关注一共花了多少钱以及一共收入多少钱，其余并不关心
  public void view(ConsumeBill bill) {
      totalConsume += bill.getAmount();
  }
  public void view(IncomeBill bill) {
      totalIncome += bill.getAmount();
  }
  public double getTotalIncome() {
      System.out.println("老板查看一共收入多少，数目是：" + totalIncome);
      return totalIncome;
  }
  public double getTotalConsume() {
      System.out.println("老板查看一共花费多少，数目是：" + totalConsume);
      return totalConsume;
  }
}

//注册会计师类，查看账本的类之一
public class CPA implements AccountBookViewer{
  //注会在看账本时，如果是支出，则如果支出是工资，则需要看应该交的税交了没
  public void view(ConsumeBill bill) {
      if (bill.getItem().equals("工资")) {
          System.out.println("注会查看工资是否交个人所得税。");
      }
  }
  //如果是收入，则所有的收入都要交税
  public void view(IncomeBill bill) {
      System.out.println("注会查看收入交税了没。");
  }
}

//账本类（相当于ObjectStruture）
public class AccountBook {
  //单子列表
  private List<Bill> billList = new ArrayList<Bill>();
  //添加单子
  public void addBill(Bill bill){
      billList.add(bill);
  }
  //供账本的查看者查看账本
  public void show(AccountBookViewer viewer){
      for (Bill bill : billList) {
          bill.accept(viewer);
      }
  }
}

public class Client {
    public static void main(String[] args) {
        AccountBook accountBook = new AccountBook();
        //添加两条收入
        accountBook.addBill(new IncomeBill(10000, "卖商品"));
        accountBook.addBill(new IncomeBill(12000, "卖广告位"));
        //添加两条支出
        accountBook.addBill(new ConsumeBill(1000, "工资"));
        accountBook.addBill(new ConsumeBill(2000, "材料费"));
        AccountBookViewer boss = new Boss();
        AccountBookViewer cpa = new CPA();
        //两个访问者分别访问账本
        accountBook.show(cpa);
        accountBook.show(boss);
        ((Boss) boss).getTotalConsume();
        ((Boss) boss).getTotalIncome();
    }
}

职责链模式
描述：对于不同的事务设置不同的级别 只有达到级别才能处理事务
雁过拔毛式：即使没有权限，也进行了建议注解

//普通的

public class 职责链 {
       //抽象的处理接口
       public abstract class Handler
       {
             protected Handler lender;
             //设定领导
             public void setLender(Handler lender) {
                    this.lender = lender;
             }
             //处理方法
             public abstract void handleRequest(int request);
       }
       //底层   只能处理级别1 的请求
       public class  A  extends Handler
       {

             public A()
             {}

             @Override
             public void handleRequest(int request) {
                    // TODO 自动生成的方法存根
                    if(request==1)
                    {
                           System.out.print("底层处理了事件"+request);

                    }
                    else
                    {
                           if(this.lender!=null)
                           {
                           System.out.println("底层无法处理事件"+request+"交给了领导");
                           this.lender.handleRequest(request);
                           }
                    }
             }
       }
       //中层  处理 1、2请求
       public class B extends Handler
       {
             @Override
             public void handleRequest(int request) {
                    // TODO 自动生成的方法存根



                    if(request<=2)
                    {
                           System.out.print("中层处理了事件"+request);

                    }
                    else
                    {
                           if(this.lender!=null)
                           {
                           System.out.println("中层无法处理事件"+request+"交给了领导");
                           this.lender.handleRequest(request);
                           }
                    }
             }
       }
       //上层处理1、2、3级别的请求
       public class C extends Handler
       {
             @Override
             public void handleRequest(int request) {
                    // TODO 自动生成的方法存根

                    System.out.println("上层领导处理了请求"+request);
             }
       }

}

public class 测试一 {
       public static void main(String[] args)
       {
             职责链 zk=new 职责链();
             Handler a=zk.new A();//底层
             Handler b=zk.new B();//中层
             Handler c=zk.new C();//高层

             a.setLender(b);
             b.setLender(c);

             a.handleRequest(3);
             a.handleRequest(1);




       }
}

//雁过拔毛式职责链

public class 雁过拔毛 {

          //抽象的处理接口
             public abstract class Handler1
             {
                    protected Handler1 lender;
                    protected String  remakes;

                    //设置备注
                    public String setremakes(String r)
                    {
                           if(this.remakes==null)
                           {
                                 this.remakes=r;
                           }
                           else
                           {

                                 this.remakes=this.remakes+"/n"+r;
                           }

                           return this.remakes;
                    }


                    //设定领导
                    public void setLender(Handler1 lender) {
                           this.lender = lender;
                    }
                    //处理方法
                    public abstract void handleRequest(int request);
             }
             //底层   只能处理级别1 的请求
             public class  A  extends Handler1
             {


                    @Override
                    public void handleRequest(int request) {
                           // TODO 自动生成的方法存根
                           if(request==1)
                           {
                                 System.out.print("底层处理了事件"+request);

                           }

                           else
                           {
                                 if(this.lender!=null)
                                 {
                                 System.out.println("底层无法处理事件"+request+"交给了领导");

                                 //并提交意见
                                 this.lender.setremakes("底层员工对请求"+request+"的意见");
                                 this.lender.handleRequest(request);
                                 }

                           }

                    }

             }
             //中层  处理 1、2请求
             public class B extends Handler1
             {
                    @Override
                    public void handleRequest(int request) {
                           // TODO 自动生成的方法存根
                           if(request<=2)
                           {
                                 System.out.println("中层查看备忘：");
                                 System.out.println(this.remakes);
                                 System.out.print("中层处理了事件"+request);

                           }
                           else
                           {
                                 if(this.lender!=null)
                                 {
                                 System.out.println("中层无法处理事件"+request+"交给了领导");
                                 //并提交意见

                                 this.lender.setremakes(this.remakes+"中层员工对请求"+request+"的意见");
                                 this.lender.handleRequest(request);
                                 }
                           }
                    }
             }
             //上层处理1、2、3级别的请求
             public class C extends Handler1
             {
                    @Override
                    public void handleRequest(int request) {
                           // TODO 自动生成的方法存根
                           System.out.println("高层查看备忘：");
                           System.out.println(this.remakes);
                           System.out.println("上层领导处理了请求"+request);
                    }
             }

}

public class 测试二 {
       public  static void main(String[] args)
       {
             雁过拔毛 zk =new 雁过拔毛();

             Handler1 a=zk.new A();//底层
             Handler1 b=zk.new B();//中层
             Handler1 c=zk.new C();//高层

             a.setLender(b);
             b.setLender(c);

             a.handleRequest(3);
             a.handleRequest(1);


       }

}

迭代器模式
描述：通过迭代器对对象进行操作
应用场景：用于安全得遍历一个容器对象
用一个自定义类将迭代器的功能展示出来
迭代器的基础是集合

//模拟迭代器功能
public interface Iterator {
          public boolean hasNext();
          public Object next();
       }

//根据集合生成填充元素后的迭代器
public interface Container {
       public Iterator getIterator();
}

//将迭代器与元素融合
public class NameRepository implements Container {
       public String names[] = {"Robert" , "John" ,"Julie" , "Lora"};
       @Override
       public Iterator getIterator() {
             return new NameIterator();
       }
       //姓名迭代器
       private class NameIterator implements Iterator {
             //int默认值为0 Integer的默认值为null
             int index;
             //判断是否还元素
             @Override
             public boolean hasNext() {
                    if(index < names.length){
                           return true;
                    }
                    return false;
             }
             //获取下一个坐标下的元素
             @Override
             public Object next() {
                    if(this.hasNext()){
                           return names[index++];
                    }
                    return null;
             }    
       }
}

public class IteratorPatternDemo {

          public static void main(String[] args) {
             NameRepository namesRepository = new NameRepository();

             //使用for进行遍历
             for(Iterator iter = namesRepository.getIterator(); iter.hasNext(); ){
                String name = (String)iter.next();
                System.out.println("Name : " + name);
             } 
          }
       }

解释器模式
描述：作为一个过滤选择器
应用场景： 首先输入一个加减或乘除的运算公式，比如a+b-c+a或a*b/c*a，再给每个参数赋值，最后根据公式完成运算并得到结果。
注：
1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。
2、一些重复出现的问题可以用一种简单的语言来进行表达。
3、一个简单语法需要解释的场景。

简单通过输入 获取输出 表达式处理

//表达式接口
public interface Expression {
       public boolean interpret(String context);

}

public class TerminalExpression implements Expression {

          private String data;

          public TerminalExpression(String data){
             this.data = data;
          }

          @Override
          public boolean interpret(String context) {
             if(context.contains(data)){
                return true;
             }
             return false;
          }
       }

public class OrExpression implements Expression {

          private Expression expr1 = null;
          private Expression expr2 = null;

          public OrExpression(Expression expr1, Expression expr2) {
             this.expr1 = expr1;
             this.expr2 = expr2;
          }

          @Override
          public boolean interpret(String context) {     
             return expr1.interpret(context) || expr2.interpret(context);
          }
       }

public class AndExpression implements Expression {

          private Expression expr1 = null;
          private Expression expr2 = null;

          public AndExpression(Expression expr1, Expression expr2) {
             this.expr1 = expr1;
             this.expr2 = expr2;
          }

          @Override
          public boolean interpret(String context) {     
             return expr1.interpret(context) && expr2.interpret(context);
          }
       }
public class InterpreterPatternDemo {

          //规则：Robert 和 John 是男性
          public static Expression getMaleExpression(){
             Expression robert = new TerminalExpression("Robert");
             Expression john = new TerminalExpression("John");
             return new OrExpression(robert, john);   
          }

          //规则：Julie 是一个已婚的女性
          public static Expression getMarriedWomanExpression(){
             Expression julie = new TerminalExpression("Julie");
             Expression married = new TerminalExpression("Married");
             return new AndExpression(julie, married);   
          }

          public static void main(String[] args) {
             Expression isMale = getMaleExpression();
             Expression isMarriedWoman = getMarriedWomanExpression();

             System.out.println("John is male? " + isMale.interpret("John"));
             System.out.println("Julie is a married women? "
             + isMarriedWoman.interpret("Married Julie"));
          }
       }