Observor

核心思想：对象的某个方法本身被调用之后，本不产生具体的动作。具体的处理方法有监听其的对象来产生。

这里产生了一个问题，对于不同的监听对象不同的处理操作，如何在被监听对象中抽象出来，以达到不用每次修改被监听对象的目的，提高程序的可维护性和扩展性。答案是让这些监听对象实现同一接口，或者继承同一抽象类。两个的区别以及他们的应用场景有什么不同，目前还不知道。
例1：

package com.software.observer;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
 
 
public class Observer {
 
    public static void main(String[] args) {
        Button bt = new Button();
        //String 的每一个方法都要烂熟于心
        String[] strs = PropertiesUtil.getListenerName("observers").split(",");
        for(String name:strs){
            try {
                //反射机制
                bt.addListener((ActionListener)Class.forName(name).newInstance());
            } catch (InstantiationException | IllegalAccessException
                    | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        bt.buttonPress();
    }
 
}
class Button{
    ActionEvent e = new ActionEvent(System.currentTimeMillis(),this);
    List<ActionListener> listeners = new ArrayList<ActionListener>();
    public void buttonPress(){
        for(ActionListener listener:listeners){
            listener.actionPerformed(e);
        }
    }
    public void addListener(ActionListener listener){
        listeners.add(listener);
    }
}
 
class ActionEvent{
    Long time;
    Object source;
    public ActionEvent(Long time, Object source) {
        super();
        this.time = time;
        this.source = source;
    }
    public Long getWhen() {
        return time;
    }
    public Object getSource() {
        return source;
    }
}
interface ActionListener{
    public void actionPerformed(ActionEvent e);
}
class Listener1 implements ActionListener{
 
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println(e.getSource()+"button pressed 1!");
 
    }
 
}
 
class Listener2 implements ActionListener{
 
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println(e.getWhen()+"button pressed 2!");
    }   
}
 
class PropertiesUtil{
    /*静态的优点：文件从硬盘中只读取一次，而后放入内存，再次获取时提高速度，这就是 缓存 机制（关于缓存有很多策略）
     * 缺点：每次更改文件时需要重新加载
     * */
    public static Properties props = new Properties();
    static{
        try {
            props.load(Observer.class.getClassLoader().getResourceAsStream("com/software/observer/observer.properties"));
 
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static String getListenerName(String key){
        return props.getProperty(key);  
    }
}