黑马程序员----java中的异常

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

一、异常：

就是在运行时出现的不正常情况；

异常的由来：问题也是现实生活中一个具体的事物，也可以通过Java的类的形式进行描述，并封装成对象。

其实就是Java对不正常情况进行描述后的对象体现。

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

        1.Error:通常出现重大错误，如运行的类不存在或者内存溢出等（不编写针对代码对其进行处理）。

        2.Exception:在运行时出现的情况，可以通过try catch finally来进行针对性的处理。   

        无论是Error还是Exception，它们都有一些共性内容,比如：不正常情况的信息和引发原因等。   

throwable类：Java语言中所有的错误或异常的超类（父类）。

       1---Error......

       2---Exception......   

       Error和Exception的子类名都是以父类名作为后缀的。   

异常处理：

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

代码块格式：

    try

    {

        需要检测的代码；

    }

    catch(异常类  变量)

    {

        处理异常的代码；（处理方式）

    }

    Finally

    {

        一定会执行的语句；

    }   

对捕获到的异常对象进行常见方法操作：

        1.    String getMssage(); 获取异常的信息。

        2.    toString(); 异常名称：异常信息。

        3.    e.printStackTrace();//异常名称：异常信息,异常出现的位置。

        其实jvm默认的异常处理机制就是在调用printStackTrace()方法，打印异常的堆栈跟踪信息。

在函数上声明异常：

        便于提高安全性，编译不处理，让调用进行处理。

对多异常的处理

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

        2.声明几个，就有几个针对性处理,抛几个异常，就应该有几个catch.不要定义多余得catch块。

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

建议在进行catch处理时，catch中一定要定义具体处理方式，不要简单的定义一句e.printStackTrace();,也不要简单的书写一条输出语句。

异常日志文件：当发生问题时并不打印，而是用一个硬盘文件记录下来.

throws和throw的区别：

        1.位置上的区别：throws使用在函数上，throw使用在函数内；

        2.throws后面跟 的是异常类（可以跟多个异常类，用逗号隔开），throw后面跟的是异常对象。

class FushuException extends Exception //getMessage()；
{
/*
private String msg;
FushuException(String msg)
{
this.msg=msg;
}
public String getMessage()
{
return msg;
}
*/
private int value;

FushuException(String msg,int value)
{
super(msg);
this.value=value;
}
public int getValue()
{
return value;
}
/*
也可以建立一个空参数的，没有异常信息
FushuException()
{
super();//隐式super；
}
*/
}
class Demo
{
int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException,FushuException
{
int [] arr=new int[a];
System.out.println(arr[4]);//数组角标越界；

if(b<0)
throw new FushuException("除数不能是负数：/by fushu",b);	//手动通过throw关键字抛出一个自定义的对象。

return a/b;	//new ArithmeticException();
}
}
public class ExceptionDemo
{
public static void main(String[] args) //throws Exception
{
Demo d=new Demo();
try
{
int x=d.div(5, -1);	//发生异常；new ArithmeticException();
System.out.println("x="+x);
}
catch(FushuException e)
{
//System.out.println("除数不能为负数。");
System.out.println(e.toString());
System.out.println("错误的负数是："+e.getValue());
}
catch(ArithmeticException e)	//Exception e=new ArithmeticException();
{
System.out.println("除数不能为0。");
System.out.println(e.getMessage());//获取异常信息；
System.out.println(e.toString());//异常名称：异常信息。

e.printStackTrace();//异常名称：异常信息,异常出现的位置。
}
catch(ArrayIndexOutOfBoundsException e)	//Exception e=new ArrayIndexOutOfBoundsException();
{
System.out.println("数组角标越界了。");
System.out.println(e.getMessage());//获取异常信息；
System.out.println(e.toString());//异常名称：异常信息。

e.printStackTrace();//异常名称：异常信息,异常出现的位置。
System.out.println();
}
try
{
int y=d.div(6, 2);
System.out.println("y="+y);
}
catch(Exception e)	//有几个异常都可以处理，但是没有针对性；
{
System.out.println("除数不能为0");
}
System.out.println("over");
//byte[] arr=new byte[1024*1024*600];//内存空间不够；
}
}
/*
class Throwable
{
private String message;
Throwable(String message)
{
this.message=message;
}
public String getMessage()
{
return message;
}
}
class Exception extends Throwable
{
Exception(String message)
{
super(message);
}
}
*/

二、自定义异常

自定义异常处理：

    对项目中的特有问题进行封装,项目中会出现一些特有的问题，这些问题并没有被Java所描述并封装对象，因此将这些特有的问题进行自定义的异常封装。

需求:在本程序中，对于除数是负数也视为是错误的，是无法进行运算的，那么就需要对这个问题进行自定义的描述。

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作：

        1.在内部try catch处理

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

一般情况下，函数内出现异常，函数上需要声明。（有特殊情况）

发现打印的结果只有异常名称没有异常信息，这是因为自定义的异常并未定义信息

那么，如何定义异常信息呢？

        对getMessage()方法复写；

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

自定义异常必须是自定义类继承Exception。

为什么要继承Exception？

        异常体系有一个特点，因为异常类和异常对象都需要被抛出，他们都具备可抛性。

        这个可抛性是throwable这个体系中的独有特点，只有这个体系中的类和对象才可以被throws和throw操作。
算术异常，分母不能为0；

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

RuntimeException 特殊之处：

1.RuntimeException的子类，如果在函数上抛出了，可以不用在函数上声明

        之所以不用在函数上声明，是因为不需要调用者处理，当该异常发生时希望程序停止，

        因为在运行时出现了无法继续运算的情况，希望停止程序后让程序员对代码进行修正。
2.RuntimeException的子类，如果在函数上声明了该异常，调用者可以不用进行处理。

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

对于异常分两种：

        1.编译时异常（编译时被检测的异常）    //抛出时需要声明，标示出去让调用者处理，要么抛（throws），要么踹(try-catch).

        2.运行时异常（RuntimeException及其子类）,直接将程序停掉，修改代码；

在自定义异常的时候需要分析这个问题发生以后能不能处理，

如果不能处理，需要修正代码的时候，要继承RuntimeException;

如果能处理，处理完之后能继续运行，那就继承Exception。

class FushuException_1 extends RuntimeException
{
FushuException_1(String message)
{
super(message);
}
}
class Demo1
{
int div(int a,int b) //throws ArithmeticException
{
//自定义抛出异常；
if(b<0)
throw new FushuException_1("除数不能为负数. /by 负数");
if(b==0)
throw new ArithmeticException("除数不能为0. /by zero");//特殊之处：
return a/b;
}
}
public class ExceptionDemo1
{
public static void main(String[] args)
{
Demo1 d=new Demo1();
int x=d.div(4, -2);
System.out.println("x="+x);

System.out.println("over");
}
}
/*
class Person
{
public void checkName(String name)
{
//if(name.equals("zhangsan"))//NullPointException
if(name!=null && name.equals("zhangsan"))//if("zhangsan".equals(name))
{
System.out.println("pass");
}
else
{
System.out.println("no pass");
}
}
}
main()
{
Person p=new Person();
p.checkName(null); //空指针异常；
}
*/

三、try-catch-finally语句块

 格式一：try{}catch(){}

 格式二： try{}catch(){}finally{}

 格式三：try{}finally{}

记住：catch是用于处理异常的，如果没有catch，就代表异常没有被处理过，如果该异常时检测时异常，就必须要声明出去；

finally代码块：

定义一定执行的代码，通常用于关闭资源。

finally中的代码一定会被执行

public void method() throws NoException	//不抛,throws SQLException，
{
连接数据库；
数据操作；	//throw new SQLException();
关闭数据库；//无论数据操作是否成功，数据库都必须关闭：finally

try
{
连接数据库；
数据操作；	//throw new SQLException();
}
catch(SQLException e)
{
会对数据库进行异常处理;
throw new NoException("操作失败");
}
finally
{
关闭数据库；//无论数据操作是否成功，数据库都必须关闭;
}
}

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

1.子类在覆盖父类时，如果父类的方法抛出异常，

那么子类的覆盖方法只能抛出父类的异常或者该异常的子类或者不抛。

不能抛父类没有的异常（父类不能处理）

Exception

    --AException

        --bException

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

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

class AException extends Exception
{
AException(String message)
{
super(message);
}
}
class BException extends  AException
{
BException(String message)
{
super(message);
}
}
class CException extends Exception
{
CException(String message)
{
super(message);
}
}
class Fu
{
void show() throws AException//BException
{

}
}
class Zi extends Fu	//如果子类真的发生CException,只能try，不能throws.
{
void show() throws AException//BException
{

}
}
class Test
{
void function(Fu f)
{
try
{
f.show();
}
catch (AException e)
{
e.printStackTrace();
}
}
}
public  class ExceptionInClass
{
public static void main(String[] args)
{
Test t=new Test();
t.function(new Fu());
}
}