java程序设计_单一工作原则

单一工作原则

定义：

        一个类只能负责一项工作

发生的问题:

类A负责不同的工作：工作W1,工作W2.当由于工作W1需要发生修改而需要修改类A时，有可能会导致原本进行正常的工作W2可能发生故障。

解决方法：

   实行单一工作原则，分别建立两个类A1，A2。这样让A1负责W1的功能，A2负责W2的功能。这样，修改A1就不会修改W2的功能了，同理修改A2就不会修改W1的功能。

  

   说到单一工作原则，很多人不屑一顾，因为它原理太简单了。稍有经验的程序员没有学习过设计模式，没有听说单一工作原则，但是在实际开发过程中自觉就实行运用这一原则了，因为这是常识，因为在开发过程，谁都不希望因为修改一个类而导致其他功能发生故障。而避免这一现象的发生，采用单一工作原则是不错的选择。

   

比如

 package text;


public class design {
public static void main(String[] args) {
      living live=new living();
      live.speak("老人");
      live.speak("儿童");
      live.speak("青年");
}
}


class living{
public void speak(String who) {
     System.out.println(who+"会说话！！");
}


}

 

 

 

 

运行结果:

   老人会说话！！

儿童会说话！！

青年会说话！！

 

 

程序运行后，发现问题了，并不是所有的生命都会说话，比如动物就不会说话，哑巴也不会说话。如果再细分的话，可以将living类分为normalpeople，animal和dumb。

package text2;

 

public classdesign {

 publicstaticvoidmain(String[] args) {

   livingnormal=newliving();

   normal.speak("儿童");

   normal.speak("老人");

   normal.speak("青年");

   dumpd=newdump();

   d.speak("哑巴");

   Animala=newAnimal();

   a.speak("小鸟");

 }  

}

class living{

   public void speak(String who)

   {

       System.out.println(who+"会说话！！");    

   }

  

}

class dump{

   public void speak(String who)

   {

      System.out.println(who+"是不会说话的!");

     

   }

  

}

class Animal{

   public void speak(String who)

   {

      System.out.println(who+"不会说话的!");

   }

  

}

运行结果

儿童会说话！！

老人会说话！！

青年会说话！！

哑巴是不会说话的!

小鸟不会说话的!

 

 

我们看到修改后的花销是大的,除了living类修改了,而且还增加了类,我们直接可以修改living类,虽然违背了单一工作的原则,但是花销变小了.

 代码如下:

package text3;

 

public classdesign {

   publicstaticvoidmain(String[] args) {

     living l=new living();

     l.speak("老人");

     l.speak("儿童");

     l.speak("青年");

     l.speak("哑巴");

       l.speak("小鸟");

   }

 

}

class  living{

   public void speak(String who)

   {

      if("老人".equals(who) ||"儿童".equals(who) ||"青年".equals(who)){

        System.out.println(who+"会说话!!");

      }else if("哑巴".equals(who)){

        System.out.println(who+"不会说话!");

      }else if("小鸟".equals(who)){

        System.out.println(who+"不会说话!");

      }

       

   }

  

}

运行结果

老人会说话!!

儿童会说话!!

青年会说话!!

哑巴不会说话!

小鸟不会说话!

 

 

 

可以看到,这种修改方式要简单的多,但是存在隐患时:有一天需要将小鸟分类麻雀和鹰 .则需要修改living类中speak方法啊.则对原有代码修改会对调用“老人”,”青年”,”儿童”等相关功能带来风险.也许有一天代码量增多,运行结果正常人中的老人不会说话了!! 这种修改时简单,但是违背了单一工作原则,到后来的隐患是大的.

package text4;

 

public classdesign {

   publicstaticvoidmain(String[] args) {

     

     Living l=new Living();

     l.speak("老人");

     l.speak("儿童");

     l.speak("青年");

     l.noSpeak("哑巴");

     l.noSpeak("小鸟");

    

   }

}

class Living{

   public void speak(String who)

   {

      System.out.println(who+"是会说话的");

   }

   public void noSpeak(String who)

   {

      System.out.println(who+"不会说话的");

   }

  

}

 

运行结果

老人是会说话的

儿童是会说话的

青年是会说话的

哑巴不会说话的

小鸟不会说话的

 

 

 

可以看到,这种修改没有改动原来类中的方法,而是在类中新增加一个方法,这样虽然说违背了单一工作方式,但在方法级别上是符合单一工作原则的.因为它没有修改原来的方法的代码

这三种方法各有利弊,那么在实际的开发中,采取哪种方法呢 ?这个要根据实际的开发需求,

  只要逻辑简单,才可以代码级别上违背单一工作原则,只有类中的方法足够多,才可以在方法级别上违背单一工作原则

  单一工作原则的优点:

 

1 可以降低复杂度,一个类只负责一个功能,其逻辑肯定比负责多个功能简单的多.

2提高性的可读性,提高系统的可维护性.

3修改代码引起的风险降低.

 

需要说明的是单一工作原则不只是面向对象编程中所特有的.只要是模块化程序设计,都适用于单一工作原则.