简单就是美——由模式谈面向对象的基本原则之单一职责原则

                                                                        简单就是美
                                         ——由模式谈面向对象的基本原则之单一职责原则


     所谓单一职责原则,就是就一个类而言,应该仅有一个引起它的变化的原因。换句话说,一个类的功能要单一,只做与它相关的事情。
     这个原则是最简单、最容易理解,却是最不容易做到的事情。这个原则的道理谁都理解,可是在实践中呢?
     我们来看一个例子:
 if(action.equals("load")&&tab.equals("1")){
          request.setAttribute("tabId",tab);
          form.set("tabId",tab);
           speciManager.loadIncrement(actionForm, request, tab);
 }
 if(action.equals("Save")&&tab.equals("1")){
 System.out.println("inter increment save action");
 ……
 request.setAttribute("tabId",tab);
 }
 if(action.equals("load")&&tab.equals("2")){
          request.setAttribute("tabId",tab);
          form.set("tabId",tab);
           speciManager.loadMeasureMent(actionForm, request, tab);
 }
 if(action.equals("Save")&&tab.equals("2")){
    ……
          System.out.println("inter increment save action");
 speciManager.loadIncrement(actionForm, request, tab);
          form.set("tabId",tab);
          request.setAttribute("tabId",tab);
           
 }
     一看就知道这个类做了太多的工作,它既要load一个tab为1的页面和一个tab为2的页面;又要save一个tab为1页面和一个tab为2的页面。这个类的代码我只截取了里面很少的一部分,绝大部分的代码我都省略掉了。这段代码写到最后是越来越混乱,直到最后失败。
     对照着这个例子,我们再来分析一下为什么要遵守单一职责愿则:
    第一、有助于我们分析和编码的思路的清晰。当你的代码里有了三层或以上的if语句或for语句的嵌套的时候,你不要跟我说,你已经把问题分析得很清楚了。多层嵌套的if或for语句只能说明你还没有把问题分析清楚。
    第二、使我们的编码、测试和维护变得简单。
    第三、将一个个复杂的问题简单化以后,易于代码的重用。当你的代码的多个功能搅和在一起的时候,你是没办法考虑代码的重用的,因为你的每一处代码都有不同。
    第四、易于系统的扩展。
    好了,在这里一二三四的列举单一职责的原则不管用,我们需要看看实际的效果才好。现在我们就来看看模式是怎么来遵守这一原则的:
     首先,我们来看简单工厂模式。工厂类只有一个功能,就是产生一个个的对象产品。就这么一个简单的功能,但如果我们不把它拿出来,在客户端就会出现这样的代码:
 if(type.equals(“apple”))
 {
   Apple apple = new Apple();
   ……
 }
 else if(type.equals(“orange”))
 {
   Orange orange = new Orange(); 
   ……
 }
 else if(type.equals(“Banana”))
 {
   Banana banana = new Banana();
   ……
 }
     有了工厂,我们的客户端就变成这样:
 Fruit fruit = Factory.getInstance(type);
 ……
     我们的客户端调用起来多么的简单,而且系统扩展起来也与客户端无关。
     我们再来看模板方法模式。
 public abstract class Template {
  
  public void totalAction()
   {
    commonAction();
    differentAction();
   }
   private void commonAction()
   {
    //......
   }
   public abstract void differentAction();
 
 }
     这是一个模板类,它只做了一件事,就是所有子类的共同行为;然后去由它的子类单独完成自己的不同的行为。
     这样的蓄意让类的职责单一,拥有的好处是:第一、所有的子类的共同行为,只在模板类里构造一次,实现了代码的重用。第二、将各子类不同的行为分配到各子类里去,使得子类极为简单,易于实现。
     命令模式和策略模式的原理都相同,命令模式是对行为的封装,而策略模式是对算法的封装。两者都是要把相同的关注点和对他们的调用分离开,如命令模式是将行为和对它们的调用分离开,而策略模式是将算法和对它们的调用分离开。这里我们只以命令模式来说明问题。
 If(condition1)
 {
   //condition1下的行为
   doThing1();
 }
 else if(condition2)
 {
   //condition2下的行为
   doThing2();
 }
 else if(condition3)
 {
   //condition3下的行为
   doThing3();
 }
 ……
     命令模式可以方便的对上面的代码进行优化:
 public interface Common
 {
   public void doThing();
 }
 public class Common1 implements Common
 {
   public void doThing()
   {
    //condition1下的行为
    doThing1();
   }
 }
 public class Common2 implements Common
 {
   public void doThing()
   {
    //condition2下的行为
    doThing2();
   }
 }
 public class Common13implements Common
 {
   public void doThing()
   {
    //condition3下的行为
    doThing3();
   }
 
 }
 
     客户端:
 Common common;
 If(condition1) common = new Common1();
 else if(condition2) common = new Common2();
 else if(condition3) common = new Common3();
 common.doThing();
     命令模式通过将行为从调用者那里分离出来,达到了下面几个目的:第一,分离关注,对各个行为进行单独的关注,减少错误的出现。不管是对行为类还是它的调用者,都变得简单。第二,行为类通过对接口的实现,使得它们的调用者可以对它们进行动态绑定,增加了程序的灵活性和扩展性。
     代理模式将一个类的核心功能和它的附加功能区别开来,分别放在不同的类里面,从而使每一个类的功能更加单一。
 Public interface ProxyInterface
 {
   public void doing();
 }
 public class MainClass implements ProxyInterface
 {
   public void doing()
   {
    //core function
    ……
 }
 }
 public class ProxyClass implements ProxyInterface
 {
  private ProxyInterface core = new MainClass();
  public void doing()
  {
   //appending to do
   ……
   //main function
   core.doing();
 }
 }
     我们可以看到,通过代理模式,上面的MainClass类用来实现核心功能,而ProxyClass类用来实现附加功能,这样使得两个类的功能都非常简单,易于实现。
     总之,单一职责原则是一个既简单又实用的原则。我们遵守了这一原则,可能会多写一些类和代码,但磨刀不误砍柴工。该原则既有利于我们编码思路的清晰,又大大增强了代码的可维护性和扩展性。
     还等什么呢?

阅读更多
个人分类: 面向对象
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭