黑马程序员---java基础---异常处理

 ------ Java培训、Android培训、iOS培训、.Net培训 、期待与您交流! -------

异常处理

********1异常概述

1.异常

          就是程序在运行是出现不正常情况。

2.异常由来

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

3.问题划分

                  一-----严重问题
                 二-----非严重问题
 
                 严重问题:java通过Error类进行描述。
                                  对于Error一般不编写针对性的处理方式进行处理。
                  非严重问题:java通过Exception类进行描述
                                   可以使用针对性的处理方式进行处理。
无论Error与Exception都有一些共性的内容
如:不正常情况的信息,印发原因等。

Throwable---|  Error   |  Exception


******2异常  try--catch()处理

4.异常的处理

 java提供了特有的语句进行处理
try
{
     需要被检测的代码;
}
catch(异常类  变量)
{
    处理异常的代码;(处理方式)
}
finally
{
    一定会执行的语句;
}

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

5.对捕获的异常对象进行常见的方法操作。

 String getMessage(); 获取异常信息。
例子:
class  ExceptionDemo
{
public static void main(String[] args)
{
try
{
Demo d  = new Demo();
                 int x = d.div(2,0);   
System.out.println(x);
}
catch (Exception e)
{
System.out.println("出错了"); 
System.out.println(e.getMessage()); //by zero
System.out.println(e.toString());   //异常名称:异常信息
e.printStackTrace();//异常名称,异常信息,异常出现的位置。
                    //jvm默认的处理机制就是调用printStackTrace方法
    //打印异常的堆栈的跟踪信息。
}
System.out.println("Hello World!");
}
}





******3异常声明

6.在函数上声明以异常

           便于提高安全性,调用进行处理,不处理则编译失败。
class Demo
{
int div(int a ,int b)throws Exception //在功能上通过throws的关键字声明了该功能可能出现问题。
{
return a/b;
}
}
class  ExceptionDemo2
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(3,0);
            System.out.println(x);   
}
catch (Exception e)
{
System.out.println("chucuo ");
System.out.println(e.getMessage());
System.out.println(e.toString());
e.printStackTrace();
}
System.out.println("over");
}
}


******4对多异常的处理

throws exception 

7.对多异常的处理

           声明异常时,建议声明更具体的异常,这样处理的更具体。
           对方声明几个异常,就对应有几个catch块,不要定义多余的catch块
           如果多个catch块中的异常出现继承关系,父类异常catch块在最下面。
           建议在进行catch处理时,一定要定义具体的处理方式,不要简单定义一句
           e.printStackTrace();   也不要简单的书写一条输出语句。
         
class Demo
{
public int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
{
int[] arr = new int[a];
System.out.println(arr[4]);
return a/b;
}
}
class ExceptionDemo4 
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(6,1);
System.out.println(x);
}
catch ( ArithmeticException e)
{
System.out.println("by zero");
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println("out of ");
}
System.out.println("over");
}
}



                 

******5自定义异常

1.因为项目中会出现特有的问题。

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

2.自定义异常

例子:
   需求-------------在本程序中,对于除数地-1,也视为是错误的,无法进行的。
                              那么就需要对这个问题进行自定义的描述。
   一般情况下------函数内出现异常,函数上需要声明。
   打印结果---------只有异常 名称 ,没有异常 信息 。因为异常信息为定义。
   定义异常信息----因为父类中一把异常信息的操作都完成了,所以子类在构造时,将异常信息传递给父类通过super语句。
                              那么就可以直接调用getMessage方法获取异常信息。

3.继承Exception的原因

异常体系有一个特点,因为异常类和异常对象都被抛出。
他们都具有可平抛性。这个可抛性时Throwable这个体系中独有的特点。

只有这个体系中的类和对对象才可以被throws和throw抛出。
class FushuException extends Exception
{
private int value;
FushuException()
{
super();
}
FushuException(String msg ,int value)
{
super(msg);
this.value = value;
}
public int getValue()
{
return value;
}
}
class Demo
{
public int div(int a,int b)throws FushuException
{
if(b<0)
{
throw new FushuException("除数是负数",b);
}
return a/b;
}
}
class ExceptionDemo5
{
public static void main(String[] args)
{
         Demo d = new Demo();
try
{
int x = d.div(5,-1);
System.out.println(x);
}
catch (FushuException e)
{
System.out.println(e.getMessage());
System.out.println(e.getValue());
}
}
}





******6throw与throws的区别

只有这个体系中的类和对象才可以被throw与throws操作。

二者区别

           throws使用在函数上。后面跟异常的类。可以跟多个,用逗号隔开。
           throw使用在函数内。后面跟异常类。
******RuntimeException

1.Exception中有一个特殊的子类异常RuntimeException运行时异常。
            如果在函数内部抛出异常,函数上可以不声明,编译一样通过。
           如果函数上声明了该异常,调用者可以不用处理,编译一样通过。
          之所以不用在函数声明是因为不需要让调用者处理。
          当该异常发生,希望程序停止。因为在运行时,
          出现了无法进行运算的情况,希望停止程序后对代码进行修正。

2.自定义异常时

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

3.对于异常,分为两种

          编译时被检测到的异常
          编译时不被检测的异常(运行时异常,RuntimeExeception 及其子类)


**********7异常处理-----finally

finally代码块: 定义一定执行的代码,通常用于关闭资源。

class ExceptionDemo extends Exception
{
ExceptionDemo(String msg)
{
super(msg);
}
}
class Demo
{
 int method(int a ,int b)throws ExceptionDemo
{
if(b<0)
{
System.out.println("出错了");
throw new ExceptionDemo("除零了");
}
return a/b;
}
}
class  ExceptionDemo6
{
public static void main(String[] args) 
{
Demo d = new Demo();
try
{
      	int x = d.method(3,-4);	
System.out.println("x"+x);
}
catch (ExceptionDemo e)
{
System.out.println(e.toString());
return;
}
finally
{
System.out.println("finally");//return后的语句finally扔执行,进行输出。
}
System.out.println("over");
}
}

*******8面向对象---异常处理语句其他格式

第一个格式
try
{
}
catch()
{
}

第二个格式
try
{
}
catch()
{
}
finally
{
}

第三个格式
try
{
}
finally
{
}

注意:catch用于处理异常,如果异常 没有被处理过
         并且该异常是 检测时异常,那么必须 声明

******9异常----覆盖时的特点

    异常在子类覆盖中的体现:
1.子类在覆盖父类时,如果父类的方法抛出异常,
   那么子类的方法只能抛出 父类的异常或者该异常的子类。
2.如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的 子集
3.如果父类或者接口的方法中 没有异常抛出,那么子类在覆盖方法时,也可以不抛出异常。
   如果子类方法发生了异常,就必须要进行 try处理,绝对不能抛
4.尽量不用if() else进行异常处理,当操作烦琐时,不建议使用。
   建议使用throw 异常,进行try--catch处理。

******10异常处理

练习

1.继承RuntimeException是因为当出错后的代码若执行无意义,
故继承RuntimeException出错,停止。
2.将问题进行封装,成为异常类进行try --catch处理
3.将不变数据,定义一个变量进行接收,有final修饰。 加static为共享数据。类加载就存在的数据。

class NoValueException extends RuntimeException
{
NoValueException(String msg)
{
super(msg);
}
}
interface Demo
{
void getArea();
}
class Rec implements Demo
{
private int len , wid;
    Rec(int len, int wid)
{
if(len <=0 || wid <=0)
throw new NoValueException("数值错误");
try
{
this.len = len;
this.wid = wid;
}
catch(NoValueException e)
{
System.out.println(e.toString());
}
}
public void getArea()
{	
System.out.println(len*wid);
}
}
class Circle implements Demo
{
private int r;
public static final double  PI=3.14;
Circle(int r)
{
if(r<=0)
throw new NoValueException("出错了");
try
{
this.r = r;
}
catch (NoValueException e)
{
System.out.println("Circle出错");
}
}
public void getArea()
{
System.out.println(r*r*PI);
}
}
class ExceptionTest8
{
public static void main(String[] args) 
{
     Rec r1 = new Rec(3,4);
 r1.getArea();
 Circle c1 = new Circle(5);
 c1.getArea();
          Circle c2 = new Circle(-3);
 c2.getArea();
 Rec r2 = new Rec(3,-1);
 r2.getArea();	
}
}


******11 异常总结

1.异常:

   是对问题的描述,将问题进行对象的封装。
------------------------------

2.异常体系

Throwable
             |-----Error
                |------Exception
                                     |---------RuntimeException

3.异常特点:

        异常体系中的所有类以及建立的对象都具备可抛性
       也就是可以被Throw及Throws操作。
       只有异常体系具备这个特点。

4.throw与throws的用法

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

       当函数内部有throw抛出异常,且并未进行处理,则必须在函数上进行声明,否则编译失败。
       注意,RuntimeException(抛出后即停止进行)除外。即当函数内抛出RuntimeException时,函数上可以不声明。

       如果函数声明了异常,调用者需要进行处理。处理方法可为throw也可为try。

5.异常分类----两种

                编译时被检测异常
                            该异常在编译时若未处理(没抛出也没有try),则编译失败。
                            该异常被标识,标识该处可以被处理。
               运行时异常(编译时不检测)
                           在编译时,不需要处理,编译器不检查。
                           该异常的发生,建议不处理让程序停止。需要对代码进行处理。

6.异常处理语句

try
{
  需要被检测的代码
}
catch()
{
处理异常的代码
}
finally
{
一定会执行的代码
}
有三个结合格式:
(1)
       try
       {
       }
        ctach()
       {
       }
(2)
       try
       {
        }
      finally
     {
     }
(3)
     try
    {
    }
    catch()
    {
     }
    finally
    {
    }
注意:
1.fianlly中定义的通常是关闭资源代码。因为资源必须释放。
2.finally只有一种情况不会执行。即当执行到System.exit(0);finally不会执行。

7.自定义异常:

             定义类继承Exception或者RuntimeException
             1.为了让自定义类具备可抛性。
             2.让该类具备操作异常的共性方法。

             当要定义自定义异常的信息时,可以使用父类已经定义好的功能。
             将异常信息传递给父类的构造函数。
             class ExceptionDemo extends  Exception 
            {
                        ExceptionDemo(String msg)
                   {
                                  super(msg);
                   }
             }

自定义异常

          按照java的面向对象的思想,将程序中出现的特有问题进行封装。

8.异常的好处

          1.将问题进行封装
          2.将正常流程代码和问题处理代码相分离,方便阅读。

9.异常的处理原则

         1.处理方式有两种:try  或者  throws
         2.调用到抛出异常的功能时,抛出几个就处理几个
            一个try对应多个catch
         3.多个catch时,父类的catch放到最后
         4.catch内,需要定义针对性的处理方式,不要简单的定义 
            printStackTrace输出语句,也不要不写。
         当捕捉到的异常,本功能处理不了时,可以继续在catch中抛出。
         try
        {
             throw new Aexception();
          }
        catch(Aexception e)
         {
            throw e;
        }

          如果该异常处理不了,但并不属于该功能出现的异常,
          可以将异常进行转化后,再抛出和该功能相关的异常。

          或者异常可以处理,可以将异常产生的和本功能有关的问题提供出去,
          当调用者知道则进行处理。也可以将捕获的异常转化成新的异常。
         try
         {
              throw new Aexception();
          }
        catch(Aexception e)
        {
                 对异常进行处理
                throw new Bexception();
          }
      比如汇款的例子。
   

10.异常的注意事项

  在子父类覆盖时
       1.子类抛出的异常必须是父类异常的子类或者子集。
       2.如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。



              ------ Java培训、Android培训、iOS培训、.Net培训 、期待与您交流! -------
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值