Java series: "Java Core technology Volume One" study notes, CCHAPTER11 exceptions

11.1.1 Exception Classification If a program appears runtimeexception, then it must be your problem.


11.1.2 Declaration has detected an exceptionIf a subclass overrides a method of the parent class, the check exception declared in the subclass method cannot be more general than the exception declared in the superclass method.
11.1.4 Create exception class all custom exception classes should implement two constructors, one is the default constructor, and the other is a constructor with a string parameter;

11.2 Catching exceptions in general, you should catch exceptions that know how to handle them, and continue to pass on exceptions that do not know how to handle them.

11.2.1 captures multiple exceptions in Java7, the same catch statement can catch multiple exceptions, such as:

  
 

   
  

  
try{
   
  

  
 ....
   
  

  
}catch(FileNotFoundException | UnknownHostException){
   
  

  
 ...
   
  

  
}
  
 

This method is only required if the caught exception class does not have a parent-child relationship with each other.

11.2.2 throws an exception again or causes the exception chain to set the original exception to the new exception.

  
 

   
  

  
try{
   
  

  
 ...
   
  

  
}catch(Exception e){
   
  

  
 Throwable se = new ServetException("database error: ");
   
  

  
 se.initCause(e);
   
  

  
 throw se;
   
  

  
}
  
 

When you catch an exception, you can use throwable se = E.getcause () to get the original exception.
11.2.4 a try statement with a resource you know, this is the same as the using statement in C #.

 
   
  

  
    
   
 try(Resources res = ){
  
    
   
 work with this res
  
    
   
 }
 
   
  

The Res.close () statement is automatically called when the try block exits. (in C #, call the Res.dispose () method)
For example, the following two codes are equivalent

  
 

   
  

  
FileInputStream fs=null;
   
  

  
try{
   
  

  
 fs = new FileInputStream("D:\test.txt");
   
  

  
 fs.xxxxx
   
  

  
}
   
  

  
finally{ 
   
  

  
 if(fs != null) fs.close();
   
  

  
  Span class= "pun" >}  
  
 

 
   
  

  
    
   
try(FileInputStream fs= new FileInputStream("D:\test.txt")){
  
    
   
 fs.xxxx
  
    
   
}
 
   
  

Obviously, the second piece of code is much simpler.
And you can define multiple resources in a try block, separated by commas, and the compiler automatically calls the close () method of all resources.
11.2.5 Analyzing stack trace information

  
 

   
  

  
 Throwable t = new Throwable();
   
  

  
 StackTraceElement[] frames = t.getStackTrace();
   
  

  
 for(StackTraceElement frame : frames){
   
  

  
 //xxxxx
   
  

  
 }
  
 

Through the stacktraceelement can obtain the corresponding file name, the wrong line number, class name, method name and other information, which can be more convenient to analyze and debug a problem.
The following method can get stack information for all threads of the current application, which was not seen in C # before, which also shows the importance of learning different languages from the side.

  
 

   
  

  
Map<Thread, StackTraceElement[]> map = Thread.getAllStackTrace();
   
  

  
for(Thread t: map.keys()){
   
  

  
 StackTraceElement frames = map.get(t);
   
  

  
  analyze frame
   
  

  
}
  
 

Several typical methods of stacktraceelement

  
 

   
  

  
String getFileName();
   
  

  
int getLineNumber();
   
  

  
String getClassName();
   
  

  
String getMethodName();
   
  

  
boolean isNativeMethod();
   
  

  
String toString();
  
 

11.3 Tips for using exceptions 1) exception handling can not replace the simple test, that is, do not use the exception to do the program to determine the branch; 2) to properly use the exception hierarchy, throw or capture, to try to use a class that can express a specific purpose, which will have better readability, Do not use throwable at all times, so that the readability is poor, 3) in the detection of errors, "harsh" than laissez-faire better, such as Stack.pop () is the return of NULL better or run out emptystackexception better? The author thinks the latter is better. 4) Don't be shy about passing exceptions. If you call a method that runs out of an exception, such as the Fileinputsteam constructor or the ReadLine method, these methods instinctively capture these possible exceptions. Passing exceptions is better than catching exceptions.

  
 

   
  

  
public void readStuff(Sting fileName) throw s IOException{
   
  

  
 InputStream is = new FileInputStream(fileName);
   
  

  
 //xxxx
   
  

  
}
  
 

Let high-level users know that an error has occurred, or that it is more appropriate to discard unsuccessful commands.
Then the above two points can be summed up as: Early throw, late capture.




From for notes (Wiz)

Java series: "Java Core technology Volume One" study notes, CCHAPTER11 exceptions