Java异常处理

异常:程序在运行时出现的不正常的情况。

异常的由来：问题也是现实生活中的一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。

问题的划分：一种是严重的问题，另一种是非严重的问题。

对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。

对于非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容,比如:不正常情况的信息,引发原因等。

异常的处理：java提供了特有的语句进行处理。

 Try

{

    需要被检测的代码

}

Catch（异常类 变量）

{

   处理异常的代码；（处理方式）

}

Finally

{

   一定会执行的语句；

}

 

对捕获的异常对象进行常见方法的操作:

e.getMessage();  e.toString(); e.printStacktrace();

在函数上声明异常,便于提高安全性,让调用者进行处理,不处理编译失败。

处理方式1:

class Demo {
    int div(int a, int b) throws Exception {
       return a / b;
    }
}
 
public class ExceptionDemo1 {
    public static void main(String[] args) throws Exception {
       Demo d = new Demo();
       int x = d.div(4, 1);
       System.out.println("x=" + x);
       System.out.println("over");
    }
}

 

处理方式2:

class Demo {
    int div(int a, int b) throws Exception {
       return a / b;
    }
}
 
public class ExceptionDemo1 {
    public static void main(String[] args) {
       Demo d = new Demo();
       try {
           int x = d.div(4, 1);
           System.out.println("x=" + x);
       } catch (Exception e) {
           System.out.println(e.toString());
       }
    }
}

 

 

对多异常的处理：

1.    声明异常时，建议声明更为具体的异常，这样可以处理的更具体

2.    对方声明几个异常，就对应有几个catch块，如果多个catch快中的异常出现继承关系，父类异常catch块放在最下面。

 

 

自定义异常：必须是自定义类继承Exception或者RuntimeException

原因：异常体系有一个特点：因为异常类和异常对象都被抛出，他们都具备可抛性，而这个可抛性是Throwable这个体系中独有的特点。

只有这个体系中的类和对象才可以被throws和throw操作。

当函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数是声明让调用者处理.

一般情况下函数内出现异常，函数上需要声明。

    如果该异常的发生,无法再继续进行运算,就让自定义异常继承RuntimeException.此时程序可以只抛出不处理.

class FushuException extends Exception {
    private int val;
    FushuException(String msg,int val){
       super(msg);
       this.val=val;
    }
    public int getVal(){
       return val;
    }
}
 
class Demo {
    int div(int a, int b) throws FushuException {
       if (b < 0)
           throw new FushuException("除数出现负数",b);//手动通过throw关键字抛出一个自定义异常对象
       return a / b;
    }
}
 
public class ExceptionDemo1 {
    public static void main(String[] args) {
       Demo d = new Demo();
       try {
           int x = d.div(4, -1);
           System.out.println("x=" + x);
       } catch (FushuException e) {
           System.out.println(e.toString());
           System.out.println("除数出现负数了");
           System.out.println("出现异常的数为:"+e.getVal());
       }
    }
}

 

Throws和throw的区别：

throws使用在函数上，后面跟的是异常类，可以抛出多个用逗号隔开。

throw使用在函数内后面跟的是异常对象。

 

Exception中有一个特殊的子类异常RuntimeException运行时异常:

1.如果在函数内抛出改异常,函数上可以不用声明,编译通过;

2.如果在函数上声明了该异常,调用者可以不用进行处理,编译通过。

之所以不用在函数上声明,是因为不需要让调用者处理.当该异常发生,希望程序停止,因为在运行时,出现了无法继续运行的情况,希望停止程序后,对代码进行修正。

 

总结:对于异常分两种:

1. 编译时被检测的异常

2. 编译时不被检测的异常(运行时异常,Runtimeexception以及其子类)

 

Finally中放的是一定会被执行的代码,通常用于释放资源.只有在一种情况下不会执行，那就是当执行到System.exit(0);

三种格式:

格式一:

Try{

}

Catch{

}

格式二:

     Try{

}

Catch{

}

Finally{

}

格式三:

      Try{

}

Finally{

}

 

Catch语句块是用于处理异常的,如果没有catch就代表异常没有被处理过,如果该异常是检测时异常,那么就必须声明出去.

 

异常在子父类覆盖中的体现:

1. 子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法只能抛出父类的异常或者该异常的子类。

2. 如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。

3. 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时也不可以抛出异常。如果子类方法发生了异常，就必须要进行try，catch处理。绝对不能往外抛。

异常的好处:

1. 将问题进行封装.

2. 将正常流程代码和问题处理代码相分离,方便于阅读。

异常的出来原则：

1. 处理方式有两种：try或者throws。

2. 调用到抛出异常的功能时，抛出几个，就处理几个，一个try对应多个catch。

3. 多个catch，父类的catch放到最下面。

4. catch内，需要定义针对性的处理方式。不要简单的定义printStackTree,输出语句,也不要不写。

5. 当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。如：

      

 try {
           throw new AException();
       } catch (AException e) {
           throw e;

 

6. 如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，再抛出和该功能相关的异常。

 

 

包（package）：

1. 对类文件进行分类管理

2. 给类提供多层命名空间

3. 写在程序文件的第一行

4. 类名的全称是 包名.类名

5. 包是一种封装形式。

有包时的编译命令：

1. javac –d . PackageDemo.java  当前目录下创建文件夹

2. javac –d C:\Myclass PackageDemo.java 指定目录下创建文件夹

 

   

包与包之间的访问:

1. 包与包之间进行访问,被访问的包中的类以及类中的成员,需要public修饰。

2. 不同包中的子类还可以直接访问父类中被protected权限修饰的成员。

3. 包与包之间可以使用的权限只有两种，public  protected

 

	public	protected	default	private
同一个类中	yes	yes	yes	yes
同一个包中	yes	yes	yes	no
子类	yes	yes	no	no
不同包中	yes	no	no	no