Java 异常总结

Throwablede类是 Java 语言中所有错误或异常的超类。

两个子类的实例，Error 和 Exception

Error 是 Throwablede 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。

Exceptionde 类及其子类是Throwablede 的一种形式，它指出了合理的应用程序想要捕获的条件。

 

package com.cwcec.test;
 
class FuShuException extends Exception
{
public FuShuException()
{
 
}
 
public FuShuException(String msg)
{
super(msg);
}
}
class Person
{
    int age;
    String name;
    public Person(String name,int age)
    {
     this.name = name;
     this.age = age;
    }
    
    public Person()
    {
    
    }
    
    public int method(int[] arr,int index) throws FuShuException  //throw是语句抛出一个异常。
    {
     if(arr == null)
     {
     throw new NullPointerException("数组不能为null");
     }
     if(index >= arr.length)
     {
     throw new ArrayIndexOutOfBoundsException("数组访问的下标越界");
     }
     if (index < 0)
     {
     throw new FuShuException("数组下标不能为负数");  //throws是方法可能抛出异常的声明
}
     return arr[index];
    }
}
 
public class FieldDemo 
{
public static void main(String[] args) throws FuShuException 
{ 
 
Person person = new Person("Tom", 50);
int[] arr = {1,2,3};
int rel = person.method(null, 2);
System.out.println(rel);
  
    }  
  
} 

 

异常的分类：

1、编译时被检测异常：只要是Exception和其子类，除了特殊子类RuntimeException体系。

      这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。

       这种问题可以针对性的进行处理。

 

2、编译时不检测异常（运行时异常）：就是Exception中的RuntimeException和其子类。

      这种问题的发生无法让功能继续，运行无法进行，更多的是因为调用的原因导致的或者内部状态的

      改变而导致的。

      这种问题一般不处理，直接编译通过，在运行时，让调用者调用时程序强制停止。

 

所以自定义异常时，要么继承Exception，要么继承RuntimeException。

 

 throws 和throw的区别：

1、throws使用在函数上，是方法可能抛出异常的声明，

      throw使用在函数内，表示抛出一个异常；

2、throws抛出的是异常类，可以抛多个，用逗号隔开，

      throw抛出的是异常对象，只能有一个。

 

--------------------------------------------------------------------------------------------------------------------------------------

1. RuntimeException与Exception, Error不同点： 当方法体中抛出非RuntimeException（及其子类）时，方法名必须声明抛出的异常；但是当方法体中抛出RuntimeException（包括RuntimeException子类）时，方法名不必声明该可能被抛出的异常，即使声明了，JAVA程序在某个调用的地方，也不需要try-catch从句来处理异常。

class TestA{  
    //compiles fine.we don't need to claim the RuntimeException to be thrown here  
    void method(){  
        throw new RuntimeException();  
    }  
}  
class TestB{  
    void method() throws RuntimeException{  
        throw new RuntimeException();  
    }  
      
    void invokeMethod(){  
        //compiles fine. we don't need the try-catch clause here  
        method();  
    }  
}  
class TestC{  
      
    //compiles error.we need to claim the Exception to be thrown on the method name   
    void method(){  
        throw new Exception();  
    }  
}  
class TestD{  
    //compiles fine.  
    void method() throws Exception{  
        throw new Exception();  
    }  
} 

以下所有的相关异常的特性都不包括RuntimeException及其子类。

2. 假如一个方法在父类中没有声明抛出异常，那么，子类覆盖该方法的时候，不能声明异常。

class TestA{  
    void method(){}  
}  
class TestB extends TestA{  
      
    //complies error if the method overrided pertaining to the base class doesn't declare throwing exceptions  
    void method() throws Exception{  
        throw new Exception();  
    }  
} 
 

3. 假如一个方法在父类中声明了抛出异常，子类覆盖该方法的时候，要么不声明抛出异常，要么声明被抛出的异常继承自它所覆盖的父类中的方法抛出的异常。

class TestA{     
    void method() throws IOException{}     
}     
class TestB extends TestA{     
    //compiles fine if current method does not throw any exceptions     
    void method(){}     
}     
class TestC extends TestA{     
    //compiles fine because InterruptedIOException is inherited from IOException which is thrown by the overrided method of the base class     
    void method() throws InterruptedIOException{}     
}     
class TestD extends TestA{     
    //compiles error because Exception thrown by current method is not inherited from IOException which is thrown by the overrided method of the base class     
    void method() throws Exception{}     
}    

4. 构造器不遵循上述规则，因为构造器不遵循JAVA的覆盖和重载规则。

class TestA {  
    public TestA() throws IOException {}  
  
    public TestA(int i) {}  
}  
  
class TestC extends TestA {  
    // compiles fine if current constructor doesn't throw anything.  
    public TestC() { super(0); }  
}  
  
class TestB extends TestA {  
    // compiles fine even if current constructor throws exceptions which don't  
    // inherit from exceptions that are thrown by the overrided method of the  
    // base class  
    // this also means constructors don't conform the inheriting system of JAVA  
    // class  
    public TestB() throws Exception {}  
}  

5. 当一个类继承某个类，以及实现若干个接口，而被继承的类与被实现的接口拥有共同的方法，并且该方法被覆盖时，它所声明抛出的异常必须与它父类以及接口一致。

class ExceptionA extends Exception{  
}  
class ExceptionB extends Exception{  
      
}  
interface TestA{  
    void method() throws ExceptionA;  
}  
abstract class TestB{  
    abstract void method() throws ExceptionB;  
}  
class TestC extends TestB implements TestA{  
    //compiles error  
    public void method() throws ExceptionA{}  
}  
class TestD extends TestB implements TestA{  
    //compiles error  
    public void method() throws ExceptionB{}  
}  
class TestE extends TestB implements TestA{  
    //compiles error  
    public void method() throws ExceptionA,ExceptionB{}  
}  
class TestF extends TestB implements TestA{  
    //compiles fine  
    public void method(){}  
}