接口的使用，以及在异步任务中的使用

相信很多java和Android初学者，都对接口的定义有一些了解，但是如何使用它，利用它的特性来更好的实现自己想要的功能，却不甚了解。之前，我写代码也是没怎么用过接口，看到Android里，如监听方法里实现接口的写法，如：setOnClickListener(new OnClickListener()，或者网络请求的回调方法等等。都用到接口，实现了回调方法。这样写的好处，试过了就知道了。

好处一：在你想要实现某种功能（却还不明确具体需求）的地方，你只需要在哪里调用 接口的抽象方法，而具体的实现，你却可以在你喜欢的其他地方实现。

例如：监听方法的onclick回调方法，它里面的代码执行在点击事件完成后。仿写一个：

//接口的定义
public interface Callbackinterface {
	void dosomethinFailed();
	void dosomethingSuceess();
}

<pre name="code" class="java">//接口的抽象方法调用的地方，这个例子里在Bijiao类里的方法里通过判断调用
public class Bijiao{
	
	public  void comprate(int a,int b,Callbackinterface callbackinterface){
		if (a>b) {
			callbackinterface.dosomethingSuceess();
		}else {
			callbackinterface.dosomethinFailed();
		}
	}
}

<pre name="code" class="java">//最后，在java的mian方法里，调用Bijiao类的方法，并传入一个实现的接口，就可以了，重写的方法调用在上面的判断里，并执行
public class Test {
	public static void main(String[] args) {
		Bijiao bijiao=new Bijiao();
		bijiao.comprate(5, 4, new Callbackinterface() {
			
			@Override
			public void dosomethingSuceess() {
				// TODO Auto-generated method stub
				//dosomething you want
			}
			
			@Override
			public void dosomethinFailed() {
				// TODO Auto-generated method stub
				//dosomething you want
			}
		});
		
	}


	
<p>}</p>

显然，通过接口你可以在回调方法里做你想做的事，而不用接口的话，你可能会将Bijiao类的的方法的代码写死，不便于复用和修改。面向接口编程，也是一种解耦的不错选择。接下来，我们来做一个稍微复杂点的案例。我们的项目里，总是会遇到很多异步处理的需求，多线程来处理这些任务。通常，我们会用thread和handler，或者异步任务来做这些事情。异步任务和handler就挑异步任务来说下吧，因为异步任务本身也就是将thread和handler处理封装了而已，而且，也用的是接口。在异步任务AsyncTask里，有两个重要的重写方法doInBackground和onPostExecute，分别就是工作线程和ui线程的操作了。

接下来，我想将异步任务进一步通过实现一个接口，来使得这个异步任务类跟适合复用。

//先定义一个接口，这个接口用来实现工作线程的执行代码
public interface BackgroundInit {
	boolean doinbackground();
	
}

//在定义一个接口，执行UI线程要执行的代码
public interface UiExecute {
	void onsucess();
	void onfailed();
}

//定义一个继承AsyncTask的类
public class XpAsynncTask extends AsyncTask<Void, Void, Boolean>{
	UiExecute execute;
	BackgroundInit init;
	//构造方法传入这两个接口的实现类
	public XpAsynncTask(UiExecute execute,BackgroundInit init){
		this.execute=execute;
		this.init=init;
	}
	@Override
	protected Boolean doInBackground(Void... params) {
		// TODO Auto-generated method stub
		boolean result=false;
		result=init.doinbackground();//接口的抽象方法,具体实现在调用这个类的构造方法前实现
		return result;
	}

	@Override
	protected void onPostExecute(Boolean result) {
		// TODO Auto-generated method stub
		super.onPostExecute(result);
		if (result) {
			execute.onsucess();//接口的抽象方法,具体实现在调用这个类的构造方法前实现
		}else {
			execute.onfailed();//接口的抽象方法,具体实现在调用这个类的构造方法前实现
		}
	}
	

}

最后，在你要调用这个异步任务处理的时候，你只需要如下，就不用每次都重写一个异步任务去修改doInBackground和onPostExecute里的代码了。

<pre name="code" class="html">XpAsynncTask task=new XpAsynncTask(new UiExecute() {
				
				@Override
				public void onsucess() {
					// TODO Auto-generated method stub
					
				}
				
				@Override
				public void onfailed() {
					// TODO Auto-generated method stub
					
				}
			}, new BackgroundInit() {
				
				@Override
				public boolean doinbackground() {
					// TODO Auto-generated method stub
					return false;
				}
			});
			task.execute();

同样的，你还可以继续在这个代码块的某个地方再实现个接口，暴露给调用者实现的接口就当做方法的参数即可。就像我上面的写法，就是给异步任务嵌套了一层接口而已。

public void writeDataByYouself(UiExecute execute,
				final ProcessData processData) {//processData,再次增加的一个接口，这个接口只让调用者添加数据，发送的事情，我来做
			// TODO Auto-generated method stub
			XpAsynncTask task=new XpAsynncTask(execute,new BackgroundInit() {//BackgroundInit接口我不暴露给调用者去实现了

				@Override
				public boolean doinbackground() {
					// TODO Auto-generated method stub
					
					List<byte[]> list=processData.processDataBeforeSend();//processData,再次增加的一个接口，这个接口只让调用者添加数据，发送的事情，我来做
					if (list!=null) {
						for (int i = 0; i < list.size(); i++) {
							
							mMsg=xPrinterDev.Write(list.get(i));
						}
						if (mMsg.GetErrorCode().equals(ErrorCode.WriteDataSuccess)) {
							return true;
						}						
					}
					return false;
				}
			});
			//task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
			task.execute();
		}

</pre><pre>

恩，看了这几个例子，你是不是发现，接口其实没什么，就是在另外一个方法里，参数是这个接口的实现类，然后在方法体的某一个地方调用它的抽象方法吧了，说的简单点，就是把一个代码块换到了你想执行的地方去执行，而那个执行的地方用接口的抽象方法做了标记。没错，就是这么简单。

还有一点好处就是，如果你的异步任务的子类，不是写着Activity或者fragment里的话，又想进行一些ui操作，怎么办，难道把要进行ui操作的控件和对象全部通过构造方法传参过去？还是是个控件对象你就定义为静态的？这样肯定不怎么好吧。那就用接口吧，在活动或者碎片里，实现接口，就很容易解决这些问题。而这个异步任务的子类也将具有非常高的复用性。代码结构也简洁易懂。

这一篇就说那么多了，下一篇，讲下接口，service，异步任务的结合使用情况。不忙的话。