java中的异常（二）

java的异常

一、异常:在Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)

二、java程序运行时异常可分为两类

        Error:  Java虚拟机无法解决的严重问题。如: JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理
        Exception:其它因编程错误或偶然的外在因素导致的--般性问题，可以使用针对性的代码进行处理。例如:1)空指针访问2)试图读取不存在的文件V网络连接中断

 

三、常见的运行时和编译时异常

1.数组下边越界异常:java.lang.ArrayIndexOutOfBoundsException

    @Test
    public void test1() {
        int[] i = new int[10];
        System.out.println(i[10]);
    }

2.算术异常:java.lang.ArithmeticException

@Test
    public void test2() {
        int i = 10;
        System.out.println(i / 0);
    }

3.类型转换异常：java.lang.ClassCastException

@Test
    public void test3() {
        Object obj = new Date();
        String str = (String)obj;

    
        //String str1 = (String)new Date();编译时出错
    }

4.空指针异常:java.lang.NullPointerException

@Test
    public void test4() {
        TestError p = new TestError();
        p = null;
        System.out.println(p.toString()); 
    }

 

四、解决方法

 

1、对于这些错误，一般有两种解决方法: 

            1）是遇到错误就终止程序的运行。

            2）由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。

2、捕获错误最理想的是在编译期间，但有的错误只有在运行中时才会发生。比如:除数为0，数组下标越界等。分类:编译时异常和运行时异常

五、Exception异常的处理

（一）java提供的是异常处理的抓抛异常

1.“抛”：当我们执行代码时，一旦出现异常，就会在异常的代码处生成一个对应的异常类型的对象，并将此对象抛出（自动抛出/手动抛出（throw+异常类对象））

          1）自动抛出

                           ①一旦抛出此异常类的对象，那么程序就会终止执行

                           ②此异常的对象抛给方法的调用者

          2）手动抛出：抛出的异常类型：若是RuntimeException，可以不显示的进行处理，但是如果是Exception必须显示的进行处理。

                            实例：

                                      

 注：手动抛出的异常可以是现成的异常类，也可以是自己创建的异常类

         如何自定义一个异常类（可以Ctrl+shift+T看一下其他的自动创建的异常是如何创建的，即可仿照创建。例如：RuntimeException异常）：

                                                 步骤：1.自定义的异常类继承现有的异常
                                                            2.提供一个序列号，同时提供几个重载的构造器即可

public class MyException extends Exception {
	//1.自定义的异常类继承现有的异常
    static final long serialVersionUID = -7034897190745766939L;
	//2.提供一个序列号，同时提供几个重载的构造器即可
    public MyException() {
    	super();
    }
    public MyException(String msg) {
    	super(msg);
    }
}

2.“抓”：抓住上一步抛出来的异常类的对象。如何抓？即为异常处理的方式。

                见(二)|||||||||||即为抓的两种方式：1、try-catch-finally     2、throws

（二）java提供了两种方式用来处理一个异常的对象

处理方式一：（try-catch：比较彻底的一种方法）

try{
    //可能出现异常的代码
}catch（Exception1 e1）{
    //处理方式1
}catch（Exception2 e2）{
    //处理方式2
}finally{
    //一定要执行的代码
}

处理方式二：（在方法的声明处，显示的抛出该异常：throws（一直向上抛出异常的方法：不彻底））

例子：public static void method1() throws Exception{}

public class TestThrows {
	public static void main(String[] args) {
		method2(); //try-catch比较彻底的一种方法
	}
	public static void method2() {
		try {
			method1();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void method1() throws Exception{
		FileInputStream fis = new FileInputStream(new File("Hello.txt"));
		int b;
		while((b = fis.read()) != -1) {
			System.out.println((char)b);
		}
	}
}

 

 

 

（三）Action（注意）:

1. try内声明的变量，类似于局部变量，除了try{}语句就不能被调用
2. finally是可选的
3. catch语句内部是对异常对象的处理。两种方法：1）getMessage（）   2）printStackTrace()
4. 可以有多个catch语句，try中抛出的异常对象从上到下去匹配catch中的异常类的类型，一旦满足就执行catch中的代码。执行完，就跳出其后的catch语句
5. 如果​​​​异常处理了，那么其后的代码继续执行
6. 若catch中的多个异常是“并列”关系，谁上谁下均可。若catch中的多个异常是“包含”关系，须将子类放在父类的上面进行处理，否则报错！
7. finally中存放的是一定会执行的代码，不管try中、catch中是否仍有异常未被处理，以及是否有return语句。
8. try-catch是可以嵌套的

（四）区分

1）对于运行时异常来说，可以不显示的进行处理

2）对于编译时异常来说，必须要显示的进行处理

（五）异常关键字

throws:捕获并向外抛出异常

throw：抛出异常

try- catch：内部捕获异常并做自定义处理

finally：物理是否有异常都会被处理的语句

（六）抛异常的方法的重写的规则

子类重写父类的方法：子类抛出的异常要比父类抛出的异常少（只能是被重写方法抛出异常的子类或者是抛出同样的异常）

（七）实例

运行结果