java异常详细学习一

逃离我推掉我的手 2022-05-11 15:04 187阅读 0赞

> java基础很重要，很多时候，如果基础不牢，请一定要花时间再回去复习复习，因为在实际中，很多人还是基础有点不牢，当然也包括博主我，感觉基础不太牢，所以也再花时间再看看，稍稍练习下。
> 
> **对于java异常这块知识点，还是非常重要的，在实际开发中，这个是必备的。所以如果懂一点，但不太理解透彻的不妨可以再看看练习下**

**java异常体系图**

**Throwable**

Java中有个java.lang.Throwable类，这个类是Java中所有异常和错误的基类。Throwable下有两个大类那就是异常(Exception)和错误(Error)。

现实生活中的很多病况从面向对象的角度考虑也是一类事物，可以定义为类。再通俗的说：如人生病了，如感冒了，你可以简单的理解为异常。相信即使对非本行业的人也能理解吧。

java中可以通过类对这一类不正常的现象进行描述，并封装为对象。

1.  java的异常体系包含在java.lang这个包默认不需要导入。
2.  java异常体系

|——Throwable  （实现类描述java的错误和异常）

|——Error （错误）一般不通过代码去处理。

|——Exceprion （异常）

|——RuntimeException （运行时异常）

|——非运行时异常

异常图解如下：

![Throwable][]

常用异常方法：

Error类的常见子类：

**![1236065-20171105121728388-233555650.png][]**

Exception类的常见子类：

![1236065-20171105121806763-149045745.png][]

RuntimeException类的常见的子类：

![1236065-20171105121838388-539456200.png][]

以上就是一些比较常见的异常。面试的时候，面试官叫你说出几个异常，希望你能随口就能说出或者写出。

1.  1.  **Throwable类**
2.  toString() 输出该异常的类名。
3.  getMessage() 输出异常的信息，需要通过构造方法传入异常信息（例如病态信息）。
4.  printStackTrace() 打印栈信息。

### 通过以上简单的介绍：那么接下来的是简单的代码演示。理解与实战并行，这样影响才深刻。 ###

一：演示异常在的Throwable基类产生

demo1如下代码所示：

package cn.demo;
    
    public class DemoThrowable {
    	public static void main(String[] args) {
    		// 定义一个Throwable类
    		Throwable abc = new Throwable("世界你好");
    		System.out.println(abc.getMessage()); // 输出异常的信息
    		System.out.println(abc.toString()); // 输出该异常的类名
    		abc.printStackTrace(); // 打印栈信息
    	}
    }

输出结果如下图：

![70][]说明在第6行有出现异常。

二：**程序中的异常处理**

1.  当除数是非0，除法运算完毕，程序继续执行。
2.  当除数是0，程序发生异常，并且除法运算之后的代码停止运行。因为程序发生异常需要进行处理。

demo2演示练习一个超简单的除法运算如下所示：

package cn.demo;
    //演示除法的异常产生
    public class DemoThrowable2 {
    	public static void main(String[] args) {
    	// 调用abc这个函数,并赋值x为6，被除数y为0,这样2除以0肯定是有问题的
    		abc(6, 0);
    		System.out.println("over");
    	}
    	// 定义一个除法函数abc
    	public static void abc(int x, int y) {
    		// 该行代码的y值可能是0,程序会出现异常并停止
    		System.out.println(x / y);//输出x除以y
    		System.out.println("除法运算");
    	}
    }

结果如下：

![70 1][]

以上就是一个异常，那么面对异常怎么办呢？两种方法，一种是抛出异常，一种是处理异常。这两种的方式都是为了让程序继续运行。如果不处理的话，那么程序是肯定不能走下去。就卡死在这里了。所以这里博主演示处理的方式。

package cn.demo;
    
    public class DemoThrowable1 {
    	public static void main(String[] args) {
    	// 调用abc这个函数,并赋值x为6，被除数y为0,这样2除以0肯定是有问题的
    		abc(6, 0);
    		System.out.println("运算结束");
    	}
    	public static void abc(int x, int y) {
            try {
    			//该行代码的y值可能是0,程序会出现异常并停止
    			System.out.println(x/y);
    		} catch (Exception e) {
    			//System.out.println(e.toString());// 输出该异常的类名
    			//System.out.println(e.getMessage());	// 输出异常的信息
    			//实际开发中，以上两个不会写，但这里是方便大家暂时学习，以后熟悉以上2个异常的类名与异常的信息是不写的
    			e.printStackTrace();// 打印栈信息
    			System.out.println("除数不能为0");
    		}
    		System.out.println("除法运算");
    	}
    }

运算结果如下：

java.lang.ArithmeticException: / by zero  
    at cn.demo.DemoThrowable1.abc(DemoThrowable1.java:12)  
    at cn.demo.DemoThrowable1.main(DemoThrowable1.java:6)  
除数不能为0  
除法运算  
运算结束

**多个异常**

1.  案例print方法，形参中增加数组。
2.  在print方法中操作数组会发生新的异常

ArrayIndexOutOfBoundsException，NullPointerException），如何处理？

1，使用将可能发生异常的代码放入try语句中，添加多个catch语句即可。

2，可以处理多种异常，但是同时只能处理一种异常。

3，try中除0异常和数组角标越界同时出现，只会处理一种。

1.  1.      package cn.demo;
            //多个异常演示
            public class DemoThrowable3 {
            	public static void main(String[] args) {
            
            		System.out.println();
            		int[] arr = { 1, 2 };
            		arr = null;
            
            		// print (1, 0, arr);
            		print (1, 2, arr);
            
            		System.out.println("over");
            	}	
            
            	public static void print(int x, int y, int[] arr) {
            
            		try {
            			System.out.println(arr[1]);
            			System.out.println(x / y);
            		} catch (ArithmeticException e) {
            			e.toString();
            			e.getMessage();
            			e.printStackTrace();
            			System.out.println("算术异常。。。");
            		} catch (ArrayIndexOutOfBoundsException e) {
            			e.toString();
            			e.getMessage();
            			e.printStackTrace();
            			System.out.println("数组角标越界。。。");
            		} catch (NullPointerException e) {
            			e.toString();
            			e.getMessage();
            			e.printStackTrace();
            			System.out.println("空指针异常。。。");
            		}
            		System.out.println("函数执行完毕");
            	}
            }
        
        运行结果 如下：  
        空指针异常。。。  
        函数执行完毕  
        over  
        java.lang.NullPointerException  
            at cn.demo.DemoThrowable3.print(DemoThrowable3.java:19)  
            at cn.demo.DemoThrowable3.main(DemoThrowable3.java:11)

**总结**

1.  程序中有多个语句可能发生异常，可以都放在try语句中。并匹配对个catch语句处理。
2.  如果异常被catch匹配上，接着执行try\{\}catch()\{\} 后的语句。没有匹配上程序停止。
3.  try中多个异常同时出现，只会处理第一条出现异常的一句，剩余的异常不再处理。
4.  使用多态机制处理异常。
    
    1.  1.  1.  程序中多态语句出现不同异常，出现了多个catch语句。简化处理（相当于急诊）。
            2.  使用多态，使用这些异常的父类进行接收。（父类引用接收子类对象）

多个catch语句之间的执行顺序。

1.  1.  1.  1.  是进行顺序执行，从上到下。
            2.  如果多个catch 内的异常有子父类关系。
                
                1.  1.  1.  子类异常在上，父类在最下。编译通过运行没有问题
                        2.  父类异常在上，子类在下，编译不通过。(因为父类可以将子类的异常处理，子类的catch处理不到)。
                        3.  多个异常要按照子类和父类顺序进行catch

package cn.demo;
    class Father {
    
    }
    
    class Son extends Father {
    
    }
    public class DemoTest {
    	public static void main(String[] args) {
    
    		System.out.println();
    		int[] arr = { 1, 2 };
    		arr = null;
    		Father f = new Father();
    		div(1, 0, arr, f);
    		
    		System.out.println("over");
    	}
    
    	public static void div(int x, int y, int[] arr, Father f) {
    
    		try {
    			System.out.println(arr[1]); 
    			System.out.println(x / y);
    			Son s = (Son) f;
    
    		} catch (ArithmeticException e) {
    			e.toString();
    			e.getMessage();
    			e.printStackTrace();
    			System.out.println("算术异常。。。");
    		} catch (ArrayIndexOutOfBoundsException e) {
    			e.toString();
    			e.getMessage();
    			e.printStackTrace();
    			System.out.println("数组角标越界。。。");
    		} catch (NullPointerException e) {
    			e.toString();
    			e.getMessage();
    			e.printStackTrace();
    			System.out.println("空指针异常。。。");
    		} catch (Exception e) {
    			e.toString();
    			e.getMessage();
    			e.printStackTrace();
    			System.out.println("出错啦");
    		}
    		System.out.println("函数执行完毕");
    	}
    }

[Throwable]: /images/20220505/2f47a6e7c5bd4293879dd139625418f4.png
[1236065-20171105121728388-233555650.png]: /images/20220505/33432f03fc854896929f096b2bd036a3.png
[1236065-20171105121806763-149045745.png]: /images/20220505/949b4ef1c45e44ae911a03599053572a.png
[1236065-20171105121838388-539456200.png]: /images/20220505/91dc15f66c504df88a336aed404b3895.png
[70]: /images/20220505/ecf198ba12eb452caae3b59425bc87b8.png
[70 1]: /images/20220505/019c6bc69c284ba3b8da32c1ce09ed47.png