设计模式之模板方法模式

   package com.dp.example.templatemethod;
 * 抽象的Computer
 * @author mrsimple
 *
 */
public abstract class  {
    protected void powerOn() {
        System.out.println("开启电源");
    }
    protected void checkHardware() {
        System.out.println("硬件检查");
    }
    protected void loadOS() {
        System.out.println("载入操作系统");
    }
    protected void login() {
        System.out.println("小白的电脑无验证，直接进入系统");
    }
    
     * 启动电脑方法, 步骤固定为开启电源、系统检查、加载操作系统、用户登录。该方法为final， 防止算法框架被覆写.
     */
    public final void startUp() {
        System.out.println("------ 开机 START ------");
        powerOn();
        checkHardware();
        loadOS();
        login();
        System.out.println("------ 开机 END ------");
    }	
}
package com.dp.example.templatemethod;
 * 码农的计算机
 * 
 * @author mrsimple
 */
public class CoderComputer extends  {
    
    protected void login() {
        System.out.println("码农只需要进行用户和密码验证就可以了");
    }
}
package com.dp.example.templatemethod;
 * 军用计算机
 * 
 * @author mrsimple
 */
public class MilitaryComputer extends  {
    
    protected void checkHardware() {
        super.checkHardware();
        System.out.println("检查硬件防火墙");
    }
    
    protected void login() {
        System.out.println("进行指纹之别等复杂的用户验证");
    }
}
package com.dp.example.templatemethod;
public class Test {
    public static void main(String[] args) {
        AbstractComputer comp = new CoderComputer();
        comp.startUp();
        comp = new MilitaryComputer();
        comp.startUp();
    }
}

public final AsyncTask<Params, Progress, Result> execute(Params... params) {
       return executeOnExecutor(sDefaultExecutor, params);
   }
   public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
           Params... params) {
       if (mStatus != Status.PENDING) {
           switch (mStatus) {
               case RUNNING:
                   throw new IllegalStateException("Cannot execute task:"
                           + " the task is already running.");
               case FINISHED:
                   throw new IllegalStateException("Cannot execute task:"
                           + " the task has already been executed "
                           + "(a task can be executed only once)");
           }
       }
       mStatus = Status.RUNNING;
       onPreExecute();
       mWorker.mParams = params;
       exec.execute(mFuture);
       return this;
   }

public AsyncTask() {
      mWorker = new WorkerRunnable<Params, Result>() {
          public Result call() throws Exception {
              mTaskInvoked.set(true);
              Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
              return postResult(doInBackground(mParams));
          }
      };
      mFuture = new FutureTask<Result>(mWorker) {
          
          protected void done() {
              try {
                  final Result result = get();
                  postResultIfNotInvoked(result);
              } catch (InterruptedException e) {
                  android.util.Log.w(LOG_TAG, e);
              } catch (ExecutionException e) {
                  throw new RuntimeException("An error occured while executing doInBackground()",
                          e.getCause());
              } catch (CancellationException e) {
                  postResultIfNotInvoked(null);
              } catch (Throwable t) {
                  throw new RuntimeException("An error occured while executing "
                          + "doInBackground()", t);
              }
          }
      };
  }

private Result postResult(Result result) {
      Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
              new AsyncTaskResult<Result>(this, result));
      message.sendToTarget();
      return result;
  }
  private static class InternalHandler extends Handler {
      @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
      
      public void handleMessage(Message msg) {
          AsyncTaskResult result = (AsyncTaskResult) msg.obj;
          switch (msg.what) {
              case MESSAGE_POST_RESULT:
                  // There is only one result
                  result.mTask.finish(result.mData[0]);
                  break;
              case MESSAGE_POST_PROGRESS:
                  result.mTask.onProgressUpdate(result.mData);
                  break;
          }
      }
  }
  private void finish(Result result) {
      if (isCancelled()) {
          onCancelled(result);
      } else {
          onPostExecute(result);
      }
      mStatus = Status.FINISHED;
  }

@SuppressWarnings({"RawUseOfParameterizedType"})
  private static class AsyncTaskResult<Data> {
      final AsyncTask mTask;
      final Data[] mData;
      AsyncTaskResult(AsyncTask task, Data... data) {
          mTask = task;
          mData = data;
      }
  }