java回调简单实例

先定义一个回调接口，里边是你要回调的方法

/**
 * 回调接口
 */
public interface ICallBack {
	public void success(Object obj) ;
}

在定义一个实体类，要用这个类回调上边的方法 ：

/**
 * 回调类
 */
public class Entity {
	private ICallBack callBack ;

	public void setCallBackClass(ICallBack callBack) {
		this.callBack = callBack ;
		String string = "hello world" ;
//		doSth(string);
		callBack.success(string);
	}
	
//	public void doSth(String str) {
//		callBack.success(str);
//	}
}

测试类测试一下：

public class Test1 {
	public static void main(String[] args) {
		Entity entity = new Entity() ;
		entity.setCallBackClass(new ICallBack() {
			
			public void success(Object obj) {
				System.out.println(obj);
				
			}
		});
	}
}

输出结果：

helo world

也可用自己定义的方法回调：

/**
 * 回调类
 */
public class Entity {
	private ICallBack callBack ;

	public void setCallBackClass(ICallBack callBack) {
		this.callBack = callBack ;
		String string = "hello world" ;
		doSth(string);
//		callBack.success(string);
	}
	
	public void doSth(String str) {
		callBack.success(str);
	}
}

和上面的没有区别 。

上面的只是简单的回调，而日常中我们需要回调的方法有可能要一段时间才会有结果，我们不可能一直等他执行完了之后才去做别的事情，这时就要用到异步回调 ，

异步回调就是把回调的函数放到线程中，让线程执行，执行完告诉我们就行了，我们交给线程之后就可以去做别的事情了 ；

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 回调类
 */
public class Entity {
	private static final ExecutorService EXECUTORS = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
	private static final class EntityInside {
		ICallBack callBack ;
	}
	public void run(final EntityInside entityInside) {
		EXECUTORS.submit(new Runnable() {
			public void run() {
				String string = "hello world" ;
				entityInside.callBack.success(string);
			}
		}) ;
	}
	public void doSth(ICallBack callBack) {
		EntityInside entityInside = new EntityInside() ; 
		entityInside.callBack = callBack ;
		run(entityInside) ;
	}
}

这里里用了一个静态内部类，需要把测试类中的main方法中Entity调用的方法改为doSth就可以了，通过通过内部类执行run方法，交给线程处理了 ，执行结果一样 ；