异常

1. 异常

举例引入

例题1：

/**

 * 举例说明常见的异常

 * java.lang.NullPointerException 空指针异常  对为null的元素作操作

 * java.lang.NegativeArraySizeException 数组的长度为负数异常  

 * java.lang.NumberFormatException 数字格式异常

 * @author Administrator

 *

 */

public class Test01 {

public static void main(String[] args) {

//声明对象数组，分配长度

Student[] arr = new Student[3];

arr[0]= new Student("张三",20);

//System.out.println("姓名："+arr[1].getName()+",年龄："+arr[1].getAge());

//int[] arr2 = newint[-3];

String strNum = "12324af,";

int num = Integer.parseInt(strNum);

System.out.println("num="+num);

}

}

例题2：

/**

 * 不可查异常 RuntimeException的子类

 * java.lang.ArrayIndexOutOfBoundsException数组索引越界

 * java.lang.StringIndexOutOfBoundsException字符串的索引越界

 * @author Administrator

 *

 */

public class Test04 {

public static void main(String[] args) {

String[] arr = new String[]{"hello1","hello2"};

/*for(int i=0;i<3;i++){

System.out.println(arr[i]);

}*/

String str = "hello";

System.out.println(str.substring(3,8));

}

}

例题3：

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

/**

 * 编译阶段能够识别的异常 ，可查异常

 * java.text.ParseException 解析异常

 * @author Administrator

 *

 */

public class Test03 {

public static void main(String[] args) {

DateFormat df = new SimpleDateFormat("yyyy-MM-dd");

try {

Date date = df.parse("2013-4-5");

System.out.println("date="+date);

} catch (ParseException e) {

e.printStackTrace();

}

}

}

什么是异常？

异常是一个事件，它发生在程序运行期间，干扰了正常的指令流程。Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的 错误条件。当条件生成时，将引发异常。

报错

（1）语法错误：可以在编译时发现。通常是开发人员犯错

（2）运行时报错 ：通常是文件找不到、网络连接失败、非法参数等。

运行时报错按照严重程度分为两种

（1）Error错误：非常严重，无法捕捉，程序必须终止。如系统崩溃，是JVM出问题。如：OutOfMemoryError。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外。错误通过Error的子类描述。

（2）Exception异常：不严重，程序可以捕捉并解决异常，之后程序继续运行。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

1.1. 本章目标本章任务

进行异常的学习，能够自己处理常见的异常，程序出现错误时，能够自己排错。

1.2. Exception异常

Java的异常(包括Exception和Error)分为可查的异常（checked exceptions）和不可查的异常（unchecked exceptions）。

（1）可查的异常（checked exceptions）

可查异常（编译器要求必须处理的异常）：正确的程序在运行中，很容易出现的、情理可容的异常状况。可查异常虽然是异常状况，但在一定程度上它的发生是可以预计的，而且一旦发生这种异常状况，就必须采取某种方式进行处理。除了RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。

如：IOException、SQLException

特点：强制要求使用try catch处理，否则程序无法启动。

（2）不可查的异常（unchecked exceptions）

不可查异常(编译器不要求强制处理的异常):运行时异常（RuntimeException与其子类）。

如：NullPointerException (空指针异常)、IndexOutOfBoundsException (下标越界异常)

何时会出现这些错误？

NullPointerException (空指针异常)、IndexOutOfBoundsException (下标越界异常)

什么是运行时异常？

是RuntimeException类及其子类异常，如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

运行时异常的特点是Java编译器不会检查它，也就是说，当程序中可能出现这类异常，即使没有用try-catch语句捕获它，也没有用throws子句声明抛出它，也会编译通过。

什么是非运行时异常 （编译异常）？

是RuntimeException以外的异常，类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等。

异常层次结构图

Throwable

Error     Exception

        IOException       RuntimeException

   FileNotFoundException    NullPointerException

 

面试题： 请写出异常的分类，常见的8种异常，并说明其含义。

Throwable下面有2个子类，一个是Error,错误，本身非常严重，程序无法处理。一个是Exception，可以处理的异常。又分为可查异常还有不可查异常。

可查异常：除了RunTimeException及其子类以外的其他异常

不可查异常：RuntimeException及其子类

1.3. 运行时异常、错误或可查异常如何处理

l 由于运行时异常的不可查，代码写好了并不能明显的看出来哪里可能出错，所以允许应用程序忽略运行时异常。但最好不要忽略。

l 所有的可查异常，出现异常的方法必须捕捉异常，或者在方法声明时声明异常并抛出方法之外。

l 对于错误Error，不作处理，因为无力处理。

1.4. 异常处理机制

异常处理机制为：抛出异常->捕捉异常。

抛出异常

当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

捕获异常

在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器。

程序遇到异常会发生什么？

程序如果遇到异常会直接终止，如果不想让程序终止，我们可以捕获异常。

1.5. Try-catch捕获异常

异常出现时，会寻找处理异常的代码，并把异常对象交给该代码处理。

异常通过try-catch语句捕获

语法：

try {  

    // 可能会发生异常的程序代码  

} catch (Type1 id1){  //异常类型1

    // 捕获并处理try  

} catch (Type2 id2){  //异常类型2

     //捕获并处理try  

}  

 

try{

 

 

}finally{

 

}

 

try{

 

 

}catch(){

 

}catch(){

 

}finally{

 

 

}

注意：Try必须有的，catch和finally至少要有1个。如果try-catch结构，其后可以跟多个catch，但是finally最多有1个，可以没有

示例1：不用异常处理用之前的学过的知识处理，发现代码结构臃肿

import java.util.Scanner;

/**

 * 计算2个数的整数商 编译器不识别 只有运行时，逻辑错误的时候才会抛出

 * java.util.InputMismatchException 输入类型不匹配异常

 * java.lang.ArithmeticException 算术异常  除数为0时出现

 * System.err.println(); //标准错误输出流  控制台的字体颜色是红色

 * System.out.println(); //标准输出流 打印

 * Scanner input = new Scanner(System.in);

System.out.print("请输入被除数：");

int num1 = input.nextInt();

System.out.print("请输入除数：");

int num2 = input.nextInt();

int result = num1/num2;

System.out.println("两个数的商为："+result);

 * @author Administrator

 *

 */

public class Test02 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

System.out.print("请输入被除数：");

if(input.hasNextInt()){

int num1 = input.nextInt();

System.out.print("请输入除数：");

if(input.hasNextInt()){

int num2 = input.nextInt();

if(num2!=0){

int result = num1/num2;

System.out.println("两个数的商为："+result);

}else{

System.err.println("除数不能为0！");

}

}else{

System.err.println("除数只能是数字");

}

}else{

System.err.println("被除数只能是数字！");

}

}

}

示例2：异常处理，没有做到精确捕获

/**

 * 异常处理机制1  

 * try{

 * //容易出错的代码

 * }catch(异常的类型e){

 *

 *

 * }

 * try alt+/回车

 * e.printStackTrace();  打印异常的堆栈信息 打印异常

 * 3个线程： 线程 main线程 ；   后台gc 回收内存（之前new一些变量会被释放内存）； 后台 异常；3个线程是独立的，堆栈信息的打印位置不受控制

 * @author Administrator

 *

 */

public class Test021 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

try {

System.out.print("请输入被除数：");

int num1 = input.nextInt();

System.out.print("请输入除数：");

int num2 = input.nextInt();

int result = num1/num2;

System.out.println("两个数的商为："+result);

} catch (Exception e) {

//打印异常的堆栈信息

e.printStackTrace();

System.out.println("计算过程中出现了异常");

}

}

}

示例3：异常处理，精确捕获

import java.util.InputMismatchException;

import java.util.Scanner;

/**

 * 异常处理机制1  精确捕获可能发生的异常,最后最好加上一个父类的异常，防止出现一些未知的异常,

 * 遵循的顺序 先子后父

 * try{

 * //容易出错的代码

 * }catch(异常的类型e){

 *

* }

 * try alt+/回车

 * e.printStackTrace();  打印异常的堆栈信息 打印异常

 * e.getMessage(); //打印异常详细消息字符串 打印的是冒号后面的描述信息

 * 3个线程： 线程 main线程 ；   后台gc 回收内存（之前new一些变量会被释放内存）； 后台 异常；3个线程是独立的，堆栈信息的打印位置不受控制

 * @author Administrator

 *

 */

public class Test023 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

try {

System.out.print("请输入被除数：");

int num1 = input.nextInt();

System.out.print("请输入除数：");

int num2 = input.nextInt();

int result = num1 / num2;

System.out.println("两个数的商为：" + result);

//int[]arr = newint[-3];

} catch (InputMismatchException e) {

e.printStackTrace();

System.out.println("详细信息："+e.getMessage());

System.out.println("被除数或者除数只能是数字!");

} catch (ArithmeticException e) {

e.printStackTrace();

System.out.println("详细信息："+e.getMessage());

System.out.println("除数不能为0！");

} catch (Exception e) {

System.out.println("可能发生一些未知的异常");

}

}

}

 

总结try-catch

关键词try后的一对大括号将一块可能发生异常的代码包起来，称为监控区域。Java方法在运行过程中出现异常，则创建异常对象。将异常抛出监控区域之 外，由Java运行时系统试图寻找匹配的catch子句以捕获异常。若有匹配的catch子句，则运行其异常处理代码，try-catch语句结束。

匹配的原则是：如果抛出的异常对象属于catch子句的异常类，或者属于该异常类的子类，则认为生成的异常对象与catch块捕获的异常类型相匹配。

 

1.6. 多层调用时控制台错误信息如何分析

l 第一行显示异常的根本原因，距离异常最接近的方法。

l 最后一行是首先被调用的方法。

l 对于堆栈信息而言，从下往上排查

举例：

/**

 * 如何分析异常信息

 * @author Administrator

 *

 */

class Demo{

private String name;

private int age;

public String getName() {

return name;

}

 

public void setName(String name) {

this.name = name;

}

 

public int getAge() {

return age;

}

 

public void setAge(int age) {

this.age = age;

}

 

public Demo() {

}

public Demo(String name,int age) {

super();

this.name = name;

this.age = age;

}

 

public void calNum(int a,int b){

calNum2(a,b);

}

public void calNum2(int a,int b){

System.out.println("两数的商位："+a/b);

}

public void showInfo(Demo d){

showInfo2(d);

}

public void showInfo2(Demod){

System.out.println("年龄："+d.getAge()+",姓名："+d.getName());

}

}

public class Test06 {

public static void main(String[] args) {

/*Demo d = new Demo();

d.calNum(10, 0);*/

//Demo d2 = new Demo("张三",18);

Demo d = new Demo();

Demo d2 = null;

d.showInfo(d2);

}

}

1.7. 多种异常、一并处理

catch (ArithmeticException e)

catch(InputMismatchException e)

字符串转数字遇到异常如何处理？

NumberFormatException

数组下标越界如何处理？

ArrayIndexOutOfBoundsException

注意：一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。

1.8. try catch finally语法

try-catch语句还可以包括第三部分，就是finally子句。它表示无论是否出现异常，都应当执行的内容。

格式：

 

 

 

示例：

/**

 * 异常处理机制1

 * 如果在执行finally代码块之前，前面的语句中出现了return，那么finally还执不执行？说出执行顺序

 * 执行，先执行finally代码块，finally执行结束后，再执行return，退出程序。

 * @author Administrator

 *

 */

public class Test026 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

try {

System.out.print("请输入被除数：");

int num1 = input.nextInt();

System.out.print("请输入除数：");

int num2 = input.nextInt();

int result = num1 / num2;

System.out.println("两个数的商为：" + result);

return;

} catch (InputMismatchException e) {

e.printStackTrace();

System.out.println("详细信息："+e.getMessage());

System.out.println("被除数或者除数只能是数字!");

//return;

} catch (ArithmeticException e) {

e.printStackTrace();

System.out.println("详细信息："+e.getMessage());

System.out.println("除数不能为0！");

} catch (Exception e) {

System.out.println("可能发生一些未知的异常");

}finally{

System.out.println("谢谢使用!");

}

}

}

注意：

（1）try中出现异常，异常代码之后的代码不会被执行，程序进入catch中，如果找到对应的异常处理程序就处理异常，如果没有找到对应的异常处理程序就终止程序。

（2）try中没有出现异常，catch不会执行。

（3）多个catch会按照从上往下的顺序逐个匹配异常，如果都匹配不上会导致找不到处理程序程序终止，所以最后一个要有Exception

1.9. 总结try、catch、finally

l try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。

l catch 块：用于处理try捕获到的异常。

l finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：

1）在finally语句块中发生了异常。

2）在前面的代码中用了System.exit(n)退出程序。

3）程序所在的线程死亡。

4）关闭CPU。

示例：

/**

 * 异常处理机制1

 * 什么情况下finally里不执行，

 * 情况1.假设在执行finally之前，前面出现了System.exit(n);终止虚拟机 强制终止程序

 * System.exit(1);异常终止  System.exit(0);正常终止

 * 情况2.在finally语句块中发生了异常。

 * @author Administrator

 *

 */

public class Test025 {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

try {

System.out.print("请输入被除数：");

int num1 = input.nextInt();

System.out.print("请输入除数：");

int num2 = input.nextInt();

int result = num1 / num2;

System.out.println("两个数的商为：" + result);

//强制退出程序

//System.exit(1);

} catch (InputMismatchException e) {

e.printStackTrace();

System.out.println("详细信息："+e.getMessage());

System.out.println("被除数或者除数只能是数字!");

//System.exit(1);

} catch (ArithmeticException e) {

e.printStackTrace();

System.out.println("详细信息："+e.getMessage());

System.out.println("除数不能为0！");

} catch (Exception e) {

System.out.println("可能发生一些未知的异常");

}finally{

//凡是爆发异常的地方，代码都会终止往下执行

System.out.println(Integer.parseInt("afafw"));

System.out.println("谢谢使用!");

}

}

}

面试题：try-catch块中存在return语句，是否还执行finally块，如果执行，说出执行顺序

面试题：举例说明何种情况下不执行finally代码块

1.10. 获得异常信息

//输出栈中的详细信息

e.printStackTrace();

//详细消息字符串

e.getMessage()

1.11. 使用throws声明并抛出异常

任何Java代码都可以抛出异常

如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。例如汽车在运行时可能会出现故障，汽车本身没办法处理这个故障，那就让开车的人来处理。

throws语句用在方法定义时声明该方法要抛出的异常类型，如果抛出的是Exception异常类型，则该方法被声明为抛出所有的异常。多个异常可使用逗号分割。throws语句的语法格式为：

访问修饰符 返回值类型方法名（参数列表） throws 异常1,异常2...

{  

}  

方法名后的throws 异常1,异常2...为声明要抛出的异常列表。当方法抛出异常列表的异常时，方法将不对这些类型及其子类类型的异常作处理，而抛向调用该方法的方法，由他去处理。

 

注意：两种方式：方式一：调用者处理异常

方式二：调用者继续抛出异常（main()方法声明的异常由java虚拟机处理）

使用throws关键字将异常抛给调用者后，如果调用者不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的调用者。

举例：

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.InputMismatchException;

import java.util.Scanner;

public class Demo {

/**

 * 抛出异常

 * @param timeStr

 * @throws ParseException

 */

public void parseTime(String timeStr)throws ParseException{

DateFormat df = new SimpleDateFormat("yyyy-MM-dd");

Date date = df.parse(timeStr);

}

/**

 * parseDate()是parseTime()方法调用者，这个时候必须throws抛出或者try-catch捕获，编译器能够检测到的异常

 * @throws ParseException

 */

public void parseDate()throws ParseException{

parseTime("2014-5-6");

}

/**

 *

 * @throws InputMismatchException

 * @throws ArithmeticException

 */

public void calShang()throws InputMismatchException,ArithmeticException{

Scanner input = new Scanner(System.in);

System.out.print("请输入被除数：");

int num1 = input.nextInt();

System.out.print("请输入除数：");

int num2 = input.nextInt();

int result = num1/num2;

System.out.println("两个数的商为："+result);

}

/**

 * 调用者跟着抛出

 * calResult()作为calShang()方法的调用者，如果没有抛出2个异常，编译器检测不到，为什么？calShang()抛出的不可查异常

 */

public void calResult()throws InputMismatchException,ArithmeticException{

calShang();

}

/**

 * calResult2()作为calShang()调用者，选择了捕获处理异常

 */

public void calResult2(){

try{

calShang();

}catch(InputMismatchException e){

System.out.println("只能输入数字");

}catch(ArithmeticException e){

System.out.println("除数不能为0");

}

}

}

public class Test01 {

/**

 * main作为调用者并没有处理掉，而是继续向上抛出，最终如果有异常，jvm来处理

 * @param args

 * @throws ParseException

 */

/*public static void main(String[] args) throws ParseException {

Demo d = new Demo();

d.parseTime("2012a-3-4");

}*/

/**

 * main作为调用者，直接处理掉该方法抛出的异常

 */

public static void main(String[] args) {

Demo d = new Demo();

try {

d.parseTime("2012a-3-4");

} catch (ParseException e) {

//e.printStackTrace();

System.out.println("出错信息为："+e.getMessage());

}

}

}

1.12. 异常处理的三大规则

l 如果是不可查异常（unchecked exception），即RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

l 必须声明方法可抛出的任何可查异常（checked exception）。如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误。

l 仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。

1.13. 使用throw抛出异常(重点)

throw总是出现在方法体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用方法中）从里向外寻找含有与其匹配的catch子句的try块。

public  返回值类型  方法名()  throws Exception(){

。。。。throw new Exception(“错误提示信息”)

}

语法

throw new 异常类的名称;

例如：

throw new IOException;

throw new Exception("这个用户是智障");

例题：throw手动抛异常

/**

 * 异常处理机制-3

 * throw和throws配合使用，手动抛出异常

 * 访问修饰符  返回值类型  方法名（参数列表）throws 异常a{

 * .....

 *  throw new 异常a（"异常的详细消息"）；

 * }

 * throw手动抛出异常，一条单独的语句，必须和throws配合使用

 * @author Administrator

 *

 */

public class Student {

private String name; //姓名

private int age;//年龄

private String sex; //性别

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age)throws Exception {

if(age<=0 || age>120){

throw new Exception("年龄范围不正确!");

/*Exception e = new Exception("年龄不正确!");

throw e;*/

}

this.age = age;

}

public String getSex() {

return sex;

}

/**

 * 方式1：

 * @param sex

 * @throws Exception

 */

/*public void setSex(String sex) throws Exception {

if(!sex.equals("男") && !sex.equals("女")){

throw new Exception("性别不正确");

}

this.sex = sex;

}*/

/**

 * 方式2：

 */

/*public void setSex(String sex) throws Exception {

if(sex.equals("男") || sex.equals("女")){

this.sex = sex;

return;

}

throw new Exception("性别不正确");

}*/

/**

 * 方式3：

 * @param sex

 * @throws Exception

 */

public void setSex(String sex)throws Exception {

if(sex.equals("男") || sex.equals("女")){

this.sex = sex;

}else{

throw new Exception("性别不正确");

}

}

public Student() {

}

@Override

public String toString() {

return "[姓名="+this.name+",年龄="+this.age+",性别="+this.sex+"]";

}

}

/**

 * java.lang.Exception: 年龄范围不正确!

 * @author Administrator

 *

 */

public class TestStudent {

public static void main(String[] args){

Student stu = new Student();

stu.setName("张三");

try {

stu.setAge(180);

} catch (Exception e) {

e.printStackTrace();

System.out.println("出错信息："+e.getMessage());

}

try {

stu.setSex("人妖");

} catch (Exception e) {

//e.printStackTrace();

System.out.println("出错信息："+e.getMessage());

}

System.out.println(stu);

}

}

抛出异常后

如果抛出了检查异常，则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者必须检查处理抛出的异常。

如果所有方法都层层上抛获取的异常，最终JVM会进行处理，处理也很简单，就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException，则该方法的调用者可选择处理该异常。

throw  和 throws 对比

throw

throws

生成并抛出异常

声明方法内抛出了异常

位于方法体内部，可作为单独语句使用

必须跟在方法参数列表后面，不能单独使用

抛出一个异常对象，且只能是一个

声明抛出异常类型，可以跟多个异常

 

1.14. 自定义异常(重点)

使用自定义异常的步骤：

1.定义异常类(继承 或者Throwable类，或者Exception类或者RuntimeException类)

2.编写构造方法，继承父类的实现

3.实例化自定义异常对象 MyException e = new MyException(“年龄范围不正确!”);

4.使用throw抛出  throw e;    //throw new MyException(“年龄范围不正确”);

package com.njwb.exception04;

/**

 * 自定义异常类 定义方式1

 *  public Exception()

 *  public Exception(String message) 用于写自定义异常

 *

 * @author Administrator

 *

 */

public class MyException  extends Exception{

/**

 * 编写自己的构造方法，调用父类的带参构造

 * @param message

 */

public MyException(String message){

super(message);

}

}

/**

 * 自定义异常类 定义方式2

* @author Administrator

*/

public class MyException  extends Exception{

private String msg;

/**

 * 编写自己的构造方法，调用父类的带参构造

 * @param message

 */

public MyException(String message){

super(message);

this.msg = message;

}

@Override

public String getMessage() {

return "自定义异常类重写的："+this.msg;

}

}

 

1.15. 异常链

A方法调用B方法时，B方法却抛出了异常。那么A方法是继续抛出原有的异常还是抛出一个新异常？

若抛出原有的异常，因为A方法和B方法进行了关联，不便于代码的修改和扩展。若抛出新的异常，虽然解决了A方法和B方法的关联问题，但是原有的异常信息会丢失。JDK1.4以后出现了异常链，异常链的出现正是解决这个问题的，虽然创建了新的异常，但却保留了原有异常的信息。

public Exception(String message, Throwable cause)

public Exception(Throwable cause)

 

public void setSex(String sex)throws Exception {

if(!sex.equals("男") && !sex.equals("女")){

MyException my = new MyException("性别不正确!");

Exception e = new Exception("性别可能设置有问题",my);

throw e;

}

this.sex = sex;

}

java.lang.Exception:性别可能设置有问题

at com.njwb.exception06.Student.setSex(Student.java:32)

at com.njwb.exception06.TestStudent.main(TestStudent.java:18)

Caused by: com.njwb.exception06.MyException:性别不正确!

at com.njwb.exception06.Student.setSex(Student.java:31)

... 1 more

解释：Exception异常对象在携带自身异常信息的同时，又携带了其他异常对象的信息

1.16. Java常见异常

runtimeException子类

（1） java.lang.ArrayIndexOutOfBoundsException数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。

（2） java.lang.ArithmeticException算术条件异常。譬如：整数除零等。

（3） java.lang.NullPointerException空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等

（4） java.lang.ClassNotFoundException找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。

（5） java.lang.NegativeArraySizeException  数组长度为负异常

（6） java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

（7） java.lang.SecurityException 安全性异常

（8） java.lang.IllegalArgumentException 非法参数异常

IOException

（1） IOException 操作输入流和输出流时可能出现的异常。

（2） EOFException   文件已结束异常

（3） FileNotFoundException   文件未找到异常

其他

（1） ClassCastException    类型转换异常类

（2） ArrayStoreException  数组中包含不兼容的值抛出的异常

（3） SQLException   操作数据库异常类

（4） NoSuchFieldException   字段未找到异常

（5） NoSuchMethodException   方法未找到抛出的异常

（6） NumberFormatException    字符串转换为数字抛出的异常

（7） StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常

（8） IllegalAccessException  不允许访问某类异常

（9） InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常