模板方法模式定义：defines the skeleton of an algorithm in a method, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm\’s structure.定义一个方法操作算法的框架（骨架结构），而将一些步骤延迟到子类中。
模板方法模式定义：
defines the skeleton of an algorithm in a method, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm\’s structure.
定义一个方法操作算法的框架（骨架结构），而将一些步骤延迟到子类中。模板方法使子类可以在不改变一个算法的结构的情况下，就可以重定义该算法的某些特定步骤。

　　如上图所示（截取自《Head First Design Patterns》一书），具体各个部分有什么作用见上图，这里就不啰嗦了。

封装不变部分，扩展可变部分。把不变部分的算法封装到父类实现，而可变部分的根据子类的具体需要，则可以通过继承来扩展。
提取公共部分，构成一个“模板”，模板的作用在于对算法或者流程的一个结构化、规范化，子类不能修改“模板方法”的整个算法骨架或者流程的顺序等，只能根据自身的不同，对模板方法中算法的某一步进行扩展。

行为由父类控制，子类实现。子类可以通过扩展的方法增加相应的功能，符合开闭原则。

　　在Android源码中，View中的Draw()方法就是一个“模板方法”。它定义了一系列“Draw”过程，主要包括这几个步骤（截取自源代码）：

        /*
         * Draw traversal performs several drawing steps which must be executed
         * in the appropriate order:
         *
         *      1. Draw the background
         *      2. If necessary, save the canvas\’ layers to prepare for fading
         *      3. Draw view\’s content
         *      4. Draw children
         *      5. If necessary, draw the fading edges and restore layers
         *      6. Draw decorations (scrollbars for instance)
         */

具体函数代码如下所示：

View Code 

  1.           /**
  2.      * Manually render this view (and all of its children) to the given Canvas.
  3.      * The view must have already done a full layout before this function is
  4.      * called.  When implementing a view, implement
  5.      * {@link #onDraw(android.graphics.Canvas)} instead of overriding this method.
  6.      * If you do need to override this method, call the superclass version.
  7.      *
  8.      * @param canvas The Canvas to which the View is rendered.
  9.      */
  10.     public void draw(Canvas canvas) {
  11.         if (ViewDebug.TRACE_HIERARCHY) {
  12.             ViewDebug.trace(this, ViewDebug.HierarchyTraceType.DRAW);
  13.         }
  15.         final int privateFlags = mPrivateFlags;
  16.         final boolean dirtyOpaque = (privateFlags & DIRTY_MASK) == DIRTY_OPAQUE &&
  17.                 (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
  18.         mPrivateFlags = (privateFlags & ~DIRTY_MASK) | DRAWN;
  20.         /*
  21.          * Draw traversal performs several drawing steps which must be executed
  22.          * in the appropriate order:
  23.          *
  24.          *      1. Draw the background
  25.          *      2. If necessary, save the canvas\' layers to prepare for fading
  26.          *      3. Draw view\'s content
  27.          *      4. Draw children
  28.          *      5. If necessary, draw the fading edges and restore layers
  29.          *      6. Draw decorations (scrollbars for instance)
  30.          */
  31.  
  32.         // Step 1, draw the background, if needed
  33.         int saveCount;
  35.         if (!dirtyOpaque) {
  36.             final Drawable background = mBGDrawable;
  37.             if (background != null) {
  38.                 final int scrollX = mScrollX;
  39.                 final int scrollY = mScrollY;
  41.                 if (mBackgroundSizeChanged) {
  42.                     background.setBounds(0, 0,  mRight - mLeft, mBottom - mTop);
  43.                     mBackgroundSizeChanged = false;
  44.                 }
  46.                 if ((scrollX | scrollY) == 0) {
  47.                     background.draw(canvas);
  48.                 } else {
  49.                     canvas.translate(scrollX, scrollY);
  50.                     background.draw(canvas);
  51.                     canvas.translate(-scrollX, -scrollY);
  52.                 }
  53.             }
  54.         }
  56.         // skip step 2 & 5 if possible (common case)
  57.         final int viewFlags = mViewFlags;
  58.         boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
  59.         boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
  60.         if (!verticalEdges && !horizontalEdges) {
  61.             // Step 3, draw the content
  62.             if (!dirtyOpaque) onDraw(canvas);
  64.             // Step 4, draw the children
  65.             dispatchDraw(canvas);
  67.             // Step 6, draw decorations (scrollbars)
  68.             onDrawScrollBars(canvas);
  70.             // we\'re done...
  71.             return;
  72.         }
  74.         /*
  75.          * Here we do the full fledged routine...
  76.          * (this is an uncommon case where speed matters less,
  77.          * this is why we repeat some of the tests that have been
  78.          * done above)
  79.          */
  80.  
  81.         boolean drawTop = false;
  82.         boolean drawBottom = false;
  83.         boolean drawLeft = false;
  84.         boolean drawRight = false;
  86.         float topFadeStrength = 0.0f;
  87.         float bottomFadeStrength = 0.0f;
  88.         float leftFadeStrength = 0.0f;
  89.         float rightFadeStrength = 0.0f;
  91.         // Step 2, save the canvas\' layers
  92.         int paddingLeft = mPaddingLeft;
  94.         final boolean offsetRequired = isPaddingOffsetRequired();
  95.         if (offsetRequired) {
  96.             paddingLeft += getLeftPaddingOffset();
  97.         }
  99.         int left = mScrollX + paddingLeft;
  100.         int right = left + mRight - mLeft - mPaddingRight - paddingLeft;
  101.         int top = mScrollY + getFadeTop(offsetRequired);
  102.         int bottom = top + getFadeHeight(offsetRequired);
  104.         if (offsetRequired) {
  105.             right += getRightPaddingOffset();
  106.             bottom += getBottomPaddingOffset();
  107.         }
  109.         final ScrollabilityCache scrollabilityCache = mScrollCache;
  110.         final float fadeHeight = scrollabilityCache.fadingEdgeLength;        
  111.         int length = (int) fadeHeight;
  113.         // clip the fade length if top and bottom fades overlap
  114.         // overlapping fades produce odd-looking artifacts
  115.         if (verticalEdges && (top + length > bottom - length)) {
  116.             length = (bottom - top) / 2;
  117.         }
  119.         // also clip horizontal fades if necessary
  120.         if (horizontalEdges && (left + length > right - length)) {
  121.             length = (right - left) / 2;
  122.         }
  124.         if (verticalEdges) {
  125.             topFadeStrength = Math.max(0.0f, Math.min(1.0f, getTopFadingEdgeStrength()));
  126.             drawTop = topFadeStrength * fadeHeight > 1.0f;
  127.             bottomFadeStrength = Math.max(0.0f, Math.min(1.0f, getBottomFadingEdgeStrength()));
  128.             drawBottom = bottomFadeStrength * fadeHeight > 1.0f;
  129.         }
  131.         if (horizontalEdges) {
  132.             leftFadeStrength = Math.max(0.0f, Math.min(1.0f, getLeftFadingEdgeStrength()));
  133.             drawLeft = leftFadeStrength * fadeHeight > 1.0f;
  134.             rightFadeStrength = Math.max(0.0f, Math.min(1.0f, getRightFadingEdgeStrength()));
  135.             drawRight = rightFadeStrength * fadeHeight > 1.0f;
  136.         }
  138.         saveCount = canvas.getSaveCount();
  140.         int solidColor = getSolidColor();
  141.         if (solidColor == 0) {
  142.             final int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;
  144.             if (drawTop) {
  145.                 canvas.saveLayer(left, top, right, top + length, null, flags);
  146.             }
  148.             if (drawBottom) {
  149.                 canvas.saveLayer(left, bottom - length, right, bottom, null, flags);
  150.             }
  152.             if (drawLeft) {
  153.                 canvas.saveLayer(left, top, left + length, bottom, null, flags);
  154.             }
  156.             if (drawRight) {
  157.                 canvas.saveLayer(right - length, top, right, bottom, null, flags);
  158.             }
  159.         } else {
  160.             scrollabilityCache.setFadeColor(solidColor);
  161.         }
  163.         // Step 3, draw the content
  164.         if (!dirtyOpaque) onDraw(canvas);
  166.         // Step 4, draw the children
  167.         dispatchDraw(canvas);
  169.         // Step 5, draw the fade effect and restore layers
  170.         final Paint p = scrollabilityCache.paint;
  171.         final Matrix matrix = scrollabilityCache.matrix;
  172.         final Shader fade = scrollabilityCache.shader;
  174.         if (drawTop) {
  175.             matrix.setScale(1, fadeHeight * topFadeStrength);
  176.             matrix.postTranslate(left, top);
  177.             fade.setLocalMatrix(matrix);
  178.             canvas.drawRect(left, top, right, top + length, p);
  179.         }
  181.         if (drawBottom) {
  182.             matrix.setScale(1, fadeHeight * bottomFadeStrength);
  183.             matrix.postRotate(180);
  184.             matrix.postTranslate(left, bottom);
  185.             fade.setLocalMatrix(matrix);
  186.             canvas.drawRect(left, bottom - length, right, bottom, p);
  187.         }
  189.         if (drawLeft) {
  190.             matrix.setScale(1, fadeHeight * leftFadeStrength);
  191.             matrix.postRotate(-90);
  192.             matrix.postTranslate(left, top);
  193.             fade.setLocalMatrix(matrix);
  194.             canvas.drawRect(left, top, left + length, bottom, p);
  195.         }
  197.         if (drawRight) {
  198.             matrix.setScale(1, fadeHeight * rightFadeStrength);
  199.             matrix.postRotate(90);
  200.             matrix.postTranslate(right, top);
  201.             fade.setLocalMatrix(matrix);
  202.             canvas.drawRect(right - length, top, right, bottom, p);
  203.         }
  205.         canvas.restoreToCount(saveCount);
  207.         // Step 6, draw decorations (scrollbars)
  208.         onDrawScrollBars(canvas);
  209.     }

其中第三步（ Step 3）Draw view\’s content函数：

  1.     /**
  2.      * Implement this to do your drawing.
  3.      *
  4.      * @param canvas the canvas on which the background will be drawn
  5.      */
  6.     protected void onDraw(Canvas canvas) {
  7.     }

第四步（ Step 4） draw children  

  1.     /**
  2.      * Called by draw to draw the child views. This may be overridden
  3.      * by derived classes to gain control just before its children are drawn
  4.      * (but after its own view has been drawn).
  5.      * @param canvas the canvas on which to draw the view
  6.      */
  7.     protected void dispatchDraw(Canvas canvas) {
  8.     }

　　从上面的Draw()“模板方法”可以看出，当继承View子类中，如果要重写或者扩展这个方法时，整个方法流程和基本内容不能够修改，子类只能通过扩展onDraw(Canvas canvas)和dispatchDraw(Canvas canvas)两个函数，使子类自己的View显示效果和别的具体子类的不同。现在来看看继承自View类的具体子类如何扩展Draw()模板方法显示自己的与众不同：

　　1、TextView类中重写了OnDraw函数

  1. @Override
  2.     protected void onDraw(Canvas canvas) {
  3.         if (mPreDrawState == PREDRAW_DONE) {
  4.             final ViewTreeObserver observer = getViewTreeObserver();
  5.             observer.removeOnPreDrawListener(this);
  6.             mPreDrawState = PREDRAW_NOT_REGISTERED;
  7.         }
  9.         if (mCurrentAlpha <= ViewConfiguration.ALPHA_THRESHOLD_INT) return;
  11.         restartMarqueeIfNeeded();
  13.         // Draw the background for this view
  14.         super.onDraw(canvas);
  16.         final int compoundPaddingLeft = getCompoundPaddingLeft();
  17.         final int compoundPaddingTop = getCompoundPaddingTop();
  18.         final int compoundPaddingRight = getCompoundPaddingRight();
  19.         final int compoundPaddingBottom = getCompoundPaddingBottom();
  20.         final int scrollX = mScrollX;
  21.         final int scrollY = mScrollY;
  22.         final int right = mRight;
  23.         final int left = mLeft;
  24.         final int bottom = mBottom;
  25.         final int top = mTop;
  27.         final Drawables dr = mDrawables;
  28.         if (dr != null) {
  29.             /*
  30.              * Compound, not extended, because the icon is not clipped
  31.              * if the text height is smaller.
  32. 。。。
  33. }

　　2、SurfaceView重写了dispatchDraw()函数：

  1.     @Override
  2.     protected void dispatchDraw(Canvas canvas) {
  3.         if (mWindowType != WindowManager.LayoutParams.TYPE_APPLICATION_PANEL) {
  4.             // if SKIP_DRAW is cleared, draw() has already punched a hole
  5.             if ((mPrivateFlags & SKIP_DRAW) == SKIP_DRAW) {
  6.                 // punch a whole in the view-hierarchy below us
  7.                 canvas.drawColor(0, PorterDuff.Mode.CLEAR);
  8.             }
  9.         }
  10.         super.dispatchDraw(canvas);
  11.     }

　　3、ViewGroup类重写了dispatchDraw()函数：

  1.  @Override
  2.     protected void dispatchDraw(Canvas canvas) {
  3.         final int count = mChildrenCount;
  4.         final View[] children = mChildren;
  5.         int flags = mGroupFlags;
  7.         if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {
  8.             final boolean cache = (mGroupFlags & FLAG_ANIMATION_CACHE) == FLAG_ANIMATION_CACHE;
  10.             final boolean buildCache = !isHardwareAccelerated();
  11.             for (int i = 0; i < count; i++) {
  12.                 final View child = children[i];
  13.                 if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
  14.                     final LayoutParams params = child.getLayoutParams();
  15.                     attachLayoutAnimationParameters(child, params, i, count);
  16.                     bindLayoutAnimation(child);
  17.                     if (cache) {
  18.                         child.setDrawingCacheEnabled(true);
  19.                         if (buildCache) {                        
  20.                             child.buildDrawingCache(true);
  21.                         }
  22.                     }
  23.                 }
  24.             }
  26.             final LayoutAnimationController controller = mLayoutAnimationController;
  27.             if (controller.willOverlap()) {
  28.                 mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;
  29.             }
  31.             controller.start();
  33.             mGroupFlags &= ~FLAG_RUN_ANIMATION;
  34.             mGroupFlags &= ~FLAG_ANIMATION_DONE;
  36.             if (cache) {
  37.                 mGroupFlags |= FLAG_CHILDREN_DRAWN_WITH_CACHE;
  38.             }
  40.             if (mAnimationListener != null) {
  41.                 mAnimationListener.onAnimationStart(controller.getAnimation());
  42.             }
  43.         }
  45.         int saveCount = 0;
  46.         final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK;
  47.         if (clipToPadding) {
  48.             saveCount = canvas.save();
  49.             canvas.clipRect(mScrollX + mPaddingLeft, mScrollY + mPaddingTop,
  50.                     mScrollX + mRight - mLeft - mPaddingRight,
  51.                     mScrollY + mBottom - mTop - mPaddingBottom);
  53.         }
  55.         // We will draw our child\'s animation, let\'s reset the flag
  56.         mPrivateFlags &= ~DRAW_ANIMATION;
  57.         mGroupFlags &= ~FLAG_INVALIDATE_REQUIRED;
  59.         boolean more = false;
  60.         final long drawingTime = getDrawingTime();
  62.         if ((flags & FLAG_USE_CHILD_DRAWING_ORDER) == 0) {
  63.             for (int i = 0; i < count; i++) {
  64.                 final View child = children[i];
  65.                 if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
  66.                     more |= drawChild(canvas, child, drawingTime);
  67.                 }
  68.             }
  69.         } else {
  70.             for (int i = 0; i < count; i++) {
  71.                 final View child = children[getChildDrawingOrder(count, i)];
  72.                 if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
  73.                     more |= drawChild(canvas, child, drawingTime);
  74.                 }
  75.             }
  76.         }
  78.         // Draw any disappearing views that have animations
  79.         if (mDisappearingChildren != null) {
  80.             final ArrayList<View> disappearingChildren = mDisappearingChildren;
  81.             final int disappearingCount = disappearingChildren.size() - 1;
  82.             // Go backwards -- we may delete as animations finish
  83.             for (int i = disappearingCount; i >= 0; i--) {
  84.                 final View child = disappearingChildren.get(i);
  85.                 more |= drawChild(canvas, child, drawingTime);
  86.             }
  87.         }
  89.         if (clipToPadding) {
  90.             canvas.restoreToCount(saveCount);
  91.         }
  93.         // mGroupFlags might have been updated by drawChild()
  94.         flags = mGroupFlags;
  96.         if ((flags & FLAG_INVALIDATE_REQUIRED) == FLAG_INVALIDATE_REQUIRED) {
  97.             invalidate(true);
  98.         }
  100.         if ((flags & FLAG_ANIMATION_DONE) == 0 && (flags & FLAG_NOTIFY_ANIMATION_LISTENER) == 0 &&
  101.                 mLayoutAnimationController.isDone() && !more) {
  102.             // We want to erase the drawing cache and notify the listener after the
  103.             // next frame is drawn because one extra invalidate() is caused by
  104.             // drawChild() after the animation is over
  105.             mGroupFlags |= FLAG_NOTIFY_ANIMATION_LISTENER;
  106.             final Runnable end = new Runnable() {
  107.                public void run() {
  108.                    notifyAnimationListener();
  109.                }
  110.             };
  111.             post(end);
  112.         }
  113.     }

　　总之，首先在View.Draw()“模板方法”函数将设计界面分成6个步骤，合并不变部分，然后将可变部分提取、独立出来，让子类TextView等扩展修改成自己“独特”的界面效果。在我们自己的实际开发中，如果要设计自己的界面效果大部分的时候，我们都是覆盖重写onDraw(Canvas canvas)函数。

　　此外：根据模版方法中的方法，可以分为两大类：模版方法（Template Method）和基本方法（Primitive Method)。其中我们这里的例子Draw()函数就是一个“模板方法”。

而基本方法又可以分为三种：抽象方法（Abstract Method）、具体方法（Concrete Method）和钩子方法（Hook Method）：

抽象方法：一个抽象方法由抽象类声明，由具体子类实现。

具体方法：一个具体方法由抽象类声明并实现，而子类并不实现或置换。

钩子方法：一个钩子方法由抽象类声明并实现，而子类会加以扩展。我们这里的onDraw()函数就是一个钩子方法。

　　最后记住：

　　本人能力和时间有限（缺少“模式使用”内容，以后会添加），写的很粗糙，恭候大家的批评指正，谢谢~~~

版权声明：本文为yemeishu原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/yemeishu/archive/2013/01/20/2868671.html