高质量软件开发人员的五大习惯(好)

最新推荐文章于 2024-10-31 13:48:35 发布
置顶 最新推荐文章于 2024-10-31 13:48:35 发布
阅读量686 收藏 1
点赞数 1
分类专栏： 程序人生 Thinking 文章标签： string 测试 methods 数据库 工作 constructor

 那些在团队环境下有能力开发和维护高质量软件的开发人员在今天的技术驱动的经济里有着巨大的需求。工作在团队环境下的开发人员所面临的排在第一位的挑战是阅读和理解其他开发人员的软件。本文试图帮助软件开发团队来克服这个挑战。
本文举出了使得软件开发团队更加有效并且更加高质量的五大习惯。首先，本文描述了这样一些商业团队给于软件开发团队以及他们所开发的软件的要求。接着，本文解释了状态更换逻辑和行为逻辑之间的重要的区别。最后，本文将要示例五个使用客户帐户情形作为案例研究的习惯。

业务对开发人员提出的要求
业务团队的工作是要决定往软件里加入什么新的功能，同时确保新的功能对业务来说是最有利的。在这里，“新的功能”是指一个新的产品或者对一个已存在产品的额外的功能提升。换句话说，业务团队决定了哪些新的特性会帮助软件产品赚更多的钱。决定上那些新的功能的关键因素是实现这些新的功能所需要的成本。如果实现的成本超过了潜在的价值，那么新的功能将不会实现在软件产品里。
业务团队要求软件开发团队以最低的成本开发新的功能。它同时也要求软件开发团队在给产品增加新的功能的时候，不会随着时间的过去而增加新的成本。而且，每一次业务团队请求开发新的功能，他们要求增加新的功能的同时不会丢失旧的功能。随着时间的过去，软件将产生足够多的功能，业务团队将要求使用文档来描述软件提供的当前功能。然后，业务团队将使用这些文档来决定下一个新的功能。
软件开发团队通过开发“易于理解”的软件来最佳的满足这些要求。“难于理解”的软件将导致整个开发过程的无效。这些无效增加了软件开发的成本，并且将导致意想不到的已经实现的功能的丢失。增加了开发人员的开发时间，和错误的软件文档的交付。通过改变业务团队的需求，这些无效能够被减少，将复杂的转化为简单的、“易于理解”的软件。

引入关键概念：状态和行为
开发易于理解的软件开始于创建一个拥有状态和行为的对象。“状态”是指在方法调用之间保持的对象的数据。一个Java对象能够在它的实例变量中临时的保持它的状态，或者通过保存到一个永久的数据源的方式保持。一个永久的数据源可以是数据库或者Web服务。“状态改变的方法”典型的是通过获取数据或从远程数据源取得和放置数据的方式管理一个对象的数据。“行为”是一个对象在“状态”的基础上回答问题的能力。“行为方法”回答问题不用改变状态，并且在应用中通常指的是业务逻辑。

案例研究：CustomerAccount对象
下面的ICustomerAccount接口定义了一个对象必须实现的用来管理用户帐户的方法。它定义了产生一个活跃账户的能力，载入一个已经存在客户账户状态、校验潜在用户的用户名和密码、校验一个账户是否为活跃账户能够购买产品等功能。

查看 复制到剪切板 打印
  1.     
  2. public interface ICustomerAccount {   
  3.   // State-changing methods   
  4.   public void createNewActiveAccount() throws CustomerAccountsSystemOutageException;   
  5.   public void loadAccountStatus() throws CustomerAccountsSystemOutageException;   
  6.   // Behavior methods   
  7.   public boolean isRequestedUsernameValid();   
  8.   public boolean isRequestedPasswordValid();   
  9.   public boolean isActiveForPurchasing();   
  10.   public String getPostLogonMessage();   
  11. }  
 
public interface ICustomerAccount {
  // State-changing methods
  public void createNewActiveAccount() throws CustomerAccountsSystemOutageException;
  public void loadAccountStatus() throws CustomerAccountsSystemOutageException;
  // Behavior methods
  public boolean isRequestedUsernameValid();
  public boolean isRequestedPasswordValid();
  public boolean isActiveForPurchasing();
  public String getPostLogonMessage();
}


习惯1：构造器实现最少的工作
第一个习惯是一个对象的构造器只能实现尽量少的工作。理想的，构造器仅仅是通过它的参数载入数据到它的实例变量。如下所是，作为一个例子，开发一个只实现最少功能的构造器使得这个对象易于被使用和理解。因为构造器只用来实现简单任务，将数据载入到对象的实例变量。

查看 复制到剪切板 打印
  1.     
  2. public class CustomerAccount implements ICustomerAccount {   
  3.   // Instance variables.   
  4.   private String username;   
  5.   private String password;   
  6.   protected String accountStatus;   
  7.   // Constructor that performs minimal work.   
  8.   public CustomerAccount(String username, String password) {   
  9.     this.password = password;   
  10.     this.username = username;   
  11.   }   
  12. }  
 
public class CustomerAccount implements ICustomerAccount {
  // Instance variables.
  private String username;
  private String password;
  protected String accountStatus;
  // Constructor that performs minimal work.
  public CustomerAccount(String username, String password) {
    this.password = password;
    this.username = username;
  }
}


构造器被用来产生对象的实例。构造器的名字永远和对象的名字相同（译者：这里的“对象”应该是“类”的意思，以下相同）。既然构造器的名字是无法改变的，它的名字不能表达出它要行使的其他功能。因而，它最好履行尽量少的工作。另一方面，状态的改变和行为方法的名称使用描述性的名称来表达它们更加复杂的意图，就像在“习惯2：方法名要清晰地表达方法的意图”描述的那样。下面的例子将要表明：软件的可读性很高，因为构造器仅仅产生对象的实例，而让行为和状态改变的方法去剩下的事情。
注：在例子中使用“…”表示它们在现实案例中是必须的，但是它们与例子的意图无关

查看 复制到剪切板 打印
  1. String username = "robertmiller";   
  2. String password = "java.net";   
  3. ICustomerAccount ca = new CustomerAccount(username, password);   
  4. if (ca.isRequestedUsernameValid() && ca.isRequestedPasswordValid()) {   
  5.   // ...   
  6.   ca.createNewActiveAccount();   
  7.   // ...   
  8. }  
    String username = "robertmiller";
    String password = "java.net";
    ICustomerAccount ca = new CustomerAccount(username, password);
    if (ca.isRequestedUsernameValid() && ca.isRequestedPasswordValid()) {
      // ...
      ca.createNewActiveAccount();
      // ...
    }



另一方面，那些构造器的功能超过载入实例变量的对象是难于理解的，并且容易被误用，因为它们的名称没有传递它们的意图。例如，下面的这个构造器额外的调用一个方法用来远程调用数据库或者Web服务，目的是为了事先载入一个账户的状态。

查看 复制到剪切板 打印
  1. // Constructor that performs too much work!   
  2. public CustomerAccount(String username, String password) throws CustomerAccountsSystemOutageException {   
  3.   this.password = password;   
  4.   this.username = username;   
  5.   this.loadAccountStatus();   
  6.   // unnecessary work.   
  7. }   
  8. // Remote call to the database or web service.   
  9. public void loadAccountStatus() throws CustomerAccountsSystemOutageException { // ...   
  10. }  
 
  // Constructor that performs too much work!
  public CustomerAccount(String username, String password) throws CustomerAccountsSystemOutageException {
    this.password = password;
    this.username = username;
    this.loadAccountStatus();
    // unnecessary work.
  }
  // Remote call to the database or web service.
  public void loadAccountStatus() throws CustomerAccountsSystemOutageException { // ...
  }



一个开发人员使用了这个构造器，但他没有意识到构造器已经做了一个远程调用，因而做了两个远程调用。

查看 复制到剪切板 打印
  1. String username = "robertmiller";   
  2. String password = "java.net";   
  3. try { // makes a remote call   
  4.   ICustomerAccount ca = new CustomerAccount(username, password);   
  5.   // makes a second remote call   
  6.   ca.loadAccountStatus();   
  7. } catch (CustomerAccountsSystemOutageException e) { // ...   
  8. }  
    String username = "robertmiller";
    String password = "java.net";
    try { // makes a remote call
      ICustomerAccount ca = new CustomerAccount(username, password);
      // makes a second remote call
      ca.loadAccountStatus();
    } catch (CustomerAccountsSystemOutageException e) { // ...
    }



或者一个开发人员重用了这个构造器来校验一个潜在的用户所希望的用户名和密码，那么他就被迫作出了一个不需要的远程调用，因为这些方法（isRequestedUsernameValid(), isRequestedPasswordValid()）不需要账户状态。

查看 复制到剪切板 打印
  1. String username = "robertmiller";   
  2. String password = "java.net";   
  3. try { // makes unnecessary remote call   
  4.   ICustomerAccount ca = new CustomerAccount(username, password);   
  5.   if (ca.isRequestedUsernameValid() && ca.isRequestedPasswordValid()) { // ...   
  6.     ca.createNewActiveAccount(); // ...   
  7.   }   
  8. } catch (CustomerAccountsSystemOutageException e) { // ...   
  9. }  
    String username = "robertmiller";
    String password = "java.net";
    try { // makes unnecessary remote call
      ICustomerAccount ca = new CustomerAccount(username, password);
      if (ca.isRequestedUsernameValid() && ca.isRequestedPasswordValid()) { // ...
        ca.createNewActiveAccount(); // ...
      }
    } catch (CustomerAccountsSystemOutageException e) { // ...
    }



习惯2：方法名清晰的表达方法的意图
第二个习惯是，通过它们的方法名，所有的方法必须清晰的传递它们的意图。例如，isRequestedUsernameValid()让开发人员知道这个方法确定请求的用户名是否是合法的。与之相对照的是，isGoodUser()可能有好几种用途：它能决定一个用户的账户是否是活跃的，决定是否请求的用户名或密码是正确的，或者决定用户是否是一个好人。既然这个方法名的描述性不强，那么它对于其他开发人员来说很难确定它的意图是什么。简短地说，一个方法名使用长的和描述性的比使用短的和毫无意义的好。
长的、描述性的方法名帮助开发团队迅速的理解他们的软件的意图和功能。此外，应用这种技术到测试方法的名称，使得测试表达了软件现有的需求。例如，软件要求检验请求的用户名和密码是不同的。使用方法名称：testRequestedPasswordIsNotValidBecauseItMustBeDifferentThanTheUsername()就能传递测试的这个意图，因此为表达了软件需求的意图。

查看 复制到剪切板 打印
  1. public class CustomerAccountTest extends TestCase{    
  2.   public void testRequestedPasswordIsNotValid    BecauseItMustBeDifferentThanTheUsername(){    
  3.     String username = "robertmiller";       
  4.     String password = "robertmiller";      
  5.     ICustomerAccount ca = new CustomerAccount(username, password);    
  6.     assertFalse(ca.isRequestedPasswordValid());    
  7.   }   
  8. }   
public class CustomerAccountTest extends TestCase{ 
  public void testRequestedPasswordIsNotValid    BecauseItMustBeDifferentThanTheUsername(){ 
    String username = "robertmiller";    
    String password = "robertmiller";   
    ICustomerAccount ca = new CustomerAccount(username, password); 
    assertFalse(ca.isRequestedPasswordValid()); 
  }
}



这个测试方法可以很简单的被命名为testRequestedPasswordIsNotValid()，或者更差的testBadPassword()，这两个名称都使得它很难确定测试的意图。不清楚地或者说含糊不清的名称将导致效率的损失。效率的损失导致需要增加额外的时间来理解测试、创建不需要的方法或属性、重复的或者冲突的测试、或者销毁了对象已经测试过的已经存在的功能。
最后，描述性的方法名减少了对于常规文档或者Javadoc注释的需要。

习惯3：一个对象执行功能集中的服务集
第三个习惯是，软件的每一个对象都集中的执行一个小的、独一无二的服务集。执行小基数工作的对象容易阅读，容易正确使用，因为只有少量的代码需要理解。此外，软件的每一个对象都必须执行独一无二的服务集，因为重复的逻辑浪费开发人员的时间，增加维护的成本。设想，未来，业务团队要求升级isRequestedPasswordValid()的逻辑，如果两个不同的对象都有执行相同动作的类似方法，在这种情况下，软件开发人员将要比升级仅仅一个对象花费更多的时间来升级两个对象。
作为案例学习的示例，CustomerAccount对象的目的是管理一个独立的客户的账户。它首先是创建一个账户，然后是验证账户对于购买商品来说仍然是活跃的。假设在未来，软件需要给那些购买了十件以上商品的客户折扣。创建一个新的接口，ICustomerTransactions，而且对象，CustomerTransactions，来实现这些新的特性。这些都是开发“易于理解”软件需要有目的进行的工作。

查看 复制到剪切板 打印
  1.     
  2. public interface ICustomerTransactions {   
  3.   // State-changing methods   
  4.   public void createPurchaseRecordForProduct(Long productId) throws CustomerTransactionsSystemException;   
  5.   public void loadAllPurchaseRecords() throws CustomerTransactionsSystemException;   
  6.   // Behavior // method   
  7.   public void isCustomerEligibleForDiscount();   
  8. }  
 
public interface ICustomerTransactions {
  // State-changing methods
  public void createPurchaseRecordForProduct(Long productId) throws CustomerTransactionsSystemException;
  public void loadAllPurchaseRecords() throws CustomerTransactionsSystemException;
  // Behavior // method
  public void isCustomerEligibleForDiscount();
}


这个新的对象维护存储客户交易和决定什么时候客户获得他的十件商品者扣的状态变化和行为方法。它应该是易于创建、测试和维护，因为它只有一个简单的、集中的目的。而一个效率低下的方法是将这些新方法加入到已经存在的ICustomerAccount接口和CustomerAccount对象。如下所示：

查看 复制到剪切板 打印
  1.     
  2. public interface ICustomerAccount {   
  3.   // State-changing methods   
  4.   public void createNewActiveAccount() throws CustomerAccountsSystemOutageException;   
  5.   public void loadAccountStatus() throws CustomerAccountsSystemOutageException;   
  6.   public void createPurchaseRecordForProduct(Long productId) throws CustomerAccountsSystemOutageException;   
  7.   public void loadAllPurchaseRecords() throws CustomerAccountsSystemOutageException;   
  8.   // Behavior methods   
  9.   public boolean isRequestedUsernameValid();   
  10.   public boolean isRequestedPasswordValid();   
  11.   public boolean isActiveForPurchasing();   
  12.   public String getPostLogonMessage();   
  13.   public void isCustomerEligibleForDiscount();   
  14. }  
 
public interface ICustomerAccount {
  // State-changing methods
  public void createNewActiveAccount() throws CustomerAccountsSystemOutageException;
  public void loadAccountStatus() throws CustomerAccountsSystemOutageException;
  public void createPurchaseRecordForProduct(Long productId) throws CustomerAccountsSystemOutageException;
  public void loadAllPurchaseRecords() throws CustomerAccountsSystemOutageException;
  // Behavior methods
  public boolean isRequestedUsernameValid();
  public boolean isRequestedPasswordValid();
  public boolean isActiveForPurchasing();
  public String getPostLogonMessage();
  public void isCustomerEligibleForDiscount();
}



就像上面看到的那样，允许对象变成大的责任和目标的仓库将使得它们更加难以阅读，更加容易误解。误解将导致效率的损失，增加业务团队的时间和金钱。简而言之，让对象和它的方法集中的执行小单元的工作更好一些。

习惯4：状态改变方法包含最小限度的行为逻辑
第四个习惯是状态改变方法必须包含最小数量的行为逻辑。混合状态改变逻辑和行为逻辑使得软件理解起来更加的困难，因为它增加了在一个地方发生的工作的数量。状态改变方法通常是用来获取或发送数据到一个远程的数据存储设备，因而容易在产品系统中出现问题。诊断一个状态改变方法的系统问题在远程调用被独立的时候更容易一些，这时候它完全不含有行为逻辑。此外，两者的混合还制约了开发过程。例如，getPostLogonMessage()是一个基于accountStatus的值的行为方法：

查看 复制到剪切板 打印
  1. public String getPostLogonMessage() {   
  2.   if ("A".equals(this.accountStatus)) {   
  3.     return "Your purchasing account is active.";   
  4.   } else if ("E".equals(this.accountStatus)) {   
  5.     return "Your purchasing account has " + "expired due to a lack of activity.";   
  6.   } else {   
  7.     return "Your purchasing account cannot be " + "found, please call customer service " + "for assistance.";   
  8.   }   
  9. }  
  public String getPostLogonMessage() {
    if ("A".equals(this.accountStatus)) {
      return "Your purchasing account is active.";
    } else if ("E".equals(this.accountStatus)) {
      return "Your purchasing account has " + "expired due to a lack of activity.";
    } else {
      return "Your purchasing account cannot be " + "found, please call customer service " + "for assistance.";
    }
  }



loadAccountStatus()是从远程数据存储设备载入accountStatus的值的状态改变方法：

查看 复制到剪切板 打印
  1. public void loadAccountStatus() throws CustomerAccountsSystemOutageException {   
  2.   Connection c = null;   
  3.   try {   
  4.     c = DriverManager.getConnection("databaseUrl", "databaseUser", "databasePassword");   
  5.     PreparedStatement ps = c   
  6.         .prepareStatement("SELECT status FROM customer_account " + "WHERE username = ? AND password = ? ");   
  7.     ps.setString(1, this.username);   
  8.     ps.setString(2, this.password);   
  9.     ResultSet rs = ps.executeQuery();   
  10.     if (rs.next()) {   
  11.       this.accountStatus = rs.getString("status");   
  12.     }   
  13.     rs.close();   
  14.     ps.close();   
  15.     c.close();   
  16.   } catch (SQLException e) {   
  17.     throw new CustomerAccountsSystemOutageException(e);   
  18.   } finally {   
  19.     if (c != null) {   
  20.       try {   
  21.         c.close();   
  22.       } catch (SQLException e) {}   
  23.     }   
  24.   }   
  25. }  
  public void loadAccountStatus() throws CustomerAccountsSystemOutageException {
    Connection c = null;
    try {
      c = DriverManager.getConnection("databaseUrl", "databaseUser", "databasePassword");
      PreparedStatement ps = c
          .prepareStatement("SELECT status FROM customer_account " + "WHERE username = ? AND password = ? ");
      ps.setString(1, this.username);
      ps.setString(2, this.password);
      ResultSet rs = ps.executeQuery();
      if (rs.next()) {
        this.accountStatus = rs.getString("status");
      }
      rs.close();
      ps.close();
      c.close();
    } catch (SQLException e) {
      throw new CustomerAccountsSystemOutageException(e);
    } finally {
      if (c != null) {
        try {
          c.close();
        } catch (SQLException e) {}
      }
    }
  }



单元测试方法getPostLogonMessage()能够通过模仿loadAccountStatus()方法很容易地进行测试，不需要那种通过数据库的远程调用，每一个假设条件就能够被测试到。例如，accountStatus是“E”用来中止，那么getPostLogonMessage()将返回“Your purchasing account has expired due to a lack of activity,”，如下所示：

查看 复制到剪切板 打印
  1. public void testPostLogonMessageWhenStatusIsExpired() {   
  2.   String username = "robertmiller";   
  3.   String password = "java.net";   
  4.   class CustomerAccountMock extends CustomerAccount { // ...   
  5.     public void loadAccountStatus() {   
  6.       this.accountStatus = "E";   
  7.     }   
  8.   }   
  9.   ICustomerAccount ca = new CustomerAccountMock(username, password);   
  10.   try {   
  11.     ca.loadAccountStatus();   
  12.   } catch (CustomerAccountsSystemOutageException e) {   
  13.     fail("" + e);   
  14.   }   
  15.   assertEquals("Your purchasing account has " + "expired due to a lack of activity.", ca.getPostLogonMessage());   
  16. }  
  public void testPostLogonMessageWhenStatusIsExpired() {
    String username = "robertmiller";
    String password = "java.net";
    class CustomerAccountMock extends CustomerAccount { // ...
      public void loadAccountStatus() {
        this.accountStatus = "E";
      }
    }
    ICustomerAccount ca = new CustomerAccountMock(username, password);
    try {
      ca.loadAccountStatus();
    } catch (CustomerAccountsSystemOutageException e) {
      fail("" + e);
    }
    assertEquals("Your purchasing account has " + "expired due to a lack of activity.", ca.getPostLogonMessage());
  }



与之相反的方法是将getPostLogonMessage()的行为逻辑和loadAccountStatus()的状态改变工作放到一个方法里。下面的示例展示了这个错误的做法：

查看 复制到剪切板 打印
  1. public String getPostLogonMessage() {   
  2.   return this.postLogonMessage;   
  3. }   
  4. public void loadAccountStatus() throws CustomerAccountsSystemOutageException {   
  5.   Connection c = null;   
  6.   try {   
  7.     c = DriverManager.getConnection("databaseUrl", "databaseUser", "databasePassword");   
  8.     PreparedStatement ps = c   
  9.         .prepareStatement("SELECT status FROM customer_account " + "WHERE username = ? AND password = ? ");   
  10.     ps.setString(1, this.username);   
  11.     ps.setString(2, this.password);   
  12.     ResultSet rs = ps.executeQuery();   
  13.     if (rs.next()) {   
  14.       this.accountStatus = rs.getString("status");   
  15.     }   
  16.     rs.close();   
  17.     ps.close();   
  18.     c.close();   
  19.   } catch (SQLException e) {   
  20.     throw new CustomerAccountsSystemOutageException(e);   
  21.   } finally {   
  22.     if (c != null) {   
  23.       try {   
  24.         c.close();   
  25.       } catch (SQLException e) {}   
  26.     }   
  27.   }   
  28.   if ("A".equals(this.accountStatus)) {   
  29.     this.postLogonMessage = "Your purchasing account is active.";   
  30.   } else if ("E".equals(this.accountStatus)) {   
  31.     this.postLogonMessage = "Your purchasing account has " + "expired due to a lack of activity.";   
  32.   } else {   
  33.     this.postLogonMessage = "Your purchasing account cannot be " + "found, please call customer service " + "for assistance.";   
  34.   }   
  35. }  
 
  public String getPostLogonMessage() {
    return this.postLogonMessage;
  }
  public void loadAccountStatus() throws CustomerAccountsSystemOutageException {
    Connection c = null;
    try {
      c = DriverManager.getConnection("databaseUrl", "databaseUser", "databasePassword");
      PreparedStatement ps = c
          .prepareStatement("SELECT status FROM customer_account " + "WHERE username = ? AND password = ? ");
      ps.setString(1, this.username);
      ps.setString(2, this.password);
      ResultSet rs = ps.executeQuery();
      if (rs.next()) {
        this.accountStatus = rs.getString("status");
      }
      rs.close();
      ps.close();
      c.close();
    } catch (SQLException e) {
      throw new CustomerAccountsSystemOutageException(e);
    } finally {
      if (c != null) {
        try {
          c.close();
        } catch (SQLException e) {}
      }
    }
    if ("A".equals(this.accountStatus)) {
      this.postLogonMessage = "Your purchasing account is active.";
    } else if ("E".equals(this.accountStatus)) {
      this.postLogonMessage = "Your purchasing account has " + "expired due to a lack of activity.";
    } else {
      this.postLogonMessage = "Your purchasing account cannot be " + "found, please call customer service " + "for assistance.";
    }
  }



在这个实现里，行为方法getPostLogonMessage()没有包含任何的行为逻辑，而是简单的返回实例变量this.postLogonMessage。这个实现存在着三个问题。首先，这个实现使得我们很难理解“post logon message”的逻辑是怎么工作的，因为它被包含在一个执行两个任务的方法里。第二，getPostLogonMessage()的重用是受限制的，因为它永远和loadAccountStatus()相关联。最后，在出现系统问题的情况下，CustomerAccountsSystemOutageException将会被抛出，使得方法在设置this.postLogonMessage的值之前就停止了。这个实现也对测试产生了一个负面的影响，因为测试getPostLogonMessage()逻辑的唯一方法是创建一个CustomerAccount对象，这个对象有一个在数据库里有用户名和密码的用户，而且这个用户的accountStatus被设置为“E”，被用来停止。这将导致为了这个测试必须给数据库做一个远程调用。这使得这个测试运行起来速度慢，而且由于数据库发生的改变将导致测试意想不到的失败。这个测试需要对数据库做一个远程调用，因为loadAccountStatus()方法也包含了行为逻辑，如果行为逻辑被模仿，那么测试测试的是模拟对象的行为，而不是实际对象的行为。

习惯5：行为方法能够在任何条件下被调用
第五个习惯是确保每一个行为方法提供的功能相对于其他的行为方法来说是独立的。换句话说，一个对象的行为方法能够被重复和以任何顺利调用。这个习惯使得对象传递固定的行为。例如，CustomerAccount对象的isActiveForPurchasing()和getPostLogonMessage()行为方法在它们的逻辑里都使用accountStatus的值。每一个方法对于其他的方法来说是功能独立的。例如，一个场景要求isActiveForPurchasing()被调用，接着调用getPostLogonMessage()：

查看 复制到剪切板 打印
  1. ICustomerAccount ca = new CustomerAccount(username, password);   
  2. ca.loadAccountStatus();   
  3. if (ca.isActiveForPurchasing()) { // go to "begin purchasing" display   
  4.   // ..   
  5.   // show post logon message.   
  6.   ca.getPostLogonMessage();   
  7. } else {   
  8.   // go to "activate account" display   
  9.   // ...   
  10.   // show post logon message. ca.getPostLogonMessage();   
  11. }  
    ICustomerAccount ca = new CustomerAccount(username, password);
    ca.loadAccountStatus();
    if (ca.isActiveForPurchasing()) { // go to "begin purchasing" display
      // ..
      // show post logon message.
      ca.getPostLogonMessage();
    } else {
      // go to "activate account" display
      // ...
      // show post logon message. ca.getPostLogonMessage();
    }



另一个场景要求调用getPostLogonMessage()，而不要求调用isActiveForPurchasing()：

查看 复制到剪切板 打印
  1. ICustomerAccount ca = new CustomerAccount(username, password);   
  2. ca.loadAccountStatus();   
  3. // go to "welcome back" display   
  4. // ...   
  5. // show post logon message.ca.getPostLogonMessage();  
    ICustomerAccount ca = new CustomerAccount(username, password);
    ca.loadAccountStatus();
    // go to "welcome back" display
    // ...
    // show post logon message.ca.getPostLogonMessage();



如果getPostLogonMessage()要求isActiveForPurchasing()首先被调用的话，CustomerAccount对象将不支持第二个场景。例如，创建两个方法来使用一个postLogonMessage实例变量，这样，它的值能够在支持场景一的方法中间得到维护，但是在支持场景二的方法中却不能：

查看 复制到剪切板 打印
  1. public boolean isActiveForPurchasing() {   
  2.   boolean returnValue = false;   
  3.   if ("A".equals(this.accountStatus)) {   
  4.     this.postLogonMessage = "Your purchasing account is active.";   
  5.     returnValue = true;   
  6.   } else if ("E".equals(this.accountStatus)) {   
  7.     this.postLogonMessage = "Your purchasing account has " + "expired due to a lack of activity.";   
  8.     returnValue = false;   
  9.   } else {   
  10.     this.postLogonMessage = "Your purchasing account cannot be " + "found, please call customer service " + "for assistance.";   
  11.     returnValue = false;   
  12.   }   
  13.   return returnValue;   
  14. }   
  15. public String getPostLogonMessage() {   
  16.   return this.postLogonMessage;   
  17. }  
 
  public boolean isActiveForPurchasing() {
    boolean returnValue = false;
    if ("A".equals(this.accountStatus)) {
      this.postLogonMessage = "Your purchasing account is active.";
      returnValue = true;
    } else if ("E".equals(this.accountStatus)) {
      this.postLogonMessage = "Your purchasing account has " + "expired due to a lack of activity.";
      returnValue = false;
    } else {
      this.postLogonMessage = "Your purchasing account cannot be " + "found, please call customer service " + "for assistance.";
      returnValue = false;
    }
    return returnValue;
  }
  public String getPostLogonMessage() {
    return this.postLogonMessage;
  }



另一方面，如果两个方法设计为逻辑彼此相互独立，那么它们将支持两个场景。在这个优胜的例子中，postLogonMessage是一个局域变量，由getPostLogonMessage()方法自己创建：

查看 复制到剪切板 打印
  1. public boolean isActiveForPurchasing() {   
  2.   return this.accountStatus != null && this.accountStatus.equals("A");   
  3. }   
  4. public String getPostLogonMessage() {   
  5.   if ("A".equals(this.accountStatus)) {   
  6.     return "Your purchasing account is active.";   
  7.   } else if ("E".equals(this.accountStatus)) {   
  8.     return "Your purchasing account has " + "expired due to a lack of activity.";   
  9.   } else {   
  10.     return "Your purchasing account cannot be " + "found, please call customer service " + "for assistance.";   
  11.   }   
  12. }  
 
  public boolean isActiveForPurchasing() {
    return this.accountStatus != null && this.accountStatus.equals("A");
  }
  public String getPostLogonMessage() {
    if ("A".equals(this.accountStatus)) {
      return "Your purchasing account is active.";
    } else if ("E".equals(this.accountStatus)) {
      return "Your purchasing account has " + "expired due to a lack of activity.";
    } else {
      return "Your purchasing account cannot be " + "found, please call customer service " + "for assistance.";
    }
  }



使得这两个方法彼此独立的一个额外的好处是这些方法容易被理解。例如，isActiveForPurchasing()更加具有可读性，因为它仅仅只回答“is active for purchasing”的问题，而不是相反的它还要设置“post logon message”。另外一个额外的好处是每一个方法都能被独立的测试，这也使得测试容易被理解：

查看 复制到剪切板 打印
  1.     
  2. public class CustomerAccountTest extends TestCase {   
  3.   public void testAccountIsActiveForPurchasing() {   
  4.     String username = "robertmiller";   
  5.     String password = "java.net";   
  6.     class CustomerAccountMock extends CustomerAccount { // ...   
  7.       public void loadAccountStatus() {   
  8.         this.accountStatus = "A";   
  9.       }   
  10.     }   
  11.     ICustomerAccount ca = new CustomerAccountMock(username, password);   
  12.     try {   
  13.       ca.loadAccountStatus();   
  14.     } catch (CustomerAccountsSystemOutageException e) {   
  15.       fail("" + e);   
  16.     }   
  17.     assertTrue(ca.isActiveForPurchasing());   
  18.   }   
  19.   public void testGetPostLogonMessageWhenAccountIsActiveForPurchasing() {   
  20.     String username = "robertmiller";   
  21.     String password = "java.net";   
  22.     class CustomerAccountMock extends CustomerAccount { // ...   
  23.       public void loadAccountStatus() {   
  24.         this.accountStatus = "A";   
  25.       }   
  26.     }   
  27.     ICustomerAccount ca = new CustomerAccountMock(username, password);   
  28.     try {   
  29.       ca.loadAccountStatus();   
  30.     } catch (CustomerAccountsSystemOutageException e) {   
  31.       fail("" + e);   
  32.     }   
  33.     assertEquals("Your purchasing account is active.", ca.getPostLogonMessage());   
  34.   }   
  35. }  
 
public class CustomerAccountTest extends TestCase {
  public void testAccountIsActiveForPurchasing() {
    String username = "robertmiller";
    String password = "java.net";
    class CustomerAccountMock extends CustomerAccount { // ...
      public void loadAccountStatus() {
        this.accountStatus = "A";
      }
    }
    ICustomerAccount ca = new CustomerAccountMock(username, password);
    try {
      ca.loadAccountStatus();
    } catch (CustomerAccountsSystemOutageException e) {
      fail("" + e);
    }
    assertTrue(ca.isActiveForPurchasing());
  }
  public void testGetPostLogonMessageWhenAccountIsActiveForPurchasing() {
    String username = "robertmiller";
    String password = "java.net";
    class CustomerAccountMock extends CustomerAccount { // ...
      public void loadAccountStatus() {
        this.accountStatus = "A";
      }
    }
    ICustomerAccount ca = new CustomerAccountMock(username, password);
    try {
      ca.loadAccountStatus();
    } catch (CustomerAccountsSystemOutageException e) {
      fail("" + e);
    }
    assertEquals("Your purchasing account is active.", ca.getPostLogonMessage());
  }
}



结论
遵从上面的五个习惯将有助于开发团队开发的软件容易被团队的每一个成员阅读、理解和修改。当软件开发团队开发新的功能太快，而不考虑将来，那么他们的软件将增加高额的使用成本。不可避免的，当他们为了在一次的理解和修改软件的时候，他们将得到的是可怕的经历。如果软件很难被理解的话，增加一个新的功能就会变得非常昂贵。然而，当开发团队应用这些好的经验，他们将以最低的成本给业务团队提供一个新的功能

sony315
关注
专栏目录
软件开发中的可持续性工程
AI天才研究院
09-09 1478
软件开发现代化带来了高速发展、成熟应用、大量用户的普及。但同时也引入了新的复杂度，如环境破坏、社会冲突等新挑战。如何提升软件系统的可持续性，是一个复杂且重要的问题。可持续性工程是指通过对软件开发过程和管理流程进行管理、培训、工具开发、改进和维护，确保软件可持续运行、健康成长的工程活动。本文将从以下两个方面阐述可持续性工程的相关知识：第一，如何衡量软件系统的可持续性；第二，如何提升软件系统的可持续性水平。
高质量软件开发人员的五大习惯
软件的信雅达
10-16 9551
                                                 高质量软件开发人员的五大习惯                                                                                     作者：Robert J. Miller                             
成功软件开发者的9种编程习惯
hktl的专栏
03-29 1080
好的原程序做出好的软件　　有些人会想：只要程序运行结果好，就不管原程序编得怎样。但绝对不是这样的。软件不是一次性就作完的，有必要做修改，扩展等管理。所以原程序要尽量作成易看懂，管理方便。　　这样做，第一是为了软件开发者方便，其次还会影响到软件的性能。管理不方便的程序不会作出好的软件。　　希望通过这篇文章能学到好的编程习惯。要理解这文章的内容，你至少要懂得1个开发工具语言。这里举例说明的都是C语言，
优秀软件开发人员的五个好习惯
changjun86的专栏
12-23 744
【转载】优秀软件开发人员的五个好习惯 —— 译自 java.net 原文地址：http://www.blogjava.net/chords/archive/2006/12/14/87591.html Five Habits of Highly Profitable Software Developers by Robert J. Miller 08/24/2006 翻译：Coody Sk8er...
软件开发的良好习惯
czs8585的专栏
11-01 332
1. 不要长时间久坐，不懂的时候可以走动一下，也许会引发你的灵感。 2. 做软件，还有一个很重要的环境：做日志！！！
软件开发工作习惯和经验小谈
weixin_30455661的博客
07-13 95
1. 手机永远保持使用状态；这我是吃过亏的，手机没电或是手机停机，又等人电话，那个急啊，真是有苦难言！而且我感觉你无论做什么行当，只要你不脱离社会，你的手机还是一直用着的好，无论是工作的还是家庭的，电话是必备的！ 2. 做事要准时守信：如果碰到什么事，一但答应了人家，就得守信，若是约了人，就得准时，这是工作的一个基本准则，一次失约就可能失去一个大好机会，乃至大好前程！ ...
提升软件质量：开发人员必备的五大高效习惯
高质量软件开发人员的五大习惯对于提升团队效率和软件质量至关重要。首先，业务团队对软件开发团队提出了明确的要求，包括新功能的引入需具备经济价值，成本效益分析是决策的重要依据。业务团队期望新功能能增加软件...
提升团队效率：高质量软件开发的五大习惯解析
"高质量软件开发人员的五大习惯" 在技术驱动的经济中，能产出和维护高质量软件的开发人员是至关重要的。团队合作时，开发者首要面对的难题是理解和解析同事编写的代码。为了应对这一挑战，文章提出了提高软件开发...
一个优秀程序员的成功之道：15个不可忽视的编程好习惯！！~
zhangmuyan的专栏
09-11 630
这是国外程序员Al katib总结的一些编程习惯。 1. 动手编码之前，你需要对要编码实现的解决方案有一个正式的或粗略的设计。永远不要在没有任何设计的前提下就开始编码，除非所编代码不重要。 2. 优秀的代码文档跟编程语言知识一样重要。在代码源文件中，为每个主要的代码段添加注释，解释代码的基本逻辑。最好注明程序的构建和修改日期，以及修改的原因也是非常有必要的。 3. 维护程序的各个
优秀后端都应该具备的开发好习惯
热门推荐
LoveSummer
10-23 2万+
很多小伙伴，判断一个list}这样写呢，逻辑是没什么问题的。}日常开发中，我们既要会用工具类，更要学会自己去总结工具类。比如去文件处理工具类、日期处理工具类等等。这些都是优秀后端开发的一些好习惯。
五个好习惯成为优秀软件开发人员
congji3817的博客
07-08 172
五个好习惯成为优秀软件开发人员 当今技术引领经济社会,大量的需要能够在团队环境中开发出稳定质量的软件开发人员。在团队开发的环境中，开发者面对的挑战就是读懂别的开发者写的软件。本文将文章尽力帮助软件开发团队来克服这样的困难。 首...
成功软件开发者的9种编程习惯 1
coolstar的调侃
05-23 1018
好的原程序做出好的软件　　有些人会想：只要程序运行结果好，就不管原程序编得怎样。但绝对不是这样的。软件不是一次性就作完的，有必要做修改，扩展等管理。所以原程序要尽量作成易看懂，管理方便。　　这样做，第一是为了软件开发者方便，其次还会影响到软件的性能。管理不方便的程序不会作出好的软件。　　希望通过这篇文章能学到好的编程习惯。要理解这文章的内容，你至少要懂得1个开发工具语言。这里举例说明的都是C语言，
软件开发心得-谈谈软件意识和编程习惯
QQ1130141391的专栏
11-05 1451
1.工程意识
成功软件开发工程师的10个习惯
02-12 466
假设您正在比较两个软件开发人员的简历:Dev A和Dev b。这两个候选人拥有几乎相同的背景和技能:语言、框架、平台、方法、行业等等。从表面上看，他们实际上是同一个人。然而，有一些事情可以表明，无论以何种标准衡量，Dev A都可能比Dev B在职业生涯中取得更大的成功。这个怎么计算? 事实证明，技术技能和经验只能让你走这么远。高度成功的软件开发人员还会培养关键的行为特征和思维模式，使他们从人群中...
软件开发人员因该养成的7个习惯
vivian_1985的专栏
04-24 758
1、尝试开发各种不同类型的应用siud（如何你手里只有一把锤子，你看什么东西都像钉子！）,接触不同的开发流程---它山之石，可以攻玉；2、保持开放的心态，beginners mind（初学者的心态）3、系统的学习，建立自己的知识体系4、编程时多用脑子，用工具帮助做事，但是不要用工具代替思考5、不要错过向高手学习的机会6、搞清技术的来龙去脉7、形成自己的软件开发世界观“软件开发是这样的！”
SpringBoot和弦：创建Web音乐网站指南
最新发布
2401_85439108的博客
10-31 692
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。网站设计的关键问题是外观和技术的平衡。
功能测试：方法、流程与工具介绍
英英的博客
10-28 995
功能测试是确保软件质量和用户满意度的关键环节。通过合理的测试方法和流程，可以有效地发现和修复软件中的问题，提高软件的可靠性和稳定性。功能测试是对产品的各功能进行验证的一种测试方法，旨在确保软件以期望的方式运行并满足设计需求。在功能测试中，可以使用多种工具来提高测试效率和准确性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值