黑马程序员-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”的输出语句执行不到。