设计模式学习--03关系模式（策略模式、模板方法模式、观察者模式、迭代器模式）

设计模式是思想，灵活使用会很大程度上减少开发的难度,拓展框架和程序的时候会很方便

1策略模式（strategy）

策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口。

上代码：

/**
 * 运算接口
 */
public interface Operation {
    public int doOperation(int i,int j);
}
/**
 * 运算A
 */
public class OperationA implements Operation{
    public int doOperation(int i, int j){
        System.out.println("执行运算A");
        return i+j;
    }
}
/**
 * 运算B
 */
public class OperationB implements Operation{
    public int doOperation(int i, int j){
        System.out.println("执行运算B");
        return i-j;
    }
}
/**
 * 策略执行类
 */
public class OperationPlan {
   private Operation ope;
    public OperationPlan(Operation ope){
        this.ope = ope;
    }

    //执行运算方法
    public int doOpe(int i,int j){
        return ope.doOperation(i,j);
    }
}
//测试

public class StrategyTest {
    public static void main(String[] args){
        OperationPlan oa = new OperationPlan(new OperationA());
        System.out.println(oa.doOpe(10,5));
        oa = new OperationPlan(new OperationB());
        System.out.println(oa.doOpe(10,5));
    }
}
//输出结果：
//执行运算A
//15
//执行运算B
//5

运算的策略封装在类里面，在调用的时候选择不同的类来执行运行策略，就能得到不同的运算结果。

2模板方法模式（Template Method）

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

简单来说就是抽象类定义了一个方法，来执行动作，子类具体实现这些动作，调用的方式还是使用父类定义的方法。

上代码：

/**
 * 模版
 */
public abstract class BulidHouse {
	//具体实现类规定方法
    abstract void buildDoor();
    abstract void buildWindow();

    /**
     *  这个就是模版方法 使用final定义
     *  不能复写，只能先执行buildDoor()再执行buildWindow()
     */

    public final void bulid() {
        buildDoor();
        buildWindow();
    }
}
public class BulidHouseByMachine extends BulidHouse {
    public void buildDoor(){
       System.out.println("机器修门");
    }

    public void buildWindow(){
        System.out.println("机器修窗户");
    }
}
public class BulidHouseByPerson extends BulidHouse {
    public void buildDoor(){
       System.out.println("人工修门");
    }

    public void buildWindow(){
        System.out.println("人工修窗户");
    }

}
public class Test {
    public static void main(String[] args){
        BulidHouse bulid1  = new BulidHouseByMachine();
        bulid1.bulid();
        BulidHouse bulid2  = new BulidHouseByPerson();
        bulid2.bulid();
    }
}
//输出：
//机器修门
//机器修窗户
//人工修门
//人工修窗户

3观察者模式（Observer）

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。
观察者模式比较抽象结合代码来看会轻松很多：

/**
 * 观察主题 定义是一只猫
 */
public class Cat {
    private String state;
    private List<Observer> observers  = new ArrayList<>();

    public String getState() {
        return state;
    }

//观察者 观察的状态
    public void setState(String state) {
        this.state = state;
        System.out.println(state);
        //状态修改后观察动作
        allObserversSee();
    }

    //加观察者
    public void addObserver(Observer observer){
        observers.add(observer);
    }

    //状态修改后观察动作
    public void allObserversSee(){
        for (Observer observer : observers) {
            observer.see();
        }
    }
}
/**
 * 观察者
 */
public interface Observer {
    public  void see();
}
/**
 * 观察者1好
 */
public class Observer1 implements Observer {
    public  void see(){
        System.out.println("观察者1号看到了状态修改");
    }
}

/**
 * 观察者2号
 */
public class Observer2 implements Observer {
    public  void see(){
        System.out.println("观察者2号看到了状态修改");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat =   new Cat();
        Observer ob1 = new Observer1();
        Observer ob2 = new Observer2();
        //给猫添加观察者
        cat.addObserver(ob1);
        cat.addObserver(ob2);
        cat.setState("猫状态修改");
    }
}
//输出：
//猫状态修改
//观察者1号看到了状态修改
//观察者2号看到了状态修改

简单分析一下观察者模式：被观察的对象持有全部的观察者，在被观察对象有状态修改的时候，通知观察者也执行相关操作。

4迭代器模式（Iterator）

提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。
简单来说就是提供一个集合，可以顺序遍历出里面所有对象，JAVA中的list,map,set大多使用了迭代器模式。java中也有自带的迭代类Iterator。
模拟一个简单的集合来说明一下这个模式：

//模拟迭代接口
public interface Iterator {
    //前移
    public Object previous();
    //后移
    public Object next();
    //是否最后
    public boolean hasNext();
    //取得第一个元素
    public Object first();
}
//迭代器
public class MyIterator implements Iterator{

    private Collection collection;

    //这个就是很多集合中使用的指针
    //每次取值变化就是移动了指针
    private int pos = -1;
    //构造方法 原生这样写 有spring框架注解注入就行
    public MyIterator(Collection collection){
        this.collection = collection;
    }
    //前移
    public Object previous(){

        if(pos > 0){
            pos--;
        }
        return collection.get(pos);
    }
    //后移
    public Object next(){
        //
        if(pos<collection.size()-1){
            pos++;
        }
        return collection.get(pos);
    }
    //是否最后
    public boolean hasNext(){
        if(pos<collection.size()-1){
            return true;
        }
        return false;
    }
    //取得第一个元素
    public Object first(){
        return collection.get(0);
    }

}
//模拟集合接口
public interface Collection {

    //建立集合
    public Iterator iterator();
    /*取得集合元素*/
    public Object get(int i);
    /*取得集合大小*/
    public int size();
}
/**
 * 实现集合类
 */
public class MyCollection implements Collection  {

    public String[] strings = {"A","B","C","D","E"};
    //集合持有集合对象
    private Iterator iterator;

    //建立集合
    public Iterator iterator(){
        return new MyIterator(this);
    }

    /*取得集合元素*/
    public Object get(int i){
        return strings[i];
    }
    /*取得集合大小*/
    public int size(){
        return strings.length;
    }
}
//测试
public class Test {
    public static  void  main(String[] args){
        Collection collection = new MyCollection();
        Iterator it = collection.iterator();

        while (it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println(it.previous());
    }
}
//输出：
//A
//B
//C
//D
//E
//D

简单的集合差不多就是这样的，java中的集合的核心大多在put或者add方法里面，喜欢看源码的重点看集合的这些方法。