注：原发表在Hadoop技术论坛

在进行OO时，很容易做到结构统一，这个也容易理解，如下：

 
  
  1. class Parent  
  2.  
  3. {  
  4.  
  5. public:  
  6.  
  7.     virtual void hello() = 0;  
  8.  
  9. };  
  10.  
  11.  
  12.  
  13. class Child1: public Parent  
  14.  
  15. {  
  16.  
  17. private:  
  18.  
  19.     virtual void hello() {  
  20.  
  21.         printf("Child1\n"); // 当运行到这里时，调用栈显得和Parent毫无关系  
  22.  
  23.     }  
  24.  
  25. };  
  26.  
  27.  
  28.  
  29. class Child2: public Parent  
  30.  
  31. {  
  32.  
  33. private:  
  34.  
  35.     virtual void hello() {  
  36.  
  37.         printf("Child2\n"); // 当运行到这里时，调用栈显得和Parent毫无关系  
  38.  
  39.     }  
  40.  
  41. };  
  42.  
  43.  
  44.  
  45. int main() {  
  46.  
  47.     Parent* p = new Child2;  
  48.  
  49.     p->hello();  
  50.  
  51.     return 0;  
  52.  
  53. } 
 
  
在上面的设计中，结构是统一的，对外展现的是Parent，但是行为并非统一，当使用gdb打印调用栈时，是看不到Parent的影子的，当系统庞大后，对新人来理解系统会增加一些阻力。如何解决这个问题了？通过统一行为，就可以将这个清晰化。方法是：在Parent中增加一个非抽象方法，由这个新增加的非抽象方法来调用hello，这样在调用栈中就可以见到Parent的身影了，调用栈显示有层次感，有助于理解系统。
 
  
 
  
  1. class Parent  
  2.  
  3. {  
  4.  
  5. public:  
  6.  
  7.     /* virtual */ void hello() {  
  8.  
  9.         do_hello();  
  10.  
  11.     }  
  12.  
  13.       
  14.  
  15. private:  
  16.  
  17.     virtual void do_hello() = 0;  
  18.  
  19. };  
  20.  
  21.  
  22.  
  23. class Child1: public Parent  
  24.  
  25. {  
  26.  
  27. private:  
  28.  
  29.     virtual void do_hello() {  
  30.  
  31.         printf("Child1\n"); // 当运行到这里时，调用栈中会包含Parent -> Child1信息  
  32.  
  33.     }  
  34.  
  35. };  
  36.  
  37.  
  38.  
  39. class Child2: public Parent  
  40.  
  41. {  
  42.  
  43. private:  
  44.  
  45.     virtual void do_hello() {  
  46.  
  47.         printf("Child2\n"); // 当运行到这里时，调用栈中会包含Parent -> Child2信息  
  48.  
  49.     }  
  50.  
  51. };  
  52.  
  53.  
  54.  
  55. int main() {  
  56.  
  57.     Parent* p = new Child2;  
  58.  
  59.     p->hello();  
  60.  
  61.     return 0;  
  62.  
  63. }  
 
  
上面的修改，简单来看，除了增加代码和调用次数的缺点外，没有带来任何好处，但软件开发实则为一项工程性的工作，需要考虑到整体性和外部因素等，个人觉得这样做很值得，特别是当你使用UML作设计时，时序图将显得更有条理性。