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

最新推荐文章于 2022-02-20 23:23:01 发布

diaolinan

最新推荐文章于 2022-02-20 23:23:01 发布

阅读量368

点赞数

分类专栏： java学习

本文链接：https://blog.csdn.net/diaolinan/article/details/40866273

版权

java学习专栏收录该内容

6 篇文章 0 订阅

订阅专栏

------ 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();	
}
}