设计模式

责任链模式

abstract class AbstractHander {
    private AbstractHander nextHander;

    public void setNextHander(AbstractHander nextHander) {
        this.nextHander = nextHander;
    }

    public final void doHander(int level) {
        if (canHander(level)) {
            doSomething(level);
        } else {
            if (nextHander != null) {
                nextHander.doHander(level);
            } else {
                System.out.println("all hander cannot hander");
            }
        }
    }

    protected abstract boolean canHander(int level);

    public abstract void doSomething(int level);

}

class InfoHander extends AbstractHander {

    @Override
    protected boolean canHander(int level) {
        if (level >= 0 && level <= 10) {
            return true;
        }
        return false;
    }

    @Override
    public void doSomething(int level) {
        System.out.println("InfoHander handler " + level);
    }
}


class DebugHander extends AbstractHander {

    @Override
    protected boolean canHander(int level) {
        if (level > 10) {
            return true;
        }
        return false;
    }

    @Override
    public void doSomething(int level) {
        System.out.println("DebugHander handler " + level);
    }
}

public class Main {
    public static void main(String... arg) {
        InfoHander infoHander = new InfoHander();
        DebugHander debugHander = new DebugHander();
        infoHander.setNextHander(debugHander);
        System.out.println("test -1");
        infoHander.doHander(-1);
        System.out.println("test 5");
        infoHander.doHander(5);
        System.out.println("test 11");
        infoHander.doHander(11);

    }
}

监听者模式

interface Listener {
    void alarm();
}

class MyListener implements Listener {

    @Override
    public void alarm() {
        System.out.println(this.getClass().getName()+"报警");
    }
}

class Ketter {
    Listener listener;

    public void registerListener(Listener listener) {
        this.listener = listener;
    }

    public void boilded() {
        System.out.println("水开了");
        listener.alarm();
    }
}

public class Main {
    public static void main(String... arg) {
        Ketter ketter = new Ketter();
        Listener listener = new MyListener();
        ketter.registerListener(listener);
        ketter.boilded();
    }

}

观察者模式（类似监听者模式）

interface Observer {
    void notice();
}

class AlarmObserver implements Observer {

    @Override
    public void notice() {
        System.out.println(this.getClass().getName() + " notified");
    }
}

class Subject {
    List<Observer> observers;

    public void subscribe(Observer observer) {
        if (observers == null) {
            observers = Lists.newArrayList();
        }
        observers.add(observer);
    }

    public void changeState() {
        System.out.println("subject changed");
        observers.forEach(Observer::notice);
    }
}

public class Main {

    public static void main(String... arg) {
        AlarmObserver observer = new AlarmObserver();
        Subject subject = new Subject();
        subject.subscribe(observer);
        subject.changeState();
    }
}

订阅者模式

 

class Topic {
    private Map<String, List<Subscriber>> topicMap;

    public void subscribe(Subscriber subscriber, String topic) {
        if (topicMap == null) {
            topicMap = Maps.newHashMap();
        }
        topicMap.computeIfAbsent(topic, key -> Lists.newArrayList()).add(subscriber);
    }

    public void notice(String topic) {
        List<Subscriber> subscribers = topicMap.computeIfAbsent(topic, k -> topicMap.put(topic, null));
        if (subscribers != null) {
            subscribers.forEach(Subscriber::notice);
        }
    }
}

interface Subscriber {
    void notice();
}

class BookSubscriber implements Subscriber{

    @Override
    public void notice() {
        System.out.println("1");
    }
}

interface Publisher {
    void publish(String topic);
    void setBookTopic(Topic topic);
}


class BookPublisher implements Publisher {
    Topic bookTopic;
    @Override
    public void setBookTopic(Topic topic) {
        bookTopic = topic;
    }

    @Override
    public void publish(String newtopic) {
        bookTopic.notice(newtopic);
    }
}

public class Main {

    public static void main(String... arg) {
        Topic bookTopic = new Topic();
        Publisher publisher = new BookPublisher();
        publisher.setBookTopic(bookTopic);
        Subscriber subscriber = new BookSubscriber();
        bookTopic.subscribe(subscriber,"1");
        publisher.publish("1");
        publisher.publish("2");
    }


}