Android design mode Series-Template method mode

The template method, and the singleton mode is the simplest of the two modes that I think Gof 23.
But I am personally very much in the classical thinking of template methods, although the template method is not recommended in the case of large logarithm, but this method of calling subclasses by the parent class, using inheritance to change part of the algorithm is a basic understanding of object-oriented.
For example, the father has a lot of ideals, medicine to save people, but the father of medicine, can only rely on son, son grew up following father ambition, Spring Breeze, Miaoshouhuichun, realize the father's ideals, son do things early in the birth of the set up, is the father before the long-established template.
Recognizing the idea of a template approach, the parent class can make the unknown subclass do something that it might not do well or simply do, and help frame learning.
In this paper, the draw method in view is used as an example to expand the analysis.
The template method, Templatemethod, is a pattern of learning this pattern that will have a long-term impact on you.

1. Intentions
The skeleton of an algorithm in an operation is defined, and some steps are deferred to subclasses, and the template method allows subclasses to redefine some specific steps of the algorithm without altering the structure of an algorithm.
Hot words: Skeleton step structure delay to subclass

2. Structure

Defines several steps, such as three-way, to perform these steps in a certain structure order in the template method. A method of the parent class can have a default implementation, or it can be an empty implementation, known as a hook operation.
In combination with the actual situation, we draw a few steps related to the Draw method in view as follows:

Learning Template method is very helpful for us to understand the framework's base class implementation, life cycle and process control, and I think it is a pattern that must be mastered.

3. Code

2. Public class view{
4. /**  
6. * Hook operation, empty implementation
8. */
10. protected void OnDraw (canvas canvas) {
12. }
16. /**  
18. * Hook operation, empty implementation
20. */
22. protected void Dispatchdraw (canvas canvas) {
24. }
28. //Algorithm skeleton
30. public void Draw (canvas canvas) {
32. if (!verticaledges &&!horizontaledges) {
34. //Step 1
36. if (!dirtyopaque) OnDraw (canvas);
40. //Step 2
42. Dispatchdraw (canvas);
46. //Step 3
48. Ondrawscrollbars (canvas);
52. return;
54. }
56. }
58. //... ...  
60. }

Let's look at the implementation of the system component TextView:

1. Public class textview{
2. @Override
3. protected void OnDraw (canvas canvas) {
4. //A large number of custom implementation codes
5. }
6. }

If we customize the view, we can also generally rewrite the OnDraw method:

2. Public class MyView extends View {
6. Public MyView (context context) {
8. super (context);
10. }
14. @Override
16. protected void OnDraw (canvas canvas) {
18. Super.ondraw (canvas);
20. }
24. @Override
26. protected void Dispatchdraw (canvas canvas) {
28. Super.dispatchdraw (canvas);
30. }
34. }

4. Effects
(1). The template method is a basic technique for code reuse. They are particularly important in class libraries, which extract public behavior from the class library.
(2). The template method leads to a directional control structure, the "Hollywood Rule": "Don ' t call Me,i will calls you.", that is, a parent class invokes the operation of a subclass, not the other way around.
(3). The type of the template invoke operation has specific operations, specific abstracclass operations, primitive operations, factory methods, hook operations. The primitive operation is less defined.
(4). The name of these redefined actions in Android likes to prefix the method with a suffix on.
(5). The template method uses inheritance to change part of the algorithm. The policy pattern uses delegates to change the entire algorithm.

Android design mode Series-Template method mode