java异常详细学习一

 

java基础很重要，很多时候，如果基础不牢，请一定要花时间再回去复习复习，因为在实际中，很多人还是基础有点不牢，当然也包括博主我，感觉基础不太牢，所以也再花时间再看看，稍稍练习下。

对于java异常这块知识点，还是非常重要的，在实际开发中，这个是必备的。所以如果懂一点，但不太理解透彻的不妨可以再看看练习下

java异常体系图

Throwable

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

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

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

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

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

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

|——Exceprion （异常）

|——RuntimeException （运行时异常）

|——非运行时异常

异常图解如下：

常用异常方法：

Error类的常见子类：

 Exception类的常见子类：

RuntimeException类的常见的子类：

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

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(); // 打印栈信息
	}
}

输出结果如下图：

说明在第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("除法运算");
	}
}

结果如下：

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

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("函数执行完毕");
	}
}