Replace error code with exception (replace the error code with an exception)

Replace error code with exception (replacing the error code with exceptions) http://book.51cto.com 2010-02-03 bear festival translated by People's post and telecommunications press I want to comment (0)

• Abstract: refactoring: improving the design of existing code clearly reveals the reconstruction process and explains the principles and best practices of refactoring, it also shows when and where to start mining code for improvement. Chapter 2 describes how to simplify function calls. This section describes replace error code with exception (replacing error codes with exceptions)
• Label: refactoring code function refactoring: improving the design of existing code

 

10.14 replace error code with exception (replace the error code with an exception)

A function returns a specific code to indicate an error.

Switch exception.

 
 

  
  
int withdraw(int amount) {  
  
  
    if (amount > _balance)  
  
  
        return -1;  
  
  
    else {  
  
  
        _balance -= amount;  
  
  
        return 0;  
  
  
    }  
  
  
}  
  
  
   
  
  
void withdraw(int amount) throws BalanceException {  
  
  
    if (amount > _balance) throw new BalanceException();  
  
  
    _balance -= amount;  
  
  
} 
 
 

Motivation

Like life, computers occasionally make mistakes. Once something goes wrong, you need some countermeasures. In the simplest case, you can stop the program and return an error code. This is like killing myself because I missed a plane (if I did that, even if I were a cat, my nine lives would be lost ). Although my smooth attempt brings a bit of humor, this "software suicide" option is indeed good. If the program crashes at a low cost and the user is tolerant enough, you can safely terminate the program. But if your program is important, you need to handle it in a more serious way.

The problem is: the errors found in the program do not necessarily know how to handle the errors. When a subroutine discovers an error, it needs to let its callers know the error, and the caller may also pass the error along the call chain. Many programs use special outputs to indicate errors. The traditional methods of UNIX and C-based systems are to return values to indicate successful or failed subprograms.

Java has a better way to handle errors: exceptions. This method is better because it clearly separates "Common Programs" from "error handling", which makes the program easier to understand-I hope you are now confident that: the comprehensibility of code should be our goal.

Practice

Decide whether to throw a controlled or unchecked exception.

If the caller has the responsibility to check the necessary status before calling, an uncontrolled exception is thrown.

To throw a controlled exception, you can create a new exception class or use an existing exception class.

Find all callers of the function and adjust them accordingly to make them use exceptions.

If a function throws an uncontrolled exception, adjust the caller so that the caller can perform a proper check before calling the function. Compile and test each modification.

If the function throws a controlled exception, adjust the caller so that the caller can call the function in the try section.

Modify the signature of the function to reflect the new usage.

If a function has many callers, the modification process may be too long. You can divide it into the following steps.

Decide whether to throw a controlled exception or an uncontrolled exception.

Create a new function and use an exception to indicate the error status. Copy the code of the old function to the new function and make appropriate adjustments.

Modify the function ontology of the old function to call the new function.

Compile and test.

Modify the callers of the old function one by one to call the new function. Compile and test each modification.

Remove the old function.

Example

In real life, you can overdraft your account balance, but it is not surprising that you cannot do this in computer textbooks? However, the following example assumes that you cannot do this:

 
 

  
  
class Account...  
  
  
  int withdraw(int amount) {  
  
  
      if (amount > _balance)  
  
  
          return -1;  
  
  
      else {  
  
  
          _balance -= amount;  
  
  
          return 0;  
  
  
      }  
  
  
  }  
  
  
 
  
  
  private int _balance; 
 
 

To make this code run abnormally, I first need to decide whether to use a controlled exception or an uncontrolled exception. The key to decision-making is: whether the caller is responsible for checking the deposit balance before the withdrawal, or whether the withdraw () function should be responsible for checking. If "checking the balance" is the caller's responsibility, "the withdrawal amount is greater than the deposit balance" is a programming error. This is a programming error, so I should use uncontrolled exceptions. On the other hand, if "checking the balance" is the responsibility of the withdraw () function, I must declare in the function interface that it may throw this exception, so the caller is reminded to pay attention to this exception, and take appropriate measures.

Example: uncontrolled exceptions

Consider uncontrolled exceptions first. This indicates that the caller is responsible for the check. First, I need to check the calling code. It should not use the return value of the withdraw () function, because the return value is only used to indicate programmer errors. If I see the following code:

 
 

  
  
If (account. Withdraw (amount) =-1)
  
  
Handleoverdrawn ();
  
  
Else dotheusualthing ();
  
  
I should replace it with this Code:
  
  
If (! Account. canwithdraw (amount ))
  
  
Handleoverdrawn ();
  
  
Else {
  
  
Account. Withdraw (amount );
  
  
Dotheusualthing ();
  
  
}
 
 

Compile and test each modification.

Now, I need to remove the error code and throw an exception when a program error occurs. This behavior is abnormal and rare, so I should use a guard statement to check this situation:

 
 

  
  
Void withdraw (INT amount ){
  
  
If (amount> _ balance)
  
  
Throw new illegalargumentexception ("amount too large ");
  
  
_ Balance-= amount;
  
  
}
  
  
As this is a programmer's mistake, I should use assertions to point out this point more clearly:
  
  
Class account...
  
  
Void withdraw (INT amount ){
  
  
Assert. istrue ("sufficient funds", amount <= _ balance );
  
  
_ Balance-= amount;
  
  
}
  
  
 
  
  
Class assert...
  
  
Static void istrue (string comment, Boolean test ){
  
  
If (! Test ){
  
  
Throw new runtimeexception ("assertion failed:" + comment );
  
  
}
  
  
}
  
  
 
  
  
Example: Controlled exception
  
  
 
  
  
The handling methods of controlled exceptions are slightly different. First, I want to establish (or use) a suitable exception:
  
  
 
  
  
Class balanceexception extends exception {}
  
  
 
  
  
Then, adjust the caller as follows:
  
  
 
  
  
Try {
  
  
Account. Withdraw (amount );
  
  
Dotheusualthing ();
  
  
} Catch (balanceexception e ){
  
  
Handleoverdrawn ();
  
  
}
  
  
Next, I want to modify the withdraw () function to indicate the error status with an exception:
  
  
 
  
  
Void withdraw (INT amount) throws balanceexception {
  
  
If (amount> _ balance) throw new balanceexception ();
  
  
_ Balance-= amount;
  
  
}
 
 

The trouble with this process is that I have to modify all callers and functions called by them at one time, or the compiler reports an error. If there are many callers, this step is too large, with no compilation and testing support.

In this case, I can use a temporary intermediate function. I am still starting from the previous situations:

 
 

  
  
If (account. Withdraw (amount) =-1)
  
  
Handleoverdrawn ();
  
  
Else dotheusualthing ();
  
  
 
  
  
Class account...
  
  
Int withdraw (INT amount ){
  
  
If (amount> _ balance)
  
  
Return-1;
  
  
Else {
  
  
_ Balance-= amount;
  
  
Return 0;
  
  
}
  
  
}
  
  
First, create a newwithdraw () function to throw an exception:
  
  
Void newwithdraw (INT amount) throws balanceexception {
  
  
If (amount> _ balance) throw new balanceexception ();
  
  
_ Balance-= amount;
  
  
}
  
  
Then, adjust the existing withdraw () function to call newwithdraw ():
  
  
 
  
  
Int withdraw (INT amount ){
  
  
Try {
  
  
Newwithdraw (amount );
  
  
Return 0;
  
  
} Catch (balanceexception e ){
  
  
Return-1;
  
  
}
  
  
}
  
  
Compile and test. Now I can call the old function one by one to call the new function:
  
  
 
  
  
Try {
  
  
Account. newwithdraw (amount );
  
  
Dotheusualthing ();
  
  
} Catch (balanceexception e ){
  
  
Handleoverdrawn ();
  
  
}
 
 

Because both new and old functions exist, I can compile and test each modification. After all callers are modified, the old function can be removed and rename method (273) is used to modify the new function name so that it is the same as the old function.