黑马程序员——异常处理

                                                                       --------------------- android培训、java培训、期待与您交流！ ---------------------- 

一丶异常

1、异常就是程序在运行时出现不正常情况。

2、异常由来：问题也是现实生活中一个具体事物，也可以通过java的类的形式进行描述，并封装成对象。

      java对不正常情况进行描述后的对象体现。

3、问题的划分:两种----①严重的问题②非严重的问题。

      对于严重的：java通过error类进行描述，对于error一般不编写针对性的代码对其进行处理。

      非严重的：java通过Exception类进行描述，对于Exception可以使用针对性的处理方式进行处理。

4、异常处理：

try
{
需要被检测的代码
}
catch(异常类 变量)
{
处理异常的代码；（处理方式）
}
finally
{
一定会执行的语句
}

5、对捕获到的异常对象进行常见方法操作。jvm默认的异常处理机制就是调用printStackTrace方法

6、有可能出现问题时在功能上用throws关键字声明改功能有可能出现问题。

class Demo
{
int div(int a,int b)throws Exception
{
return a/b;
}
}

class ExceptionDemo
{
public static void main(String[] args)//throws Exception可以不用try捕获，直接抛出给下一个调用者，不过一般情况不这样执行。
{
Demo d=new Demo();
try
{
int x=d.div(4,1);
System.out.println("x="+x);
}
catch(Exception e)
{
System.out.println("e.toString()");
}

System.out.println(over);
}
}

7、多异常处理

/*
声明异常时，建议声明更为具体的异常，这样处理的可以更具体。
声明几个异常，就对应有几个catch块，如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面
建议进行catch处理时，catch中一定要定义具体处理方式。
*/
class Demo
{
int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//声明两个异常
{
int[] arr=new int[a];
System.out.println(arr[4]);
return a/b;
}
}

class ExceptionDemo1
{
public static void main(String[] args)
{
Demo d=new Demo();
try
{
int x=d.div(4,1);
System.out.println("x="+x);
}
//与之对应的catch
catch(ArithmeticException e)
{
System.out.println("e.toString()");
System.out.println("除数为零！");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("e.toString()");
System.out.println("角标越界！");
}

System.out.println(over);
}
}

8、自定义异常

/*
项目中会出现特有的问题，而java中没有描述进行封，所以对这些特有问题可以按照java的对问题封装的思想将特有的问        题进行自定义异常封装
需求：在本程序中，除数不能是负数，那么需要对这个问题进行自定义的描述。
当在函数内部出现了throw抛出异常对象，那么必须要给对应的处理动作。
要么在内部try cathc处理，要么在函数上声明让调用者处理。
一般情况，函数内出现异常，函数上需要声明
自定义异常必须是自定义类继承Exception
继承Exception原因：
异常体系有一个特点：异常类和异常对象都被抛出，都具有可抛性，这个可抛性是Throwable这个体系中独有的特点。
自定义异常：如果该异常的发生，无法再继续进行运算，就让该异常继承RuntimeException。
*/
class FuShuException extends RuntimeException
{
private int value;
//private String msg;
FuShuEception(String msg,int value)
{
//this.msg=msg;
super(msg);
this.value=value;
}
/*
public String getMessage()
{
return msg;
}
*/
public int getValue()
{
return value
}
}

class Demo
{
int div(int a,int b)//throws FuShuException
{
if(b<0)
throw new FuShuException("出现了除数是负数的情况------ /by fushu",b);//手动通过throw关键字抛出一个自定义异常对象
return a/b;
if(b==0)
throw new FuShuException("被除零啦！");
return a/b;
}
}

class ExceptionDemo2
{
public static void main(String[] args)
{
Demo d=new Demo();
//try
//{
int x=d.div(4,1);
System.out.println("x="+x);
//}
//与之对应的catch
/*
catch(FuShuExceptiont e)
{
System.out.println("e.toString()");
//System.out.println("除数出现负数了！");
System.out.println("负数是："+e.getValue());
}
*/
System.out.println(over);
}
}

9、throws和throw的区别

/*
throws使用在函数上。后面跟的异常类，可以跟多个用逗号隔开
throw使用在函数内。后面跟的是异常对象。
*/

10、RuntimeException异常

/*
Exception中有一个特殊子类异常RuntimeException运行时异常，如果在函数内抛出该异常，函数
上可以不用声明。可能在执行方法期间抛出但未被捕获的 RuntimeException 的任何子类都无需在 throws 子句中进行声明。
如果在函数上声明了该异常，调用者可以不用处理。
1.编译时被检测的异常。
2.编译时不被检测的异常（运行时异常，RuntimeException以及其子类）
*/

11、异常练习示例代码

/*
毕老师用电脑上课
上课出现的问题：电脑蓝屏，电脑冒烟
要对问题进行描述，封装成对象
当冒烟发生后，讲课进度无法继续，出现了讲师的问题，课时计划无法完成
*/
class LanPingException extends Exception
{
LanPingException(String message)
{
super(message);
}
}

class MaoYanException extends Exception
{
MaoYanException(String message)
{
super(message);
}
}

class NoPlanException extends Exception
{
NoPlanException(String msg)
{
super(msg);
}
}

class Computer
{
private int state=1;
public void run()throws LanPingException,MaoYanException
{
if(state==2)
throw new LanPingException("蓝屏");
if(state==3)
hrow new MaoYanException("冒烟");
System.out.println("电脑运行");
}

public void reset()
{
state=1;
System.out.println("电脑重启");
}
}

class Teacher
{
private String name;
private Computer cmpt;

Teacher(String name)
{
this.name=name;
cmpt=new Computer();
}

public void prelect()throws NoPlanException
{
try
{
cmpt.run();
}
catch(LanPingException e)
{
cmpt.reset();
}
cat
4000
ch(MaoYanException e)
{
test();
throw new NoPlanException("课时无法继续"+e.getMessage());//throw下面不能写执行语句，throw抛出异常，程序已经停止，后面的代码可定无法执行
//test();
}

System.out.println("讲课");
}

public void test()
{
System.out.println("lianxi");
}
}

class ExceptionTest
{
public static void main(String[] args)
{
Teacher t=new Teacher("毕老师");
try
{
t.prelect();
}
catch(NoPlanException e)
{
System.out.println(e.toString());
System.out.println("换老师或者放假");
}
}
}

二丶异常-finally

1、finally中的代码一定会被执行

2、通常用于关闭资源

3、try{}finally{}格式也行

4、catch是用于处理异常，如果没有catch说明异常没有被处理过，如果该异常是检测时异常，那么必须声明。

三丶异常的覆盖

1、子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。

2、如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。

3、如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常，如果子类方法发生了异常

      必须利用try()catch{}在内部处理,绝对不能抛出。

4、练习代码：

/*
有一个圆形和长方形
都可以获取面积，对于面积如果出现非法的数据，视为是获取面积出现问题
问题通过异常来表示
基本设计
*/
class NoValueException extends RuntimeException
{
NoValueException(String message)
{
super(message);
}

}

interface Shape
{
void getAre();
}

class Rec implements Shape
{
private int len,wid;

Rec(int len,int wid)throws NoValueException
{
if(len<=0||wid<=0)
throw new NoValueException("出现非法值");
this.len=len;
this.wid=wid;
}

public void getAre()
{
System.out.println(len*wid);
}
}

class ExceptionTest1
{
public static void main(String[] args)
{

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

System.out.println("over");
}
}

四丶异常总结

1、对问题的描述，将问题进行对象的封装

2、异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性

也就是说可以通过throw和throws关键字操作，只有异常体系具备这个特点

3、thow和throws的区别

4、当函数内容有throw抛出异常对象，并未进行处理，必须要在函数上声明，否则编译失败

      RuntimeException除外

5、如果函数声明了异常，调用者需要进行处理，处理方法可throws可try

6、编译时被检测异常和运行时异常（编译时不检测）

7、异常处理语句finally中只有一种情况执行不到，前面代码中含有Syste.m.exit(0);//系统退出代码

8、自定义异常：定义类继承Exception或者RuntimeException

       让该类具备可抛性；让该类具备操作异常的共性方法。

       当要定义自定义异常的信息时，可以使用父类已经定义的功能

        将异常信息传递给父类的构造函数

9、自定义异常：按照java的面向对象细想，见程序中出现的特有问题进行封装

10、异常的益处：

        将问题进行封装

                        将正常历程代码和问题处理代码相分离，方便阅读

11、catch：其中需要定义针对性的处理方式  

12.当捕捉到的异常，功能不能处理时，可以继续在catch中抛出

     如果该异常不能处理，但并不属于该功能出现的异常，可以讲该异常转换后，再抛出和该功能相关的异常

                     或者异常可以处理，当需要将异常产生产生的和本功能相关的问题提供出去，当调用者知道，并处理，也可以将捕获异                               常处理          后，转换新的异常 

 

13、异常的注意事项：

            在子父类覆盖时：

                    子类抛出的异常必须是父类的异常的子类或者子集

                    如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

                                                                       --------------------- android培训、java培训、期待与您交流！ ---------------------- 

                                                                                                    详细请查看：http://edu.csdn.net/heima