Java如何获得传递方法的能力

在Javascript里通常可以定义对象，将方法当做一个变量传递进去
var option = {
  "username" : "xiami"
  "onLoadError" : function(str){
        console.log("xiami lost " + str);
   }
}
主调函数在执行时，传什么方法就执行什么方法。
同样的特性在java里也可以实现。


说是传方法，其实还是传对象
JAVA利用反射可以得到对象里的方法集合。只要拥有了含有目标方法的对象，目标方法的名称和方法入参，就可以直接执行了。
所以我们的目标就是把含有这三样的东西封装成对象用于传递


举个例子，这个类：

public class MethodObject {
	private Object target;//  
	private String method_name;
	private Object[] params;
	
	/*public static MethodObject function(Object target, String methodName,Object...objects){  
	   MethodObject mo=new MethodObject(target, methodName ,objects);  
	   //mo.invoke(objects);  
	   return  mo;  
	}*/
	public static MethodObject function(Object target,Object...objects){  
        MethodObject mo=new MethodObject(target,objects);  
        //mo.invoke(objects);  
        return  mo;  
    } 
	
	public Object invoke(){
		Class clazz = this.target.getClass();
		try {
			Method[] ms = clazz.getDeclaredMethods();
			Method targetMethod = null;   
			if(this.method_name==null&&ms.length==1) {
				//匿名类
				targetMethod=ms[0];
			}else if(this.method_name!=null&&ms.length>=1) {
				for(Method m : ms){    
                    if(this.method_name.equals(m.getName())){    
                        targetMethod = m;    
                        break;    
                    } 
				}
			}else{
				return null;
			}
			targetMethod.setAccessible(true);
			return targetMethod.invoke(this.target, this.params);    
		} catch (Exception e) {
			throw new RuntimeException(e);   
		}
	}
	public void rebund(Object anothertarget){    
        this.target = anothertarget;    
    }
	public MethodObject() {
		super();
	}
	public MethodObject(Object target,Object...objects) {    
	    super();    
	    this.target = target;
	    this.params = objects;
	}   
	public MethodObject(Object target, String methodName, Object...objects) {
		super();
		this.target = target;
		this.method_name = methodName;
		this.params = objects;
	}
	public Object getTarget() {
		return target;
	}
	public void setTarget(Object target) {
		this.target = target;
	}
	public String getMethod_name() {
		return method_name;
	}
	public void setMethod_name(String methodName) {
		method_name = methodName;
	}
	public Object[] getParams() {
		return params;
	}
	public void setParams(Object[] params) {
		this.params = params;
	}
	
	
}

其中MethodObject.function其实就是把 拥有目标方法的对象、目标方法名、入参 这三样东西绑定到一个MethodObject实例上




然后为了模拟js的情况，先写一个Option类
onLoadError被set了什么方法，到时就执行什么：

public class Option {
	private String username;
	private MethodObject onLoadError;
	
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public MethodObject getOnLoadError() {
		return onLoadError;
	}
	public void setOnLoadError(MethodObject onLoadError) {
		this.onLoadError = onLoadError;
	}
	
	
}

然后在Foo类里随便写个主调方法，Foo类的细节并不重要：

public void load(Option option){
		System.out.println(option.getUsername());
		option.getOnLoadError().invoke();
	}

实际执行时是这样的：

                Option option = new Option();
		option.setUsername("xiami");
		option.setOnLoadError(MethodObject.function(new Object(){
			public void getFromXiami(String thing){
				System.out.println("xiami lost " + thing); 
			}
		}, "JJ"));
		
		Foo o = new Foo();
		o.load(option);