程序员学习 异常

异常概述：

异常：异常就是Java程序在运行过程中出现的错误。

异常由来：问题也是现实生活中一个具体事务，也可以通过java 的类的形式进行描述，并封装成对象。其实就是Java对不正常情况进行描述后的对象体现。

我们见过的异常,角标越界异常,空指针异常

异常分类：

异常分类图解：

 

异常举例:

除数为0

数组访问越界

 

异常处理方案：

异常处理方案

try…catch…finally

throws

 

try…catch处理方式

一个异常的情况

多个异常的情况

平级情况

存在上下级的情况

JDK7的新特性及注意事项

Java中的异常被分为两大类：编译时异常和运行时异常。所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常

编译时异常

Java程序必须显示处理，否则程序就会发生错误，无法通过编译

运行时异常

无需显示处理，也可以和编译时异常一样处理

Throwable中的方法

getMessage()

获取异常信息，返回字符串。

toString()

获取异常类名和异常信息，返回字符串。

printStackTrace()

获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

printStackTrace(PrintStream s)

通常用该方法将异常内容保存在日志文件中，以便查阅。 

Throws

定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在方法上标识。

举例分别演示编译时异常和运行时异常的抛出

throw

 

在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

举例分别演示编译时异常对象和运行时异常对象的抛出

 

 

throws和throw的区别

throws

用在方法声明后面，跟的是异常类名

可以跟多个异常类名，用逗号隔开

表示抛出异常，由该方法的调用者来处理

throws表示出现异常的一种可能性，并不一定会发生这些异常

throw

用在方法体内，跟的是异常对象名

只能抛出一个异常对象名

表示抛出异常，由方法体内的语句处理

throw则是抛出了异常，执行throw则一定抛出了某种异常  
例如：/*

throw和throws的区别？

 

1，throw用在函数内。

throws用在函数上。

2，thorw抛出的是异常对象。

throws用于进行异常类的声明，后面异常类可以有多个，用逗号隔开。

 

 

 

*/

 

class Demo

{

void show()throws Exception

{

throw new Exception();

}

}

 

class  

{

public static void main(String[] args) 

{

System.out.println("Hello World!");

}

}

 

finally的特点作用及面试题

 

finally的特点

被finally控制的语句体一定会执行

特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

finally的作用

用于释放资源，在IO流操作和数据库操作中会见到

finally相关的面试题

final,finally和finalize的区别

如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后。

自定义异常

考试成绩必须在0-100之间

很明显java没有对应的异常，需要我们自己来做一个异常

自定义异常举例：

lass NoAgeException extends RuntimeException

{

/*

为什么要定义构造函数，因为看到Java中的异常描述类中有提供对问题对象的初始化方法。

*/

NoAgeException()

{

super();

}

 

NoAgeException(String message)

{

super(message);// 如果自定义异常需要异常信息，可以通过调用父类的带有字符串参数的构造函数即可。

}

}

 

class Person

{

private String name;

private int age;

Person(String name,int age)

{

//加入逻辑判断。

if(age<0 || age>200)

{

throw new NoAgeException(age+",年龄数值非法");

}

this.name = name;

this.age = age;

}

//定义Person对象对应的字符串表现形式。覆盖Object中的toString方法。

public String toString()

{

return "Person[name="+name+",age="+age+"]";

}

}

 

 

 

class ExceptionDemo5 

{

public static void main(String[] args) 

{

Person p = new Person("xiaoming",-20);

System.out.println(p);

}

}

 

举例2：

 

/*

描述长方形，

属性：长和宽。

行为：获取面积。

 

考虑健壮性问题。

万一长和宽的数值非法。

描述问题，将问题封装成对象，用异常的方式来表示。

*/

/*

不知道要继承编译时异常还是运行时异常。

 

*/

class NoValueException extends RuntimeException

{

NoValueException()

{

super();

}

NoValueException(String message)

{

super(message);

}

 

}

 

class Rec

{

private int length;

private int width;

Rec(int length,int width)

{

if(length<=0 ||width<=0)

{

//抛出异常，但是不用声明，不需要调用者处理。就需要一旦问题发生让调用者端停止，让其修改代码。

throw new NoValueException("长或者宽的数值非法");

}

this.length = length;

this.width = width;

}

/**

定义面积函数。

*/

public int getArea()

{

return length*width;

}

 

}

class  ExceptionTest

{

public static void main(String[] args) 

{

 

Rec r = new Rec(-3,4);

int area = r.getArea();

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

 

 

 

}

}

 

 

/*

案例二：毕老师用电脑讲课。

两个对象：

老师：

属性：姓名。

行为：讲课。

电脑：

行为：运行。

 

考虑问题。

1，电脑蓝屏-->异常。

 

2，电脑冒烟-->异常。

 

*/

// 可以声明，让调用给出处理方式。

class LanPingException extends Exception

{

LanPingException()

{

super();

}

LanPingException(String message)

{

super(message);

}

}

 

class MaoYanException extends Exception

{

MaoYanException()

{

super();

}

MaoYanException(String message)

{

super(message);

}

}

举例三：

/*

讲课中冒烟，问题可以临时解决，是冒烟问题没有直接处理，所以就使用throws声明。

但是发现，这个问题不应该属于讲课的问题。调用讲课方法的调用者是处理不了这个冒烟问题的。

该调用者能处理的应该是冒烟导致的课程进行不下去的问题。

应该在列出一个异常。课时停止异常。

 

*/

class NoPlanException extends Exception

{

NoPlanException()

{

super();

}

NoPlanException(String message)

{

super(message);

}

}

 

 

class NoteBook

{

private int state = 2;

public void run()throws LanPingException,MaoYanException//方法上可以通过throws声明多个异常。

{

System.out.println("笔记本电脑运行");

if(state == 1)

throw new LanPingException("电脑蓝屏了");

 

if(state == 2)

throw new MaoYanException("电脑冒烟了");

}

public void reset()

{

state = 0;

System.out.println("电脑重启");

}

}

class Teacher

{

private String name;

private NoteBook book;

Teacher(String name)

{

this.name = name;

book = new NoteBook();

}

//讲课。

public void prelect()throws NoPlanException

{

/*

调用到了声明异常的方法，在这里到底是捕获好呢？还是声明好呢？

有具体的捕获处理方式吗？有，那就捕获，没有，那么声明。

我可以处理，重启就可以了，重启是电脑的功能。

*/

try

{

book.run();//对于声明多个异常的方法，在处理，需要定义多个catch与之对应。

}

catch (LanPingException e)//LanPingException e = new LanPingException("电脑蓝屏了");

{

//重启。

System.out.println(e.toString());//异常的名称+异常的信息。

// e.printStackTrace();

book.reset();

}

catch(MaoYanException e)//MaoYanException e = new MaoYanException("电脑冒烟了");

{

System.out.println(e.toString());

test();

//冒烟问题没有解决，继续声明throws出去。

// throw e;

// new 电脑维修部(book);//去修电脑。

// book = new NoteBook();

throw new NoPlanException(e.getMessage()+",课时停止");//异常转换。

 

 

}

System.out.println(name+"....讲课");

}

//留练习。

public void test()

{

System.out.println("做练习");

}

}

 

class ExceptionTest2 

{

public static void main(String[] args) 

{

Teacher t = new Teacher("毕老师");

try

{

t.prelect();

}

catch (NoPlanException e)

{

System.out.println(e.toString());

System.out.println("换老师");

}

System.out.println("Hello World!");

}

}