黑马程序员——异常

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------

异常

异常的体系

• Throwable

• Error

• 通常出现重大问题如：运行的类不存在或者内存溢出等。

• 不编写针对代码对其处理

• Exception

• 在运行时运行出现的一起情况，可以通过try catch finally

 

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

• Throwable中的方法

getMessage()

• 获取异常信息，返回字符串。

 toString()

• 获取异常类名和异常信息，返回字符串。

 printStackTrace()

• 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

 printStackTrace(PrintStream s)

• 通常用该方法将异常内容保存在日志文件中，以便查阅。

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

函数内声明异常时，函数上也要声明异常throws,当主函数上调用声明的方法时，主函数上也要声明异常

 

注意：出现异常要么try catch   要么抛throws

 

如何自定义异常？

 

class FusshuException extends Exception

方法是：继承Exception    加入异常帮派 ， 才能具备异常功能

异常概述

/*

 * 异常：就是程序在运行时，出现的不正常情况

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

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

 * 对于问题的划分：两种

 * 一种是严重的问题：Java通过Error类进行描述

 *                 对于error一般不编写针对性代码进行处理

 * 一种是非严重的问题：Java通过Excption类进行描述

 *                 对于Excption需要编写针对性代码进行处理

 *

 * 无论Error或Excption都具有一些共性内容。

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

 *

 * Throwable

 *    |--Error

 *    |--Excption

 *

 * 2, 异常的处理

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

 *   try

 *   {需要被检测的代码}

 *  catch

 *   {处理异常的代码《处理方式》}

 *  finally

 *   {一定会执行语句}

 *  

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

 *  String getMessage();

 */

class DemoTwo
{
    int div(int a,int b)
    {
       return a/b;
    }
}
publicclass _06异常 {
   
    publicstatic void main(String[]args)
    {
       DemoTwo d = new DemoTwo();
       try
       {
       int x = d.div(3,0);
       System.out.println(x);
       }
       catch(Exception e)//Exceptione = new ArithmeticException();
       {
           System.out.println("除零啦");
           System.out.println(e.getMessage());//    / by zero 
           System.out.println(e.toString());// 捕获异常名称、异常信息
           e.printStackTrace();//捕获异常名称、异常信息、异常出现的位置
    //其实jvm默认的异常处理机制，就是在调用printStackTrace方法。打印异常堆栈的跟踪信息
       }
    }
 
}

异常细节

1.        RuntimeException以及其子类如果在函数中被throw抛出，可以不用 在函数上声明。

2.        一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类。

3.        如果父类抛出多个异常，那么重写（覆盖）方法必须抛出那些异常的一个子集，不能抛出新的异常。

/*－－－－－－－－－－－－－－－－－－－－－

* ArithmeticException：运算异常

 * RuntimeException：运行时异常

 * －－－－－－－－－－－－－－－－－－－－

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

 *

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

 *

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

 *

ArithmeticException：运算异常

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

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

 * 对代码进行修正。

 *

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

 * 就让自定义的异常继承;RuntimeException.

 *

 * 对于异常分为两种：

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

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

 */

class FuShhuException extends RuntimeException
{
    FuShhuException(String msg)
    {
       super(msg);
    }
}
class DemoS
{
    int div(int a,int b)
    {
       if(b<0)
       {
           throw new FuShhuException("出现除数为负数了。"+b);
       }
       if(b==0)
       {
           throw new ArithmeticException("被零除啦");//不用在方法后声明throws,编译通过
       }
       return a/b;
    }
}
public class _09RuntimeException {
   
    public static void main(String[]args)
    {
       DemoS s = new DemoS();
       int num = s.div(5, 1);
       System.out.println(num);
    }
 
}

异常处理语句格式

/*

//第一个格式
try
{}
catch
{}

//第二个格式
try
{}
catch()
{}
finally
{}

//第三个格式
try
{}
finally
{}

*/

//记住：catch是用于处理异常。
//如果没有catch就代表异常没有处理过，如果该异常是检测时异常，那么必须声明。
class demo
{
	public void method()throws Exception
	{
		try
		{
			throw new Exception("xx");
		}
		finally
		{
			System.out.println("关闭资源");
			//关闭资源
		}
	}
}
public class _03异常_处理语句格式 {
	
	public static void main(String[]args)
	{
		demo d = new demo();
		try
		{
			d.method();
		}
		catch(Exception e)
		{
			System.out.println(e.toString());
		}
	}

}

异常的总结

/*
 * 异常是什么？
 * 是对问题的描述，并对问题进行封装。
 * －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
 * 异常体系：
 *    Throwable
 *       |--Error
 *       |--Exception
 *         |--RuntimeException
 *         
 * 异常体系的特点：异常体系中的所有类以及建立的对象，都具备可抛性。
 *                也就是说：可以被throws throw 关键字操作
 *                只有异常体系具备这个特点
 *	－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
 * throws 和 throw 的用法：
 * Throw  定义在函数内，用于抛出异常对象。
 * Throws 定义在函数上，用于抛出异常类。	可以抛出多个异常，用逗号隔开。
 * 
 * 当函数内有throws抛出异常对象，并未进行try处理，需在函数上声明，否则，编译失败。
 * 
 * 注意：RuntimeEcxeption异常，除外。也就是函数内如果抛出的是Runtime异常，函数上可以不用声明
 * 
 * －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
 * 如果函数声明了异常，调用者需要进行处理，处理方式：可throws 可try
 * 
 * －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
 * 异常有两种：
 * 一个是编译时被检测异常
	  该异常如果在编译时，如果没有处理（没有抛，也没有try），那么编译失败
	 该异常被标识，可以被处理。
	
	一个是运行时异常（编译时不检测）（运行时异常。RuntimeException以及其子类	）
	    在编译时，不需要处理，编译器不检查。
	    该异常发生，建议不处理，让程序停止。需要对代码进行修正。
 * 
 * －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
 * 异常处理语句：
 * try(需要被检测的代码)catch(处理异常的代码)finally(一定会被执行的代码)
 * 
 * 有三种语句格式：
 * try()catch()finally() 
 * try()catch()
 * try()finally()
 * 
 * 注意：finally中定义的通常是：关闭资源代码。因为资源必须要释放
 * 		finally只有一种情况，不会执行。如下：
 *      当执行到－－//System.exit(0);//系统退出；finally语句将读不到
 * 
 * －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
 * 自定义异常:
 *   定义类继承Exception或者RuntimeException
 *   
 *   1，为了该自定义类具备可抛性。
 *   2，让该类具备操作异常的共性方法。
 *   
 *   当要定义自定义的异常信息时，可以使用父类已经定义好的功能。
 *   将异常信息，传递给父类的构造函数。
 *   class MyException extends Exception
 *   {
 *   	MyException(String message)
 *   	{
 *   		super(message);
 *   	}
 *   }
 *   
 *   －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
 * 
 * 自定义异常的出现有什么好处？
 * 自定义异常：按照Java的面向 对象思想，将程序中的特有问题进行封装。
 * 
 * 1，将问题进行封装。
 * 2，将正常流程代码，与问题代码相分离，方便阅读。
 * 
 * 异常的处理原则：
 * 
 * 1，处理方式有两种：try()或者throws
 * 2，调用到抛出异常的功能时，抛出几个就处理几个。
 *    会出现一个try对应多个catch的情况
 * 3，多个catch，父类的catch放到最下边。
 * 4，catch内，需要定义针对性的处理方式，不要简单的定义printStackTrice,输出语句。
 *    也不要不写。
 *    当捕获到的异常，本功能处理不了时，可 以继续在catch中抛出
 *    try
 *    {throw new AException()}
 *    catch(AException e)
 *    {throw e;}
 *    
 *    如果该异常处理不了，但并不属于该功能出现的异常，
 *    可以将异常转换后，再抛出和该功能相关的异常
 *    
 *    或者，异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，
 *    让调用者知道，并作处理。也可以将捕获异常处理后，转换新的异常抛出。
 *    try
 *    {throw new AException()}
 *    catch(AException e)
 *    {
 *    	//对AException进行处理。
 *    	throw new BException("");
 *    }
 *    比如：汇款的例子，
 *    
 *  -------------------------------------------------------------------
 * 异常的注意事项：
 * 在子父类覆盖时，
 * 1，子类抛出的异常，必须是父类异常的子类，或者子集。
 * 2，如果父类或者接口，没有异常抛出时，子类覆盖出现异常，只能try，不能抛
 * 
 * 
 *    
 */

异常Finally

/*

 * finally代码块：定义一定要执行的代码。

 * 通常用于关闭资源。

 */

Throws 和 throw的区别?

Throws 定义在函数上，后面跟的是异常类名，可以跟多个，使用逗号隔开。

Throw 定义在函数内，后面跟的是异常对象。

---------------------- 黑马程序员 Android培训、期待与您交流！ ----------------------