我使用AsyncTask来加载作为内部类实现的操作。
在中onPreExecute()，显示一个加载对话框，然后将其再次隐藏在中onPostExecute()。但是对于某些加载操作，我事先知道它们将很快完成，因此我不想显示加载对话框。
我想通过一个我可以传递给它的布尔参数来表明这一点，onPreExecute()但是显然出于某种原因onPreExecute()它没有任何参数。
显而易见的解决方法可能是在我的AsyncTask或外部类中创建一个成员字段，在每次加载操作之前都必须设置该成员字段，但这似乎不是很优雅。有一个更好的方法吗？
Answers:
您可以覆盖构造函数。就像是：
private class MyAsyncTask extends AsyncTask<Void, Void, Void> {
public MyAsyncTask(boolean showLoading) {
super();
// do stuff
}
// doInBackground() et al.
}
然后，在调用任务时，请执行以下操作：
new MyAsyncTask(true).execute(maybe_other_params);编辑：这比创建成员变量更有用，因为它简化了任务调用。将上面的代码与：
MyAsyncTask task = new MyAsyncTask();
task.showLoading = false;
task.execute();
1）对我来说，将参数传递给异步任务的最简单方法是这样的
// To call the async task do it like this
Boolean[] myTaskParams = { true, true, true };
myAsyncTask = new myAsyncTask ().execute(myTaskParams);像这样声明和使用异步任务
private class myAsyncTask extends AsyncTask<Boolean, Void, Void> {
@Override
protected Void doInBackground(Boolean...pParams)
{
Boolean param1, param2, param3;
//
param1=pParams[0];
param2=pParams[1];
param3=pParams[2];
....
} 2）将方法传递给异步任务 为了避免多次编码异步任务基础结构（线程，messagenhandler等），您可能会考虑将应在异步任务中执行的方法作为参数传递。以下示例概述了这种方法。另外，您可能需要将async-task子类化以在构造函数中传递初始化参数。
/* Generic Async Task */
interface MyGenericMethod {
int execute(String param);
}
protected class testtask extends AsyncTask<MyGenericMethod, Void, Void>
{
public String mParam; // member variable to parameterize the function
@Override
protected Void doInBackground(MyGenericMethod... params) {
// do something here
params[0].execute("Myparameter");
return null;
}
}
// to start the asynctask do something like that
public void startAsyncTask()
{
//
AsyncTask<MyGenericMethod, Void, Void> mytest = new testtask().execute(new MyGenericMethod() {
public int execute(String param) {
//body
return 1;
}
});
}为什么，如何以及将哪些参数传递给Asynctask <>，请参见此处的详细信息。我认为这是最好的解释。
Google的Android文档说：
异步任务由3个通用类型（称为Params，Progress和Result）以及4个步骤（称为onPreExecute，doInBackground，onProgressUpdate和onPostExecute）定义。
AsyncTask的通用类型：
异步任务使用的三种类型如下：
参数，执行时发送给任务的参数类型。进度，后台计算期间发布的进度单位的类型。结果，背景计算结果的类型。并非所有类型都总是由异步任务使用。要将类型标记为未使用，只需使用Void类型：
private class MyTask extends AsyncTask<Void, Void, Void> { ... }您可以进一步参考：http : //developer.android.com/reference/android/os/AsyncTask.html
或者您可以通过参考Sankar-Ganesh的博客来清除AsyncTask的作用
好吧，典型的AsyncTask类的结构如下：
private class MyTask extends AsyncTask<X, Y, Z>
protected void onPreExecute(){
} 在启动新线程之前执行此方法。没有输入/输出值，因此只需初始化变量或您认为需要执行的任何操作即可。
protected Z doInBackground(X...x){
}AsyncTask类中最重要的方法。您必须将所有您想在后台执行的工作放在这里，与主线程不在同一线程中。在这里，我们有一个来自类型“ X”的对象数组作为输入值（您在标题中看到吗？我们有“ ... extends AsyncTask”这是输入参数的TYPES）并返回该类型的对象“ Z”。
受保护的void onProgressUpdate（Y y）{
}此方法使用publishProgress（y）方法调用，通常在想要在主屏幕上显示任何进度或信息时使用，例如，进度条显示在后台进行的操作的进度。
受保护的void onPostExecute（Z z）{
在后台操作完成后，将调用此方法。作为输入参数，您将收到doInBackground方法的输出参数。
X，Y和Z类型呢？
从上面的结构可以推断出：
X – The type of the input variables value you want to set to the background process. This can be an array of objects.
Y – The type of the objects you are going to enter in the onProgressUpdate method.
Z – The type of the result from the operations you have done in the background process.我们如何从外部类中调用此任务？只需以下两行：
MyTask myTask = new MyTask();
myTask.execute(x);其中x是类型X的输入参数。
一旦我们运行了任务，我们就可以从“外部”找出其状态。使用“ getStatus（）”方法。
myTask.getStatus（）; 我们可以收到以下状态：
RUNNING-表示任务正在运行。
待处理-表示任务尚未执行。
已完成-表示onPostExecute（Z）已完成。
有关使用AsyncTask的提示
不要手动调用onPreExecute，doInBackground和onPostExecute方法。这是系统自动完成的。
您不能在另一个AsyncTask或线程内调用AsyncTask。方法execute的调用必须在UI线程中完成。
方法onPostExecute在UI线程中执行（在这里您可以调用另一个AsyncTask！）。
任务的输入参数可以是一个对象数组，这样您就可以放置所需的任何对象和类型。
您可以在任务构造函数中传递参数，也可以在调用execute时传递参数：
AsyncTask<Object, Void, MyTaskResult>第一个参数（对象）在doInBackground中传递。第三个参数（MyTaskResult）由doInBackground返回。您可以将它们更改为所需的类型。三个点表示可以将零个或多个对象（或它们的数组）作为参数传递。
public class MyActivity extends AppCompatActivity {
TextView textView1;
TextView textView2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main2);
textView1 = (TextView) findViewById(R.id.textView1);
textView2 = (TextView) findViewById(R.id.textView2);
String input1 = "test";
boolean input2 = true;
int input3 = 100;
long input4 = 100000000;
new MyTask(input3, input4).execute(input1, input2);
}
private class MyTaskResult {
String text1;
String text2;
}
private class MyTask extends AsyncTask<Object, Void, MyTaskResult> {
private String val1;
private boolean val2;
private int val3;
private long val4;
public MyTask(int in3, long in4) {
this.val3 = in3;
this.val4 = in4;
// Do something ...
}
protected void onPreExecute() {
// Do something ...
}
@Override
protected MyTaskResult doInBackground(Object... params) {
MyTaskResult res = new MyTaskResult();
val1 = (String) params[0];
val2 = (boolean) params[1];
//Do some lengthy operation
res.text1 = RunProc1(val1);
res.text2 = RunProc2(val2);
return res;
}
@Override
protected void onPostExecute(MyTaskResult res) {
textView1.setText(res.text1);
textView2.setText(res.text2);
}
}
}