java异常体系-- 提供异常信息

目录

一.异常类

1.1 Throwable类 

1.2  Error 类

 VirtualMachineError extends Error

1.3 . Exception 类

二. 处理异常的方式 :捕获,向上抛出throws 异常类型 

2.1 Catch 捕获异常 : 可视性不好

2.1.1 final 块 

2.2 抛出或声明一个异常 throw ， throws

三. 自定义异常 

---

异常：在Java语言中，在程序运行时出现的错误叫异常,或在程序执行中发生的不正常情况称为“异常”。

Java中的异常用于处理非预期的情况，如文件没找到，网络错误，非法的参数

Error:  JVM系统内部错误、资源耗尽等严重情况 程序员无法解决的

Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，例如： 空指针访问 试图读取不存在的文件 网络连接中断 可以解决的 

  RuntimeException

•    错误的类型转换
•    数组下标越界
•   空指针访问

IOExeption

• 从一个不存在的文件中读取数据
• 越过文件结尾继续读取
• 连接一个不存在的URL

空指针异常 就是 null.xxx 
例子: 
public class NullRef{
	   int i=1;
    	   public static void main(String[] args) {
		NullRef t=new NullRef();
		t=null;      	
		System.out.println(t.i);
      }
}

ava.lang.NullPointerException
	at NullRef.main(NullRef.java:6)
Exception in thread "main" 

一.异常类

1.1 Throwable类 

一. 构造器

不是final修饰,可以扩展
1. new Throwable()

2. new Throwable(String message) 
message: 提供异常信息

二. 方法

1. getMessage(); 获取异常信息

2. void printStackTrace(); 打印错误信息的(异常名) ,用来跟踪异常事件发生时执行堆栈的内容。

1.2  Error 类

 VirtualMachineError extends Error

 OutOfMemoryError ， StackOverflowError 继承 VirtualMachineError

• StackOverFlowError: 栈溢出， 方法调用方法的时候
• OutOfMemeryError: 内存不足了，无法创建对象

1.3 . Exception 类

• IOException: 数据传输的异常， QQ， 微信

   抛出的异常是IOException类的异常，则必须捕获，否则编译错误

• RuntimeException: 运行时异常

1.  ArithmeticException 数学异常
2. ClassCastException 类型转换异常(多态)
3. IndexOutOfBoundsException 下标越界异常
4. ArrayIndexOutOfBoundsException 数组下标越界异常
5. StringIndexOutOfBoundsException 字符串下标越界异常
6. NullPointerException 空指针异常
7. IllegalArgumentException 非法参数异常
8. ConcurrentModificationException 并发修改异常
9. RuntimeException类或是它的子类，这些类的异常的特点是：即使没有使用try和catch捕获，Java自己也能捕获，并且编译通过  ( 但运行时会发生异常使得程序运行终止 )。

二. 处理异常的方式 :捕获,向上抛出throws 异常类型 

java中编写程序时，会猜到程序的使用者如果使用不当，有可能会出现异常，但是程序的使用这不知道怎么处理看,我们程序员就直接将这个异常处理即可;

java中提供了2种处理异常的方式：

2.1 Catch 捕获异常 : 可视性不好

try    捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。

catch (Exceptiontype e)     在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

try {
  //可能出现异常的代码
  //捕获异常
  String str = null;
  str.length();

}catch (NullPointerException  e) {
  e.printStackTrace();
}catch ( ArithmeticException e) {
  e.printStackTrace();
}catch (ClassCastException e) {
  e.printStackTrace();
}catch (Exception e) {
  e.printStackTrace();
}


try {
  //捕获异常
  String str = null;
  str.length();

}catch (ArithmeticException | NullPointerException  e) {
  e.printStackTrace();
}

• Exception in thread "main" java.lang.ArithmeticException: / by zero   : jvm虚拟机处理的,程序停止运行
• java.lang.ArithmeticException: / by zero   : 自己处理的异常,会继续执行程序

public static void main(String[] args) {
		try {
			//可能出现异常的代码
			int c=1/0;
			System.out.println(c);
		}catch(Exception e) {
			e.printStackTrace();
		}

 java异常体系只是提供信息,自己处理异常,减少虚拟机压力

2.1.1 final 块 

finally块儿的作用就是用来关闭资源 ，应为正常情况下，finally 一定会被执行的

但是有不正常的情况:

1. 使用System.exit(0); 强制退出jvm虚拟机的情况下 ，不执行

2. 在没有进入try块儿中 ，就已经出现异常了，那么也不执行finally 块儿

3. try {
     int a = 1/1;
     System.out.println("haha");
     return;
     //终止这个方法
   } catch (Exception e) {
     e.printStackTrace();
   
   }finally {
     System.out.println("=====");
   }

在finally块儿中使用return关键字会出现什么情况  

1. 返回值被覆盖

try {
  int a = 1/1;
  System.out.println("haha");
  return a;
  //终止这个方法
} catch (Exception e) {
  e.printStackTrace();
  return 20;
}finally {
  System.out.println("=====");
  return 30;
}
//返回值被覆盖 30

try {
  int a = 1/0;
//出现异常后面的语句不执行
  System.out.println("haha");
  return a;
  //终止这个方法
} catch (Exception e) {
  e.printStackTrace();
  return 20;
}finally {
  System.out.println("=====");
  return 30;
}
//30

2.  异常丢失

public static void get() throws Exception{	
  try {
    int a = 1/0;
    System.out.println("haha");
    return;
    //终止这个方法
  } catch (Exception e) {
    throw new ArithmeticException();
  }finally {
    System.out.println("=====");
    return;
  }
}
//什么也不输出

总结: 自己处理不了异常,jvm就会处理

2.2  throws + 异常名

1.可以使用throws关键字进行异常处理，会把异常对象抛出给方法的调用者处理（自己不处理，交给别人处理），若没人处理，最终交给JVM处理——>中断处理

2. 在方法声明中用 throws 子句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

抛出异常: Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要人工创建并抛出 首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)。

//声明一个异常 throws NullPointerException,Exception(虚拟机处理)
public static void div(int a, int b) throws NullPointerException,Exception{
  if(b == 0) {
    //抛出异常  throw new ArithmeticException();
    throw new ArithmeticException();
  }
  int c = a / b;
}
//以后开发大多数都是 抛出异常，可视性好，而且更灵活

问题: throw 和 throws 的区别:

1.使用位置不同: throws在方法名后声明,由该方法的调用者处理

throw 使用在方法体中,在方法体中处理

2. 发生异常可能性

throws 是声明一个异常，这只是一种可能性，异常不一定会发生

执行throw一定抛出了某种异常

throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象我们可以不处理，默认交给JVM去处理

throw关键字后边创建的是编译器异常(不是以上两种异常)，我们就必须处理这个异常，要么throws，要么try...catch

三. 自定义异常 

java中的异常不能满足我们日常开发，所以要自定义类型的异常处理

如何实现呢? 就是自定义一个类，继承Throwable 或 RuntimeException

自定义异常必须抛出(new 对象)

message e, printStackTrace()

package com.moju.test2;

public class MyArrayIndexOutOfBoundsException extends RuntimeException{

	private String message;

	public MyArrayIndexOutOfBoundsException() {}
	
	public MyArrayIndexOutOfBoundsException(String message) {
		this.message =message;
	}

	@Override
	public String getMessage() {
		return message;
	}

	@Override
	public void printStackTrace() {
		
		String name = getClass().getName()+this.message;
		
		System.err.println(name);
	}
}

package com.moju.test2;

public class TestArray {

	/**
	 * 获取数组中所有元素的
	 */
	public static void getArrays(int[] array) throws MyArrayIndexOutOfBoundsException{
		//故意写错
      	for(int i = 0;i < 23 ;i++) {
			if(i > array.length-1) {
				throw new MyArrayIndexOutOfBoundsException("我的数组越界异常");
			}
			System.out.println(array[i]);
		}
	}
	
	public static void main(String[] args) {
		int[] arr = {1,2,23,34,5,5,1,3,3,31};
		try {
			getArrays(arr);
		} catch (MyArrayIndexOutOfBoundsException e) {
			e.printStackTrace();
		}	
	}
}