黑马程序员_异常

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

 

异常:

异常是对问题的描述,将问题进行对象的封装

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

对于问题的划分:两种:一种是严重的问题,一种是非严重的问题

对于严重的,java通过Error类进行描述

对于Erro一般不编写针对性的代码进行处理

对于非严重的,java通过Exception类进行描述

           对于Exception编写针对性代码来运行

Exception有两种:

编译时被检测异常

该异常在编译时,如果没有处理(没有抛没有try),编译失败

该异常被标识,代表可以被处理

运行时异常(编译时检测)

在编译时,不需要处理,编译器不检查

该异常的发生,建议不处理,让程序停止,需要对代码进行修正

 

异常的处理原则:

   1处理方式有两种:try或throws

   2调用到抛出异常的功能时,抛出几个就处理几个

   3多个catch时父类catch放在最下面

   4catch内需要针对性的处理方式,不要简单的定义printStackTrace输出语句,也不要不写,当捕获到的异常,本功能处理不了时,可以继续在catch中抛出

1 异常处理

java 提供了特有的语句进行处理

try
{
         需要被检测的代码
}
catch
{
         处理异常的代码
}
final
{
         一定会执行的语句
}

2 对捕获异常信息的主要方法

e.toString();  e.getMessage();  e.tracetrack();

 

3 对多异常的处理

 1声明异常时建议声明具体的异常,这样处理的可以更具体

 2对方声明几个异常,就有几个catch块.不要定义多余的catch块

    如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面

 

4 自定义异常

  因为项目中会出现特有的问题,而这些问题并未被java缩描述并封装对象

  所以对这些特有的问题可以按照java的对问题封装的思想,将特有的问题进行自定义的异常封装

 

发现打印的结果只有异常名称,没有异常信息

因为自定义的异常并没有定义异常信息

 

5 如何定义异常信息呢?

  因为父类中已经把异常信息的操作都完成了

  所以子类只要在构造时,将异常信息传递给父类通过super语句

  那么就可以直接通过getMessage()方法获取自定义异常信息

 

自定义异常:

必须是自定义类继承Exception

继承Exception原因:

 异常体系有个特点:因为异常类和异常对象都被抛出,他们都具备可抛性,这个可抛性是Throwable这个体系中独有特点

只有这个体系中的类才可以被throws和throw操作.

/*
自定义异常例子1:
*/
class Demo
{
         public int div(int a,int b)throws Exception//在功能上通过throws关键字声明了该功能可能会出现问题
         {
         return a/b;
         }
}
 
class ExceptionDemo
{
         public static void main(String[] args)
         {
         Demo d=new Demo();  //创建对象
         try
         {
         int x=d.div(3,0);   //调用对象方法
         System.out.print(x);
         }
         catch(Exception e)
         {
          System.out.println("除零啦");
         System.out.println(e.toString()); //异常名称:异常信息
         System.out.println(e.getMessage());//by zero
         e.printStackTrace();//异常名称,异常信息,异常出现的位置
         }
         }
}

6 throws使用在函数上   后面跟的是异常类

   throw使用在函数内    后面跟的是异常对象

7 Exception中有一个特殊的子类RuntimeException运行时异常

如果在函数内抛出该异常,函数上不用声明,编译一样通过

如果在函数上抛出该异常,调用者可以不用处理,编译一样通过

之所以不用函数声明,是因为不需要调用者去处理

当该异常发生,希望程序停掉,因为运行时,出现了无法继续运算的情况,希望停止程序后,对代码进行修正

 

自定义异常时,如果该异常的发生,无法再继续进行运算,就让自定义异常继承RuntimeException

/**
例子2:毕老师用电脑上课
开始思考问题,名字提炼法
毕老师初始化有名字,初始化之后又会有电脑
毕老师有讲课功能prelect();
 
电脑有运行run功能和重启功能rest,这两个功能都是有办法解决的,所以都继承Exception类
state=1  电脑正常运行
state=2  电脑蓝屏
state=3  电脑冒烟了
*/
 
class LanPingExceptionextends Exception //定义一个电脑蓝屏异常类
{
       LanPingException(String msg)
       {
       super(msg);//调用父类的构造函数
       }
}
 
class MaoYanExceptionextends Exception //定义一个电脑冒烟异常
{
        MaoYanException(String msg)
        {
        super(msg);//调用父类的构造函数
       }
}
 
class NoPlanExceptionextends Exception
{
       NoPlanException(String msg)
       {
        super(msg);  //调用父类的构造函数
       }
}
 
class Compluter  //定义一个电脑类
{
       private static int state=1;
       
       public void run()throws LanPingException,MaoYanException//抛出异常
       {
        if(state==1)
        System.out.println("电脑正常运行");
       if(state==2)
       throw new LanPingException("电脑蓝屏啦");  //抛出LanPingException异常
       if(state==3)
       throw new MaoYanException("电脑冒烟啦"); //抛出MaoYanException异常
       }
 
         //电脑重启, state=1
       public void rest()
       {
       System.out.println("电脑重启");
       state=1;
       }   
}
 
class Teacher  //定义一个老师类
{
       private String name;
       private Compluter cmp;
       Teacher(String name)
       {
       this.name=name; //把name赋值给当前对象
        cmp=new Compluter();   //创建电脑对象
       }
       public void prelect()throws NoPlanException
       {
       try
       {
        cmp.run();    //调用电脑的运行功能
       System.out.println(name+"开始讲课");
       }
       catch(LanPingException e)   //捕抓电脑LanPingException异常
       {
       cmp.rest();    //调用电脑重启方法
       }
       catch(MaoYanException e)  //捕抓电脑MaoYanException异常
       {
       throw new NoPlanException("课时无法继续"+e.getMessage());
       }
       }
}
class TeacherDemo  
{
       public static void main(String[] args)
       {
       Teacher t=new Teacher("毕老师"); //创建一个老师对象
       try
       {
       t.prelect();  
       }
       catch(NoPlanException e)        
       {
       System.out.println(e.toString());  
     System.out.println("换老师或者放假");
       }
       }
}

8 异常finally

程序一有异常就跳转到catch代码块,那么就会有一些代码会执行不到,导致资源被占用

这时我们要强制执行某些代码,让它断开连接,释放资源,而finally代码块里面的语句就是一定要执行的语句

 

 只有一种情况不会被执行System.exit(0);//jvm退出

 

9 下面是处理异常的几种格式

 1) try{ } catch(){}  finally{}

 2)try{} catch(){}

 3)try{}finally{}

记住一点,catch是用来处理异常的,如果没有catch就代表该异常没有被处理过

 

10 异常在子父类覆盖中的体现

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

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

  3)如果父类或者接口的方法中没有异常抛出,那么该子类在覆盖方法时,也不可以抛出异常,如果子类方法发生异常,就必须要进行try处理,绝对不能抛

 

异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性,也就是说可以被throw和throws关键字缩操作,只有异常体系具备这个特点

11 throw和throws的用法:

   throw定义在函数内,用于抛出异常对象

   throws定义在函数上,用于抛出异常类,可以抛出多个用逗号隔开

当函数内有throw抛出异常对象,并未进行try处理,必须在函数上声明,都在编译失败

注意:RuntimeException除外

/**
异常例子3:

求长方形和圆的面积
都是求面积,但是所求的面积不一样,把面积定义成接口inrerface Shape
功能:void getArea();     因为长宽和半径不一样所以没有参数

求面积过程中会出现异常
当长宽和半径出现负数,不符合逻辑,程序应该停掉

定义一个异常类NoValueEception继承RuntimeException异常

*/
class NoValueException extends RuntimeException
{
	NoValueException(String msg)
	{
		super(msg);
	}
}
interface Shape
{
	public void getArea();
}

class Rec implements Shape //定义一个长方形的类
{
	private int len,wid;//定义长方形的长和宽
	Rec(int len,int wid)//构造函数
	{
		if(len<0||wid<0)//判断长和宽是否小于零
		throw new NoValueException("值无效"); //抛出异常
		this.len=len;
		this.wid=wid;
	}
	public void getArea()
	{
		System.out.println(len*wid);//输出面积
	}
}

class Circle implements Shape
{
	private int radius;
	private static final double PI=3.14;//因为PI是固定的所以用final定义,因为PI是共享数据所以用static定义,不用每个对象都创建一次
	Circle(int radius)
	{
		this.radius=radius;
		if(radius<0)
		throw new NoValueException("输入的值为负数");//抛出异常
	}
	public void getArea()
	{
		System.out.println(radius*radius*PI);
	}
}

class ExceptionTest
{
	public static void main(String[] args)
	{
		Circle c=new Circle(-3);
		c.getArea();
	}
}

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