1.模板方法模式

有个abstarct 类定义了整个函数的流程，继承，实现。

abstract class AbstractSort{
    protected abstract void sort(int[] array);
    public void showSortResult(int[] array){
        this.sort(array);
        System.out.println("result:");
        for(int i=0;i<array.length;i++){
            System.out.printf("%3s", array[i]);
        }
    }
}
class ConcreteSort extends AbstractSort{
    @Override    protected void sort(int[] array) {
        for(int i=0;i<array.length -1;i++){
            selectSort(array,i);
        }
    }
    private void selectSort(int[] array,int index){
        int MinValue = 32767;
        int indexMin =0;
        int Temp;
        for(int i=index;i<array.length;i++){
            if(array[i] < MinValue){
                MinValue =array[i];
                indexMin=i;            }
        }
        Temp = array[index];
        array[index]= array[indexMin];
        array[indexMin]=Temp;
    }
}
public class Module {
    public static int[] a ={10,32,1,9,5,7,12,0,4,3};
    public static void main(String[] args){
        AbstractSort s = new ConcreteSort();
        s.showSortResult(a);
    }
}

2.中介者模式
为了不让 两个相关联的类，缠绕在一起，于是，多做了一层，
在这一层里面，封装两个人交互的行为。
为了解耦合其实是。

abstract class AbstractColleague2{
    protected int number;
    public int getNumber(){
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }
    public abstract void setNumber(int number,AbstractMediator coll);
}
class ColleagueA2 extends AbstractColleague2{
    public void setNumber(int number,AbstractMediator coll){
        this.number=number;
        coll.AaffectB();
    }
}

class ColleagueB2 extends AbstractColleague2{
    public void setNumber(int number,AbstractMediator coll){
        this.number=number;
        coll.BaffectA();
    }
}


abstract class AbstractMediator{
    protected AbstractColleague2 A;
    protected AbstractColleague2 B;

    public AbstractMediator(AbstractColleague2 a,AbstractColleague2 b){
        A=a;
        B=b;
    }

    public abstract void AaffectB();
    public abstract void BaffectA();
}
class Mediator extends AbstractMediator{
    public Mediator(AbstractColleague2 a,AbstractColleague2 b){
        super(a,b);
    }

    @Override
    public void AaffectB() {
        B.setNumber(A.getNumber()*100);
    }

    @Override
    public void BaffectA() {
        A.setNumber(B.getNumber()/100);
    }
}

public class Middle2 {
    public static void main(String[] args) {
        AbstractColleague2 collA = new ColleagueA2();
        AbstractColleague2 collB = new ColleagueB2();
        AbstractMediator am = new Mediator(collA, collB);
        System.out.println(" ========");
        collA.setNumber(1000, am);
        System.out.println("A:" + collA.getNumber());
        System.out.println("B:" + collB.getNumber());
    }
}

3.观察者模式

感觉就是循环通知....

abstract class Subject{
    private Vector<Observer> obs = new Vector<Observer>();
    public void addObserver(Observer obs){
        this.obs.add(obs);
    }
    public void delObserver(Observer obs){
        this.obs.remove(obs);
    }

    protected void notifyObserver(){
        for(Observer o:obs){
            o.update();
        }
    }

    public abstract void doSomething();

}

class ConcreteSubject extends Subject{
    @Override
    public void doSomething() {
        System.out.println("happen");
        this.notifyObserver();
    }

}
interface Observer{
    public void update();
}

class ConcreteObserver1 implements Observer{
    @Override
    public void update() {
        System.out.println("1 receive data and solving");
    }
}

class ConcreteObserver2 implements Observer{
    @Override
    public void update() {
        System.out.println("2 receive data and solving");
    }
}


public class ObserverTest {
    public static void main(String[] args){
        Subject sub = new ConcreteSubject();
        sub.addObserver(new ConcreteObserver1());
        sub.addObserver(new ConcreteObserver2());
        sub.doSomething();
    }
}