----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
Uncheck类型的异常包括RuntimeException 以及他的子类。
Check类型的异常包括exception这个类，以及exception除了RuntimeException的子类。如果抛出的是check异常，则必须进行try，catch处理。try ,catch,finally. 如果try里边的内容无异常，则不执行catch，否则则执行，最后执行finally一定执行，相当于异常的出口。
如果对于一个函数 throws 异常，那么调用这个函数的地方要对其进行处理。
先编写一个User类
class User {
private int age;
public void SetAge(int age) throws Exception{
if(age<0){
Exception e = new Exception("年龄不能为负数");
throw e;
}
this.age=age;
}
}
.......................................................................................
再编写一个test类
class test {
public static void main(String args[]) {
User tony = new User();
try {
tony.SetAge(-20);
} catch (Exception e) {
e.printStackTrace();
}
}
}
异常详解
异常是什么呢？异常就是程序在运行时出现不正常情况。
异常怎么由来的呢？问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。其实就是java对不正常情况描述后的对象体现。
对于问题的划分，总共两种：
a） 严重的问题：java通过Error类进行描述，对于Error一般不编写针对性的代码对其处理
b） 非严重的问题，java通过Exception类进行描述，对于Exception可以使用针对性的处理方式进行处理
无论Error或者Exception都具有一些共性内容，比如不正常情况的信息，引发原因等。这些共性的内容就Throwable,它是Error和Exception的父类
异常的处理
try-catch语句
对于异常我们怎么处理呢？java提供了特有的语句（try-catch）进行处理。格式如下：
try{
需要被检测的代码
}catch(异常类变量)｛
处理异常的代码；（处理方式）
｝finally｛
一定会执行语句；
｝
蓝色部分可以省略不写
例如我们对以下代码除零抛出算数异常进行处理;
处理前：
class ExceptionTest
{
public static void main(String[] args)
{
Demo d=new Demo();
int x=d.div(3,0);
System.out.println(x);//抛出ArithmeticException异常
}
}
class Demo
{
public int div(int a,int b){
return a/b;
}
处理后（使用try-catch）：
class ExceptionTest
{
public static void main(String[] args)
{
Demo d=new Demo();
try{
int x=d.div(3,0);
System.out.println(x);//异常后，这段代码不执行
}catch(Exception e){ //Exception e =new ArithmeticException();
System.out.println("嗨，除零了");
}
}
}
class Demo
{
public int div(int a,int b){
return a/b;
}
}
对于这个以上Exception e其实是吧new ArithmeticException();对象传给了形参e，就形成了多态。Exception e =new ArithmeticException();对于catch捕获到的异常对象常见的方法操作是什么呢？
a） 获取异常信息：public String getMessage()：返回此 throwable 的详细消息字符串
b） public String toString()：返回此 throwable 的简短描述
c） public void printStackTrace()：将此 throwable 及其追踪输出至标准错误流。
对于这三种常见方法我们来看看如下代码：
class ExceptionTest
{
public static voidmain(String[] args)
{
Demo d=new Demo();
try{
int x=d.div(3,0);
System.out.println(x);
}catch(Exception e){
System.out.println(e.getMessage()); // /byzero
System.out.println(e.toString());//异常名称：异常信息
e.printStackTrace();//异常名称，异常信息，异常所出现的位置
//其实jvm默认的异常处理机制，就是在调用printStackTrace()方法，打印异常的堆栈的跟踪信息
}
}
}
class Demo
{
public int div(int a,intb){
return a/b;
}
}
异常声明throws关键字
throws关键字在功能上通过throws的关键字声明了该功能有可能出现问题。会提示你去如何让解决该功能如何解决？不解决编译错误。如以下代码：
classThrowsExceptionTest
{
public static void main(String[] args)
{
Demo d=new Demo();
int x=d.div(3,0);
System.out.println(x);
}
}
class Demo
{
public int div(int a,int b)throwsException{ //编译抛出异常
return a/b;
}
怎么解决编译错误呢？我们在main方法后面再加上)throws Exception{ 编译没错，如果运行出错，最终虚拟机会处理，程序结束。
我们还是使用try-catch来处理这种异常，记住throws什么名称的异常，try-catch语句里就处理什么异常，如以下代码：
class Demo
{
public int div(int a,int b)throws ArithmeticException{ //抛出什么异常
return a/b;
}
}
classThrowsExceptionTest
{
public static void main(String[] args)
{
try{
Demo d=new Demo();
int x=d.div(3,0);
System.out.println(x);
}catch(ArithmeticExceptione){ //处理什么异常
System.out.println(e.toString());
}
}
}
多异常处理
我们在处理异常时，我们有如下建议：
a) 声明异常时，建议声明更为具体的异常。这样处理的可以更具体
b) catch里面应该有针对性的异常处理，不要把一切交给父异常Exception处理。甚至不使用，出错了就停止程序，我们去处理程序。为了代码的严谨性。
c) 对方声明几个异常，就对应有几个catch块，如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面，不要定义多余的catch块。
d) 建议在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句e.printSrackTrace(),也不要简单的就书写一条输出语句。在实际开发中我们要对异常进行处理。
我们看看多异常处理的代码：
class Demo
{
public int div(int a,intb)throws ArithmeticException,ArrayIndexOutOfBoundsException{
/*
数组越界异常
*/
int[] array=newint[a];
System.out.println(array[2]);
/*
除零异常
*/
return a/b;
}
}
class ThrowsExceptionTest
{
public static voidmain(String[] args)
{
try{
Demo d=new Demo();
int x=d.div(3,0);
System.out.println(x);
}catch(ArithmeticExceptione){
System.out.println(e.toString()); //处理除零异常
System.out.println("除零了");
}catch(ArrayIndexOutOfBoundsExceptione){ //处理数组越界异常
System.out.println(e.toString());
System.out.println("数组越界异常");
}catch(Exception e){
System.out.println("otherException"); //实际不建议使用，且不能放在catch块第一行
}
}
}
自定义异常
什么是自定义异常？因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想，将特有的问题，进行自定义的异常封装。
我们如何去自定义异常呢？
我们看一下以下程序的需求，在这段程序中，对与除数是-1，也视为是错误的是无法进行运算的。那么就需要对这个问题进行自定义的描述。
classCustomException
{
public static void main(String[] args)
{
Divisor d=new Divisor();
try{
int num=d.divisor(4,-1);
System.out.println(num);
}catch(NegativeException e){
System.out.println(e.toString());
System.out.println("不能除以负数");
}
}
}
class Divisor
{
public int divisor(int a,int b) throws NegativeException{ //必须要抛出异常,否则编译错误
if(b<0){
throw new NegativeException(); //抛出自定义异常，使用throw
}
return a/b;
}
}
class NegativeException extends Exception //自定义除以负数异常
{
}
以上代码中，当在函数内部出现了throw关键字常对象，那么就必须要给对应的处理动作。要么在函数上声明让调用者处理。
一般情况下，函数内出现异常，函数上需要声明。
我们发现打印的结果中没有只有异常的名称，却没有异常的信息，因为自定义的异常并未自定义信息。
如何自定义异常信息呢？我们先看看如下代码？
classCustomException
{
public static void main(String[] args)
{
Divisor d=new Divisor();
try{
int num=d.divisor(4,-9);
System.out.println(num);
}catch(NegativeException e){
System.out.println(e.toString());
System.out.println("不能除以负数");
System.out.println("this is negative"+e.getValue()); //调用自定义方法
}
}
}
class Divisor
{
public int divisor(int a,int b) throws NegativeException{ //必须要抛出异常,否则编译错误
if(b<0){
throw new NegativeException("/by nagative",b); //抛出自定义异常，使用throw，
}
return a/b;
}
}
classNegativeException extends Exception //自定义除以负数异常
{
int value; //自定义一个值
NegativeException(String msg, intvalue){ //自定义构造方法
super(msg);//super调用父类中的构造方法
this.value=value;
}
public int getValue(){ //子类自定义一个获取方法
return value;
}
}
通过以上代码我们知道了如何自定义信息？因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类，是通过super语句，那么就可以直接通过getMessage方法获取自定义的异常信息。
总结：当我们自定义异常，必须是自定义类去继承Exception或者Throwable，Error。为什么要继承Exception呢，异常体系中有一个特点，因为异常类和异常对象都需要被抛出，他们都具备可抛性。这个可抛性是Throwable这个体系中独有的特点，只有这个体系中的类和对象才可以被throw和throws操作。
throws和throw的区别：
a) throws是使用方法上，throws后面跟的是异常类，可以跟多个，用逗号隔开
b) throw是使用在方法内，throw后跟的是异常对象。
RuntimeException
Exception中有一个特殊的子类异常RuntimeException运行时异常。它和别的异常有种特殊的意义在里面。
a） 如果在方法内容抛出该异常，方法上可以不用声明，编译也一样通过。
b） 如果在方法上声明了该异常，调用者可以不用进行处理。编译一样通过。
如以下例子：
classRuntimeExceptionTest
{
public static void main(String[] args)
{
Divisor2 d=new Divisor2();
int num=d.divisor(3,0);
System.out.println(num);
}
}
class Divisor2
{
public int divisor(int a,intb) {
if(b==0){
throw new ArithmeticException("除零了");//ArithmeticException是RuntiemException的子类，如果是new Exception程序出错
}
return a/b;
}
}
注意：我们之所以不用在方法上声明，是因为不需要让调用者处理。当该异常发生，我们希望该程序去停止？为什么呢？因为在运行时，出现了无法继续运算的情况，希望停止程序后，让我们程序员对代码进行修正。
我们来看看自定义异常去继承RuntimeException是什么情况？
class RuntimeExceptionTest
{
public static voidmain(String[] args)
{
Divisor2 d=newDivisor2();
intnum=d.divisor(3,-9);
System.out.println(num);
}
}
class Divisor2
{
public intdivisor(int a,int b) { //这里不用写throws CustomsException2
if(b<0){
throw new CustomsException2("除以负数啦");
}
if(b==0){
throw new ArithmeticException("除零了");//ArithmeticException是RuntiemException的子类
}
return a/b;
}
}
class CustomsException2 extends RuntimeException{ //自定义异常去继承RuntimeException
String msg;
CustomsException2(String msg){
this.msg=msg;
}
}
从以上代码可以总结：当我们自定义异常时，如果该异常的一旦发生，无法再继续进行运算，就让该自定义异常继承RuntimeException。
总结：对于异常我们分为两种：
a） 编译时被检测的异常
b） 编译时不被检测的异常（运行时异常，RuntimeException以及其子类）
finally代码块
finally代码块是用来定义一个一定执行的代码块，通常用于关闭资源。finally是一定会执行的
如以下例子：
classFinallyTest
{
public static void main(String[] args)
{
Demo d=new Demo();
try{
int num=d.method(4,0);
System.out.println(num);
}catch(Exception e){
System.out.println(e.getMessage());
}finally{ //这段代码一定会被执行
System.out.println("这段代码一定会被执行");
}
System.out.println("over");
}
}
class Demo
{
public int method(int a,int b){
return a/b;
}
}
关于异常处理的格式总共有三种：
第一个格式：
try{
}catch(){
}
第二个格式：
try{
}catch(){
}finally{
}
第三个格式：
try{
}finally{
}
记住一点：catch是用于处理异常，如果没有catch就代表异常没有被处理过，如果该异常是检测时异常，那么必须声明。
异常-覆盖
异常在子父类覆盖中的体现：
1. 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类
如以下代码：
class Father //父类
{
public void method() throwsFatherException{
}
}
class child extends Father //子类
{
public void method()throws ChildException{ //如果子类复写父类方法，必须抛父类已抛的异常
//或者是这个异常的子异常，不能抛其他异常。也可以不抛异常
}
}
class FatherException extends Exception //父异常
{
}
class ChildException extends FatherException //子异常
{
}
2. 如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集或者不抛异常
3. 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类发生异常，就必须进行try处理，绝对不能抛。
异常的总结
异常是什么？异常是对问题的描述。将问题进行对象的封装
异常体系：
Throwable
|--Error
|--Exception
|--RuntimeException
异常体系中的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作。只有异常体系具备这个特点。
throw和throws的用法：
a） throw定义在方法内，用于抛出异常对象，当方法内容有throw抛出异常对象，并未被进行try处理，必须要在方法上声明，否则都是编译失败，注意，RuntimeException除外，也就是说，方法内如果抛出的RuntimeException异常，方法上可以不用声明。如果方法声明了异常，调用者需要进行处理，处理方法可以throws可以try。
b） throws定义在方法上，用于抛出异常类，可以抛出多个，它们用逗号分隔开。
异常有两种：
a） 编译是被检测异常。该异常在编译时，如果没有处理（没有抛没有try），编译失败该异常被标识，代表这可以被处理
b） 运行时异常（编译时不检测）。在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止，需要对代码进行修正
异常处理语句：
第一个格式：
try{
}catch(){
}
第二个格式：
try{
}catch(){
}finally{
}
第三个格式：
try{
}finally{
}
注意：1. Finally中定义的通常是关闭资源代码，因为资源必须释放
2. finally只有一种情况不会执行。当执行到Syetem.exit（0）；finally不会执行。
自定义异常
定义类继承Exception或者RuntimeException
1. 为了让该自定义类具备可抛性
2. 让该类具备操作异常的共性方法
当药定义自定义异常的信息时，可以使用父类已经定义好的功能。
异常异常信息传递给父类的构造方法：
classMyException extends Exception
｛
MyException（String message）｛
super（message）；
｝
｝
自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装
异常的好处：
a） 将问题进行封装
b） 将正常流程代码和问题处理代码相分离，方便与阅读
异常的处理原则：
a） 处理方式有两种：try和throws
b） 调用到抛出异常的功能是，抛出几个，就处理几个。
一个try对应多个catch。
c） 多个catch，父类的catch放到最下面。
d） catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace，输出语句。也不要不写
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出
try｛
throw new AException
｝catch（）｛
throw e
｝
如果该异常处理不了，但并属于该功能出现的异常可以将异常转换后，在抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能的相关的问题提供出去，当调用者知道，并处理，也可以将捕获异常处理后，转换新的异常
try｛
throw new AException（）；
｝catch（AException）｛
//对AException先处理
throw new BException();
｝
比如说汇款的例子。
异常的注意事项：
在子父类覆盖时：
1. 子类抛出的异常必须是父类的异常的子类或者子集
2. 如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。
练习1:毕老师上课：
class ExceptionTest2
{
public static void main(String[] args)
{
Teacher t=new Teacher("毕老师");
try{
t.teach();
}catch(NoPlanException e){
System.out.println("换老师或者换电脑，放假");
}
}
}
classTeacher //老师
{
public static String name; //老师姓名
private Computer c;
Teacher(){
}
Teacher(String name){
this.name=name;
c=new Computer();
}
public void teach() throwsNoPlanException{
try{
c.run();
}catch(ComputerSmokingExceptione){
System.out.println(e.getMessage());
doTest();
throw new NoPlanException("课时无法继续");
}catch(ComputerBlueScreenExceptione){
System.out.println(e.getMessage());
c.reset();
}
System.out.println(name+"讲课");
}
public void doTest(){
System.out.println(Teacher.name+"让学生去做练习");
}
}
/*
变量state代表了电脑状态
0数字：电脑状态正常
1数字：电脑状态蓝屏
2数字：电脑状态冒烟
*/
classComputer //电脑
{
int state=2;
Teacher t=new Teacher();
public void run() throwsComputerBlueScreenException,ComputerSmokingException{
if (state==1) //电脑状态为1，蓝屏
{
throw newComputerBlueScreenException("电脑蓝屏了");
}else if(state==2){ //电脑状态为2，冒烟了
throw new ComputerSmokingException("电脑冒烟了");
}else if(state==0){
System.out.println("电脑正常运行");
}
}
public void reset(){
System.out.println(t.name+"重启电脑");
}
}
/*
自定义异常：
1.电脑冒烟异常
2.电脑蓝屏异常
3.课时无法继续异常
*/
class ComputerSmokingExceptionextends Exception //电脑冒烟异常
{
ComputerSmokingException(String msg){
super(msg);
}
}
classComputerBlueScreenException extends Exception//电脑蓝屏异常
{
ComputerBlueScreenException(Stringmsg){
super(msg);
}
}
class NoPlanExceptionextends Exception //课时无法继续异常
{
NoPlanException(String msg){
super(msg);
}
}
练习二：计算圆和长方形的面积
class Test2
{
public static void main(String[] args)
{
Rec r=new Rec(1,4);
r.area();
Circle c=new Circle(0);
c.area();
}
}
interface Shape{
public void area();
}
/*
长方形面积
*/
class Recimplements Shape
{
int wid,hei;//长方形的长和高
Rec(int wid,int hei){
if(wid<=0||hei<=0){
throw newIllegalValueException("非法字符");
}
this.wid=wid;
this.hei=hei;
}
public void area(){
System.out.println("长方形的面积area=="+wid*hei);
}
}
class Circleimplements Shape
{
int r;
private final static double PI=3.14;
Circle(int r){
if(r<=0){
throw new IllegalValueException("非法字符");
}
this.r=r;
}
public void area(){
System.out.println("三角形的面积是=="+r*PI);
}
}
classIllegalValueException extends RuntimeException //非法字符异常
{
IllegalValueException(String msg){
super(msg);
}
}
221
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
