java之设计模式

 编写代码原则：
    开闭原则：对修改关闭、对扩展开发。（如利于代码二次开发）

    作用：1.代码重用 2.低耦合（模块与模块之间，类与类之间依赖程度要降低） 3.高内聚（模块或者类内部依赖程度要高）4.易扩充 5.易维护

1.适配器模式 
  核心：只关心自己改造的部分，其他不用管

  类的适配器模式：关键就是继承一个source
  对象的适配器模式：持有source类的引用
  接口的适配器模式：就是弄一个抽象类继承大接口，然后类继承抽象类重写自己关心的方法就行了

/**
 * 适配器模式 - 类的适配器模式
 * 该类好比以前老功能，是第一期功能
 * Created by yz on 2018/3/6.
 */
public class Source {
    public void method1(){
        System.out.println("我是被适配的类的method1方法");
    }
}


/**
 * 适配器模式 - 类的适配器模式
 * 适配器接口，对以前功能进行适配，必须有以前类（Source.method1()）的方法
 * Created by yz on 2018/3/6.
 */
public interface AdapterInft {
    void method1(); // 以前的功能
    void method2(); // 扩展功能，自己的方法
}


/**
 * 适配器模式 - 类的适配器模式
 * 适配器接口实现类，需继承一期的类，实现新的功能
 * Created by yz on 2018/3/6.
 */
public class Adapter extends Source implements AdapterInft{

    public void method2() {
        System.out.println("第二期功能扩展，我是扩展功能！");
    }


    /**
     * 测试 适配器模式 - 类的适配器模式
     * @param args
     */
    public static void main(String[] args) {
        AdapterInft intf = new Adapter();
        intf.method1();
        intf.method2();
    }
}


/**
 * 适配器模式- 对象的适配器模式
 * 该类好比以前老功能，是第一期功能
 * Created by yz on 2018/3/6.
 */
public class Source {
    public void method1(){
        System.out.println("我是被适配的类的method1方法");
    }
}


/**
 * 适配器模式 - 对象的适配器模式
 * Created by yz on 2018/3/6.
 */
public interface AdapterInft {
    void method1(); // 以前的功能
    void method2(); // 扩展功能，自己的方法
}


/**
 * 适配器模式 - 对象的适配器模式
 * 他不需要继承以前Source类,他是有目标类的引用
 * Created by yz on 2018/3/6.
 */
public class Adapter implements AdapterInft{

    Source source;

    public Adapter(Source source) {
        this.source = source;
    }

    public void method1() {
        source.method1();
    }

    public void method2() {
        System.out.println("第二期功能扩展，我是扩展功能！");
    }


    /**
     * 测试 适配器模式 - 类的适配器模式
     * @param args
     */
    public static void main(String[] args) {
        AdapterInft intf = new Adapter(new Source());
        intf.method1();
        intf.method2();
    }
}


/**
 * 适配器模式 - 接口的适配器模式
 * 该接口好比以前老功能，是第一期功能
 * Created by yz on 2018/3/6.
 */
public interface Source {
    void method1();
    void method2();
    void method3();
    void method4();
    void method5();
    void method6();
    void method7();
}


/**
 * 适配器模式 - 接口的适配器模式
 * 定义抽象类 继承原接口 可以空方法
 * Created by yz on 2018/3/6.
 */
public abstract class Wrapper implements Source{
    public void method1() {
    }
    public void method2() {
    }
    public void method3() {
    }
    public void method4() {
    }
    public void method5() {
    }
    public void method6() {
    }
    public void method7() {
    }
}


/**
 * 适配器模式 - 接口的适配器模式
 * 继承抽象类，只重写需要的方法
 * Created by yz on 2018/3/6.
 */
public class Source1 extends Wrapper{
    @Override
    public void method1() {
        System.out.println("我只关心method1");
    }

    @Override
    public void method2() {
        System.out.println("我只关心method2");
    }

    public static void main(String[] args) {

    }
}


2.责任链模式 
  横向扩展，链条上有多个对象，每个对象持有下一个对象的引用，这样就会形成一条链，请求就在这条链上传递
  到底是哪一个对象处理请求，请求用户是不知道的，在隐瞒用户的情况下，对系统进行一个动态调整。


/**
 * 适配器模式 - 责任链模式
 * Created by yz on 2018/3/6.
 */
public class Test {

    /**
     * 这种写法，如果业务扩展，每次扩展都需要往后添加，这样写违背开闭原则 if esle 属于纵向扩展，不利于代码维护
     * 解决：不改以前代码基础上进行横向扩展
     * @param args
     */
    public static void main(String[] args) {
        String type = "湖南";
        if("湖南".equals(type)){
            System.out.println("我是处理湖南业务的代码！");
        }else if("湖北".equals(type)){
            System.out.println("我是处理湖北业务的代码！");
        }else if("江西".equals(type)){
            System.out.println("我是处理江西业务的代码！");
        }else if("江苏".equals(type)){
            System.out.println("我是处理江苏业务的代码！");
        }
    }
}


/**
 * 适配器模式 - 责任链模式
 * 定义接口
 * Created by yz on 2018/3/6.
 */
public interface Action {
    void todo(String type);
}

/**
 * 适配器模式 - 责任链模式
 * 定义抽象类实现接口
 * Created by yz on 2018/3/6.
 */
public abstract class AbstractAction implements Action{
    private Action action;
    public void todo(String type) {
        System.out.println("我是你们的爹，你们处理不了，就我来处理！");
    }
    public Action getAction() {
        return action;
    }
    public void setAction(Action action) {
        this.action = action;
    }
}

/**
 * 适配器模式 - 责任链模式
 * 定义湖南类继承抽象类
 * Created by yz on 2018/3/6.
 */
public class Hunan extends AbstractAction{

    private String type = "湖南";
    @Override
    public void todo(String type) {
        if(this.type.equals(type)){
            System.out.println("我是湖南处理中心，我只处理湖南业务！");
        }else {
            Action action = this.getAction();
            if(action != null){
                action.todo(type);
            }else{
                super.todo(type);
            }
        }
    }
}

/**
 * 适配器模式 - 责任链模式
 * 定义湖北类继承抽象类
 * Created by yz on 2018/3/6.
 */
public class Hubei extends AbstractAction{
    private String type = "湖北";
    @Override
    public void todo(String type) {
        if(this.type.equals(type)){
            System.out.println("我是湖北处理中心，我只处理湖北业务！");
        }else {
            Action action = this.getAction();
            if(action != null){
                action.todo(type);
            }else{
                super.todo(type);
            }
        }
    }
}

/**
 * 适配器模式 - 责任链模式
 * 定义江西类继承抽象类
 * Created by yz on 2018/3/6.
 */
public class Jiangxi extends AbstractAction{
    private String type = "江西";
    @Override
    public void todo(String type) {
        if(this.type.equals(type)){
            System.out.println("我是江西处理中心，我只处理江西业务！");
        }else {
            Action action = this.getAction();
            if(action != null){
                action.todo(type);
            }else{
                super.todo(type);
            }
        }
    }
}

/**
 * 适配器模式 - 责任链模式
 * 定义广东类继承抽象类
 * Created by yz on 2018/3/6.
 */
public class Guangdong extends AbstractAction{
    private String type = "广东";
    @Override
    public void todo(String type) {
        if(this.type.equals(type)){
            System.out.println("我是广东处理中心，我只处理广东业务！");
        }else {
            Action action = this.getAction();
            if(action != null){
                action.todo(type);
            }else{
                super.todo(type);
            }
        }
    }
}

/**
 * 适配器模式 - 责任链模式
 * Created by yz on 2018/3/6.
 */
public class Test {

    /**
     * 测试责任链
     * @param args
     */
    public static void main(String[] args) {
        Hunan hunan = new Hunan();
        Hubei hubei = new Hubei();
        Jiangxi jx = new Jiangxi();
        Guangdong gd = new Guangdong();
        hunan.setAction(hubei); // 湖南设置湖北的引用
        hubei.setAction(jx);
        jx.setAction(gd);
        gd.setAction(null);
        hunan.todo("广东");
    }
}

3.策略模式 也是消除大量if esle之一
  策略模式的一个决定权在用户，系统本身只实现不同算法的实现，用户可以决定到底调用谁
  责任链模式和策略模式好处：可以去除代码里面大量的if else ，可以横向扩展，易于维护

/**
 * 适配器模式 - 策略模式
 * 定义接口 策略模式先判断是不是自己的任务
 * Created by yz on 2018/3/6.
 */
public interface Action {

    /**
     * 处理任务的方法
     */
    void todo();

    /**
     * 判断是否是我的任务
     * @param type
     */
    boolean isMyJob(String type);
}

/**
 * 适配器模式 - 策略模式
 * 定义抽象类实现接口
 * Created by yz on 2018/3/6.
 */
public abstract class AbstractAction implements Action {

    public void todo() {
        System.out.println("我是你们的爹，你们处理不了，就我来处理！");
    }
}


/**
 * 适配器模式 - 策略模式
 * 定义湖南类继承抽象类
 * Created by yz on 2018/3/6.
 */
public class Hunan extends AbstractAction {
    private String type = "湖南";
    public void todo() {
        System.out.println("我是湖南处理中心，我只处理湖南业务！");
    }
    public boolean isMyJob(String type) {
        return this.type.equals(type);
    }
}


/**
 * 适配器模式 - 策略模式
 * 定义湖北类继承抽象类
 * Created by yz on 2018/3/6.
 */
public class Hubei extends AbstractAction {
    private String type = "湖北";
    public void todo() {
        System.out.println("我是湖北处理中心，我只处理湖北业务！");
    }
    public boolean isMyJob(String type) {
        return this.type.equals(type);
    }
}


/**
 * 适配器模式 - 策略模式
 * 定义江西类继承抽象类
 * Created by yz on 2018/3/6.
 */
public class Jiangxi extends AbstractAction {
    private String type = "江西";
    public void todo() {
        System.out.println("我是江西处理中心，我只处理江西业务！");
    }
    public boolean isMyJob(String type) {
        return this.type.equals(type);
    }
}


/**
 * 适配器模式 - 策略模式
 * 定义广东类继承抽象类
 * Created by yz on 2018/3/6.
 */
public class Guangdong extends AbstractAction {
    private String type = "广东";
    public void todo() {
        System.out.println("我是广东处理中心，我只处理广东业务！");
    }
    public boolean isMyJob(String type) {
        return this.type.equals(type);
    }
}

/**
 * 适配器模式 - 策略模式
 * Created by yz on 2018/3/6.
 */
public class Test {

    /**
     * 测试策略模式
     * @param args
     */
    public static void main(String[] args) {
        String type = "湖南";
        Hunan hn = new Hunan();
        Hubei hb = new Hubei();
        Jiangxi jx = new Jiangxi();
        Guangdong gd = new Guangdong();
        /*List<Action> lists = new ArrayList<Action>();
        lists.add(hn);
        lists.add(hb);
        lists.add(jx);
        lists.add(gd);
        boolean flag = true;
        for (Action action : lists) {
            if(action.isMyJob(type)){
                flag = false;
                action.todo();
                break;
            }
        }*/
        Map map = new HashMap();
        map.put("湖南",hn);
        map.put("湖北",hb);
        map.put("江西",jx);
        map.put("广东",gd);
        Action action = (Action) map.get("广东");
        action.todo();
    }
}


4.观察者模式（重点）
  例如订阅了一个文章，如果文章发生改变，怎样通知所有用户？
  有主题，有观察者，一旦主题发生改变，那么要及时的通知所有的观察者
  主题中需要拥有所有的观察者，这样才能操作所有的观察者，这样才能把消息传递给所有的观察者

/**
 * 适配器模式 - 观察者模式
 * 定义主题接口，主题改变的时候就要通知观察者
 * Created by yz on 2018/3/6.
 */
public interface Subject {
    void add(Observer o);     // 需要有观察者引用
    void notifyAllObserver(); // 通知所有观察者
}

/**
 * 适配器模式 - 观察者模式
 * 定义抽象类 可以定义很多抽象方法
 * Created by yz on 2018/3/6.
 */
public abstract class AbsteractObserver implements Subject{

    List<Observer> obList = new ArrayList<Observer>();

    public void add(Observer o) {
        obList.add(o);
    }

    public void notifyAllObserver() {
        if(obList.size()<=0){
            return;
        }
        for (Observer o : obList) {
            o.notifyme("有内容更新，请及时查阅");
        }
    }
}


/**
 * 适配器模式 - 观察者模式
 * 定义主题类
 * Created by yz on 2018/3/6.
 */
public class MySubject extends AbsteractObserver {
    public void myMethod(){
        System.out.println("");
    }
}

/**
 * 适配器模式 - 观察者模式
 * 定义观察者接口
 * Created by yz on 2018/3/6.
 */
public interface Observer {
    void notifyme(String msg);
}

/**
 * 适配器模式 - 观察者模式
 * 定义观察1 实现观察者接口
 * Created by yz on 2018/3/6.
 */
public class Observer1 implements Observer{
    public void notifyme(String msg) {
        System.out.println("我是观察者1，我收到了消息:"+msg);
    }
}


/**
 * 适配器模式 - 观察者模式
 * 定义观察2 实现观察者接口
 * Created by yz on 2018/3/6.
 */
public class Observer2 implements Observer{
    public void notifyme(String msg) {
        System.out.println("我是观察者2，我收到了消息:"+msg);
    }
}


/**
 * 适配器模式 - 观察者模式 测试类
 * Created by yz on 2018/3/6.
 */
public class Test {
    public static void main(String[] args) {
        Subject subject = new MySubject();
        Observer ob1 = new Observer1();
        Observer ob2 = new Observer2();
        subject.add(ob1);
        subject.add(ob2);
        subject.notifyAllObserver();
    }

}