java如何实现参数传递方法

例如类似于
obj.callme("abc",function(){自定义代码});
运行后内部也运行了那个匿名函数。
当然java由于语言本省的限制，是很难实现和上面完全一样的。
不过我们可以模拟一下。

定义一个类：

import java.lang.reflect.Method;


public class MethodObject 
	{
   private Object target;//
   private String method_name;
   public MethodObject(){}  
   
   public MethodObject(Object target, String methodName) {  
       super();  
       this.target = target;  
       this.method_name = methodName;  
   } 
   public MethodObject(Object target) {  
       super();  
       this.target = target;  
   } 
   public static MethodObject function(Object target, String methodName,Object...objects)
   {
	   MethodObject mo=new MethodObject( target,  methodName);
	  // mo.invoke(objects);
	   return  mo;
   }
   public static MethodObject function(Object target,Object...objects)
	   {
		   MethodObject mo=new MethodObject( target);
		  // mo.invoke(objects);
		   return  mo;
	   }
	public Object invoke(Object... objects)
		{
			 Class clazz = target.getClass();  
		        try {  
		            Method[] ms = clazz.getDeclaredMethods();  
		              
		            Method targetMethod = null;  
		            if(method_name==null&&ms.length==1)
		            	{
		            		targetMethod=ms[0];
		            	}
		            else if(method_name!=null&&ms.length>=1)
		            	{
		            		  for(Method m : ms){  
		  		                if(method_name.equals(m.getName())){  
		  		                    targetMethod = m;  
		  		                    break;  
		  		                } 
		            	}
		            		
		            
		           
		            }  
		            else
          			  {
          				  return null;
          			  }
		            targetMethod.setAccessible(true);  
		            return targetMethod.invoke(target, objects);  
		        } catch (Exception e) {  
		            // TODO Auto-generated catch block  
		            throw new RuntimeException(e);  
		        }   
		}
	 public void rebund(Object anothertarget){  
	        target = anothertarget;  
	    }  
	      

	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 method_name)
		{
			this.method_name = method_name;
		}

	}

之后我们就可以测试使用：

public class test
	{
     public static void main(String[] args)
		{
			
			
			
        
         test te=new test();
         te.isNotTrue(function(new Object(){
				
				public String  sysout(String jk)
					{
						return jk;
					}
			
			}),"哈哈 ");
		
		
		
		}
     public void isNotTrue(MethodObject me,String abc)
    	 {
    		System.out.println("i am here");
    		System.out.println(me.invoke(abc));
    		System.out.print("wo cool");
    	 }
	}

输出结果：
i am here
哈哈
wo cool

这里面用了几项技巧：静态导入，反射，不定参数，通过他们，就可以很好的封装模板代码。
现在让我们分析一下，先充test类开始，说白了，我就是想在 isNotTrue方法里面插入一段自定义的代码，或者说传入一个方法的调用，而到底执行什么是事先不确定的。
( 同时这是回调的一种很好的方式，比如很多框架都可以自定义在执行某些方法的核心代码之前你可以做覆盖某个方法做预处理等，这个都可以用上面的的代码实现)
那么我们如何实现呢？
  我们给main方法里的isNotTrue传了两个参数

分别是
MethodObject ： 
function(new Object(){

public String  sysout(String jk)
{
return jk;
}

})
Stirng：
"哈哈"

function是MethodObject中的静态方法，返回MethodObject 实例。MethodObject实例可以调用new Object(){}中的方法，如果你只是在new Object(){}定义一个方法，你无需指定是什么方法 MethodObject知道怎么调用哪一个，如果你定义了多个，那么你就得多指定一个参数，告诉他，是调用Object的哪一个方法。
那么这个就实现了在在isNotTrue方法中实现方法的传递了。
其实我们可以比较下javascript,在JavaScript你可以这样做
function parent(child,other){child();alert(other)}
这里child明显是一个函数。
我们调用parent可以这样
parent(function(){alert(0)},"me");
其实质就是实现了方法的传递。javascript的一等公民是函数，自然可以将函数做为参数传递给别人。
但是java则不可以，只能传递对象，应为Java是完全面向对象的。这就使得像Java那样传递一个简单
的匿名函数很困难，必须通过对象进行封装，在通过对象调用需要的方法。这时候对象成了一个中间的过程
，而且很繁琐。
上面的方法只是对javascript函数传递的一个模拟，但已经很简化了，只需通过给一个静态方法传递一个一个新建的
匿名对对象即可。唯一比javascript繁杂的地方时我们需要的函数外面包裹了两层，new Object以及静态方法function.
不过我想代码已经很少了了。呵呵。
具体实现大家可以再看看上面的代码。应该可以直接使用的。