黑马程序员-day10-面向对象(异常)

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

异常概述

1.异常定义：程序在运行时出现不正常情况。

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

3.对于问题的划分：两种：一种是严重的问题，一种非严重的问题。

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

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

  (3)无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等。

4.异常体系

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

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

5.处理Exception异常的方法：

  (1)在运行时运行出现的一些情况，可以通过 try catch finally

  (2)通过throws在函数上声明。（如果函数内throw异常，那么函数就必须声明）

注意：

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

RuntimeException除外，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。

异常分两种：

1.编译时被检测的异常。

  (1)该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。

  (2)该异常被标识，代表这可以被处理。

2.编译时不被检测的异常(运行时异常：RuntimeException以及其子类)

  (1)在编译时，不需要处理，编译器不检查。

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

异常的处理方式

1.异常两种处理方式
   (1)捕捉：try-catch
   (2)抛出：throw
2.try的三种格式：

(1)第一种格式：

try

{
需要被检测的代码；

}

catch(异常类 变量)

{
处理异常的代码(处理方式)

}

finally

{
一定会执行的语句；

}

(2)第二种格式：

try

{

}

catch ()

{

}

(3)第三种格式：

try

{

}

finally

{

}

注意：catch是用于处理异常。如果没有catch就代表异常没有被处理过，如果该异常没有被处理，那么必须声明。

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

  (1)String getMessage()：获取异常信息。

  (2)toString():获取异常名称 ： 异常信息。

  (3)printStackTrace():打印异常的堆栈的跟踪信息。

异常-finally

1.定义：一定执行的代码。

2.作用：通常用于关闭资源。比如：数据库连接

3.注意：Finally代码块只有一种情况不会被执行。就是在之前执行了System.exit(0)，它的作用是终止当前正在运行的 Java 虚拟机。

异常处理实例：

class Demo{
//两个整数相除
public static int div(int a,int b){
return a/b;
}
}

//测试类
class ExceptionDemo{
public static void main(String[] args){
try{
int num = Demo.div(2, 0);
System.out.println("num：" +num);
}
catch(Exception e){
//打印异常的堆栈的跟踪信息
e.printStackTrace();
}
finally{
System.out.println("over");
}
}
}

throws 关键字

1.定义：声明该功能有可能会出现问题。

2.注意：

调用声明异常的方法，必须对其进行捕捉或声明以便抛出，否则编译通不过。

throws与throw的区别：

1.作用：

  throws用于标识函数暴露出的异常。

  throw用于抛出异常对象。

2.用法：

  throws用在函数上，后面跟异常类名。可以跟多个,用逗号隔开。

  throw用在函数内，后面跟异常对象。

throws 关键字实例：

class Demo{
//两个整数相除,并声明该功能有可能会出现问题。
public static int div(int a,int b)throws Exception{
return a/b;
}
}

//测试类
class ThrowsDemo{
public static void main(String[] args){
try{
int num = Demo.div(2, 0);
System.out.println("num：" +num);
}
catch(Exception e){
//打印异常的堆栈的跟踪信息
e.printStackTrace();
}
finally{
System.out.println("over");
}
}
}

多异常处理

1.声明异常时，建议声明更为具体的异常。这样处理的可以更具体。

2.对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块必须放在最下面，要不然编译失败。

3.实际开发处理方式：

  (1)记录信息：异常日记
注意：

在进行异常处理时，catch里面要写针对性的处理。不要简单定义一句 e.printStackTrace(),

也不要简单的就书写一条输出语句。

多异常处理实例：

/*
多异常处理
*/
class Demo{
//两个整数相除,并声明该功能有可能会出现多种异常。
public static int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException{
//有可能出现ArrayIndexOutOfBoundsException异常
int[] arr = new int[a];
System.out.println("arr:" + arr[2]);
//有可能出现ArithmeticException异常
return a/b;
}
}

//测试类
class ExceptionDemo2{
public static void main(String[] args){
try{
int num = Demo.div(2, 1);
System.out.println("num：" +num);
}
catch (ArithmeticException e){
System.out.println(e.toString());
System.out.println("被零除了!!");

}
catch (ArrayIndexOutOfBoundsException e){
System.out.println(e.toString());
System.out.println("角标越界啦！！");
}
catch(Exception e){
//打印异常的堆栈的跟踪信息
e.printStackTrace();
}
finally{
System.out.println("over");
}
}
}

运行结果：



自定义异常

1.自定义异常：因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题。进行自定义的异常封装。

2.当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理。两种处理方法

  (1)在内部try catch处理。

  (2)在函数上声明让调用者处理。

3.注意：

  (1)一般情况下，函数内出现异常，函数上需要声明。

  (2)自定义异常类必须直接或者间接继承Exception类。

如何定义异常信息呢？

因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。

为什么要继承Exception或其子类？

1.为了让该自定义类具备可抛性。

2.让该类具备操作异常的共性方法。

自定义异常继承父类两种选择：

1.如果该异常的发生，不影响程序的运算，希望程序继续运行，就继承Exception。

2.如果该异常的发生，无法再继续进行运算，希望程序停止，就继承RuntimeException。

自定义异常实例：

/*
需求：
1.在本程序中，对于除数是-1，也视为是错误的，那么就需要对这个问题进行自定义的描述。
2.出现该异常，希望程序继承运行。继承Exception类。
*/
//自定义异常类
class FuShuException extends Exception{
private int num;
FuShuException(String message, int num){
super(message);
this.num = num;
}
public String getMessage(){
return super.getMessage()+":"+num;
}
}

class Demo{
//两个整数相除，并在函数上声明异常
public static int div(int a,int b)throws FuShuException{
if(b<0)
//手动通过throw关键字抛出一个自定义异常对象。
throw new FuShuException("错误：除数不能为负数",b);
return a/b;
}
}

//测试类
class ExceptionDemo3{
public static void main(String[] args){
try{
int num = Demo.div(2, -1);
System.out.println("num：" +num);
}
catch(FuShuException e){
System.out.println(e.getMessage());
}
finally{
System.out.println("over");
}
}
}

RuntimeException

Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。

特点：

1.如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。

2.如果在函数上声明了该异常并抛出，调用者可以不用进行处理。编译一样通过；

为什么RuntimeException类和它的子类不用在函数声明？

因为不需要让调用者处理。因为在运行时，出现了无法继续运算的情况，希望停止程序，对代码进行修正。

RuntimeException实例：

/*
需求：
1.在本程序中，对于除数是-1，视为是错误的，无法再继续进行运算
2.出现该异常，希望程序停止
*/
//自定义异常类
class FuShuException extends RuntimeException{
private int num;
FuShuException(String message, int num){
super(message);
this.num = num;
}
public String getMessage(){
return super.getMessage()+":"+num;
}
}

class Demo{
//继承了RuntimeException，在函数上可以不声明异常，但是必须手动抛出异常
public static int div(int a,int b){
if(b<0)
//手动通过throw关键字抛出一个自定义异常对象。
throw new FuShuException("错误，除数不能为负数",b);
return a/b;
}
}

//测试类
class ExceptionDemo4{
public static void main(String[] args){
int num = Demo.div(2, -1);
System.out.println("num：" +num);

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

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

1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类，也可以不抛

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

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

  如果子类方法发生了异常，就必须要进行try处理，绝对不能抛。

异常-练习

/*
有一个圆形和长方形。
都可以获取面积。对于面积如果出现非法的数值，视为是获取面积出现问题。
问题通过异常来表示。
*/
//非法值异常，影响程序继续运行，应该停止运行
class NoValueException extends RuntimeException{
NoValueException(String message){
super(message);
}
}

//接口
interface Shape{
public abstract 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("RecArea:" + len*wid);
}
}

//圆形
class Circle implements Shape{
private int radius;
public static final double PI = 3.14;
Circle(int radius){
if(radius<=0){
throw new NoValueException("出现非法值");
}
this.radius = radius;
}
public void getArea(){
System.out.println("CircleArea:" + radius*radius*PI);
}
}

//测试类
class ExceptionTest{
public static void main(String[] args){
Rec r = new Rec(8,5);
r.getArea();
Circle c = new Circle(-8);
c.getArea();
}
}

异常-总结
异常的好处：

1.将问题进行封装。

2.将正常流程代码和问题处理代码相分离，方便于阅读。

异常的处理原则：

1.处理方式有两种：try 或者 throws。

2.调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。

3.多个catch，父类的catch放到最下面。

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

  (1)当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}

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

  (3)或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，给调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
try
{
throw new AException();
}
catch (AException e)
{
// 对AException处理。
throw new BException();
}

  比如，汇款的例子。

5.throw单独存在，下面不要定义语句，因为执行不到。

public static void func()
{
try
{
//show();//这样写可以，因为下面的语句有可能执行
throw  new Exception();
System.out.println("A");
}
catch(Exception e)
{
System.out.println("B");
}
}

编译失败。 因为打印“A”的输出语句执行不到。