黑马程序员--Java基础--异常

----------------------Android培训、Java培训、期待与您交流！ ---------------------- 

异常定义：异常是指当程序中某些地方出错时创建的一种特殊的运行时的错误对象。

Java创建异常对象后，就发送给Java程序，即抛出异常（throwing an Exception）。程序捕捉到这个异常后，可以编写相应的异常代码进行处理。使用异常处理可以使程序更加健壮，有助于调试和后期维护。

异常：程序在运行时出现的不正常情况。

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

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

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

对于严重的,java通过Error类进行描述。

       对于Error一般不编写针对性的代码对其进行处理。

对于非常严重的，java通过Exception类进行描述。

Exception类及Exception派生的子类都是系统事先定义好的并包含在java类库中的，系统定义的异常对应着一些系统错误，如中断，文件没有找到等错误。下面收集一些常见的系统异常类

       对于Exception可以使用针对性的处理方式进行处理。 

无论Error或者Exception都具有一些共性内容，

比如：不正常情况的信息，引发原因等。

由继承类图可以看出：Throwable类派生了两个类Error和Exception，其中Error类系统保留，而Exception类供应用程序使用，它下面又派生出几个具体的异常类，都对应着一项具体的运行错误

 

异常类图

      

异常的处理

 java异常通常在调用某些方法不一定完全成功时抛出，针对抛出的异常程序需要给出相应的处理，就称为异常处理。

异常处理分为三个部分：捕捉异常，程序流程的跳转和异常处理语句块

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

try
{
	需要检测的代码；
}
catch(异常类   变量)
{	
	处理异常的代码：（处理方式）
}
finally
{
	一定会执行的语句；
}

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

       String getMessage():获取异常信息
       e.toString():异常名称：异常信息
      e.printStackTrace();异常名称，异常信息，异常出现的位置

 

在函数上声明异常：

便于提高安全性，让调用出进行处理，不处理则编译失败 

class Demo
{//在功能上通过throws的关键字声明该功能可能会出现异常
	int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException
	{
		int[] arr=new int[a];
		System.out.println(arr[4]); //角标越界
		return a/b;
	}
}

对多异常的处理

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

2，对方声明几个异常，就对应有几个catch块，不要定义多余的catch块。

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

      

建立在进行catch处理时，catch中一定要定义具体处理方式，

不要简单的定义一句e.printStackTrace();

也不要简单一句中文打印就搞定了。

应该将异常记录入日志文件。

 

 自定义异常

  因为项目中会出现特有问题，

 而这些问题并未被java所描述并封装对象。

 所以对于这些特有的问题可以按照java对问题封装的思想，

 将特有的问题，进性自定义的异常封装 

 自定义异常

 需求：在本程序中，对于除数是-1,也视为是错误的是无法进行运算的。

 那么就需要对这个问题进行自定义的描述。

class FuShuException extends Exception
{//自定义异常类
	FuShuException(String msg)
	{
		//调用父类构造函数
		super(msg);
	}
}

class Demo2
{//在功能上通过throws的关键字声明该功能可能会出现异常
	int div(int a,int b) throws FuShuException
	{
		if(b<0)
		{
			//手动通过throw关键字抛出一个自定义异常对象
			throw new FuShuException("出现了除数是负数的情况");
		}
		return a/b;
	}
}

public class ExceptionDemo2 {
	public static void main(String[] args) throws Exception
	{
		Demo2 d=new Demo2();
		//函数上声明该功能可能会出现异常,调用时要么在内部try catch处理，
		//要么在函数上声明让调用者处理: main(String[] args) throws Exception
		try
		{
			int x=d.div(3, -1);
			//此处抛出  new AritchmeticException()			
			System.out.println(x);
		}		
		catch(FuShuException e)
		{
			//采用多态性：没有针对性
			System.out.println("哈哈!"+e.toString());	
			//System.out.println("出现负数了");
		}		
		System.out.println("over");
	}
}

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

 要么在内部try catch处理，

 要么在函数上声明让调用者处理。

 

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

 

 发现打印的结果中只有异常的名称，却没有异常的信息。

 因为自定义的异常并未定义信息。

 

 如何定义异常信息呢？

 因为父类中已经把异常信息的操作都完成了，

 所以子类只要在构造时，将异常信息传递给父类通过super

 

自定义异常：

必须是自定义类继承Exception

 

继承Exception的原因：

异常体系有一个特点：因为异常类和异常对象都会被抛出。

他们都具备可抛性，这个可抛性是Throwable这个体系中独有特点。

 

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

 

throws和throw的区别:

    throws使用在函数上

public static void main(String[] args) throws Exception

    throw使用在函数内

throw new Exception("出现异常，请及时处理~！");

 

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

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

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

 

 之所以不用再函数上声明，是因为不需要让调用者处理，

 当该异常发生，希望程序停止，因为在运行时，出现了无法继承运算的情况，希望停止程序。

 

*** 自定义异常时：如果该异常的发生，无法再继续进行运算，

 就让自定义异常继承RuntimeException

 

 对于异常分两种：

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

 2，编译时不被检测的异常（运行时异常，RuntimeException以及其子类）

 */

 

/*

异常：

是什么？是对问题的描述，将问题进行对象的封装。

 

异常体系：

Throwable

       |--Error

       |--Exception

              |--RuntimeException 

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。

                           也就是说可以被throw和throws关键字所操作。

                            只有异常体系具备这个特点。

throw和throws的用法：

throw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

 

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

注意：RuntimeException除外。也就是说，函数内如果抛出的是RuntimeException异常，函数上可以不声明

 

如果函数声明了异常，调用者需要进行处理，处理方法可以try可以throw

 

异常有两种：

       1,编译时被检测异常

             该异常在编译时，如果没有处理（没有抛出也没有Try）,编译失败

       2,运行时异常（编译时不检测）

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

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

 

注意 :

1，finally中定义的通常是关闭资源代码，因为资源必须释放。

2，finally只有一种情况不会执行：System.exit(0); finally不会被执行。

 

自定义异常：

       定义类继承Exception或者RuntimeException

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

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

      

       当要定义自定义异常的信息时，可以使用父类已经定义好的功能。

       异常异常信息传递给父类的构造函数。

自定义异常：按照java面向对象思想，将程序中出现的特有问题进行封装。

------------

异常的好处：

       1，将问题进行封装

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

 

异常处理的原则：

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

       2，调用到抛出异常的功能时，抛出几个，就处理几个。

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

       4，catch内需要定义针对性的处理方式，

             不要简单的定义printStackTrack，输出语句。

             当捕获到的异常，本功能处理不了是，可以继续在catch中抛出。

              try {

                     throw new ExException();

              }

              catch (Exception e) {

                     throw e;

              }

             

             如果该异常处理不了，但并不属于该功能出现的异常，

             可以将异常装换后，在抛出和该功能相关的异常。

             

             或者异常可以处理，当需要将异常产生的和功能相关的问题提供出去，

             当调用者知道，并处理，也可以将捕获异常处理后，转换为新的异常。

 

异常的注意事项：

       在子父类覆盖时：

       1，子类抛出的异常必须是父类异常的子类或者子集

       2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛

      

---------------------- Android培训 、 Java培训 、期待与您交流！ ----------------------