黑马毕向东Java课程笔记（day09-5到9-11）:面向对象（第六部分）java异常1—描述

参考文章：
异常描述

1.1、异常概述
  异常：就是程序在运行时出现不正常情况。
  异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并将这些问题封装成对象。其实异常就是java对不正常情况进行描述后的对象体现。

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

1）对于严重的，java通过Error类进行描述。Error是程序中无法处理的错误，表示运行应用程序中出现了严重的错误。此类错误一般表示代码运行时JVM出现问题，通常有Virtual MachineError（虚拟机运行错误）、NoClassDefFoundError（类定义错误）等。比如说当jvm耗完可用内存时，将出现OutOfMemoryError，此类错误发生时，JVM将终止线程。这些错误是不可查的，因此我们事先不需要也没办法专门设计代码去处理此类错误。

2）对与非严重的，java通过Exception类进行描述。对于Exception，程序本身可以捕获并且可以处理的这些异常。

  Exception这种异常又分为两类：运行时异常和编译异常。

1）运行时异常(不受检异常)：RuntimeException类及其子类表示JVM在运行期间可能出现的错误。比如说试图使用空值对象的引用（NullPointerException）、数组下标越界（ArrayIndexOutBoundException）。此类异常属于不可查异常，一般是由程序逻辑错误引起的，在程序中可以选择捕获处理，也可以不处理（不处理一样会编译通过）。

2）编译异常(受检异常)：Exception中除RuntimeException极其子类之外的异常。如果程序中出现此类异常，比如说IOException，必须对该异常进行处理，否则编译不通过。在程序中，通常不会自定义该类异常，而是直接使用系统提供的异常类。

  Exception又可以分为可查异常与不可查异常：java的所有异常可以分为可查异常（checked exception）和不可查异常（unchecked exception）。

1）可查异常（可查既在编译的时候能够被检测出来，那么就算非运行时异常）：编译器要求必须处理的异常。正确的程序在运行过程中，经常容易出现的、符合预期的异常情况。一旦发生此类异常，就必须采用某种方式进行处理。除RuntimeException及其子类外，其他的Exception异常都属于可查异常。编译器会检查此类异常，也就是说当编译器检查到应用中的某处可能会此类异常时，将会提示你处理本异常——要么使用try-catch捕获，要么使用throws语句抛出，否则编译不通过。

2）不可查异常：编译器不会进行检查并且不要求必须处理的异常，也就说当程序中出现此类异常时，即使我们没有try-catch捕获它，也没有使用throws抛出该异常，编译也会正常通过。该类异常包括运行时异常（RuntimeException极其子类）和错误（Error）（需要注意error在编译的时候可以通过，但是运行时无法通过）。（运行不通过）

  无论Error或者Exception都具有一些共性内容，比如：不正常情况的信息，引发原因等。有了共性就可以将Error类与Exception类向上抽取：Throwable类：

1.2、异常的处理
1.2.1、异常处理机制
  在java应用中，异常的处理机制分为抛出异常和捕获异常。

1）抛出异常：当一个方法出现错误而引发异常时，该方法会将该异常类型以及异常出现时的程序状态信息封装为异常对象，并交给本应用。运行时，该应用将寻找处理异常的代码并执行。任何代码都可以通过throw关键词抛出异常，比如java源代码抛出异常、自己编写的代码抛出异常等。

2）捕获异常：一旦方法抛出异常，系统自动根据该异常对象寻找合适异常处理器（Exception Handler）来处理该异常。所谓合适类型的异常处理器指的是异常对象类型和异常处理器类型一致。

  对于不同的异常，java采用不同的异常处理方式：

1）运行异常将由系统自动抛出，应用本身可以选择处理或者忽略该异常。

2、对于方法中产生的Error，该异常一旦发生JVM将自行处理该异常，因此java允许应用不抛出此类异常。

3、对于所有的可查异常（既会在编译时出错的异常），必须进行捕获或者抛出该方法之外交给上层处理。也就是当一个方法存在异常时，要么使用try-catch捕获，要么使用该方法使用throws将该异常抛调用该方法的上层调用者。

1.2.2、异常处理语句
1、try-catch语句

try {
	//可能产生的异常的代码区，也成为监控区
	}catch (ExceptionType1 e) {
    //捕获并处理try抛出异常类型为ExceptionType1的异常
    }catch(ExceptionType2 e) {
    //捕获并处理try抛出异常类型为ExceptionType2的异常
        }

  监控区一旦发生异常，则会根据当前运行时的信息创建异常对象，并将该异常对象抛出监控区，同时系统根据该异常对象依次匹配catch子句，若匹配成功（抛出的异常对象的类型和catch子句的异常类的类型或者是该异常类的子类的类型一致），则运行其中catch代码块中的异常处理代码，一旦处理结束，那就意味着整个try-catch结束。含有多个catch子句，一旦其中一个catch子句与抛出的异常对象类型一致时，其他catch子句将不再有匹配异常对象的机会。
  例子1：

//注意视频9-6的5分钟开始处对异常处理流程的描述
public class ExceptionTest {

	public static void main(String[] args) {
		Demo d = new Demo();
		
		try
		{
			int x = d.div(4, 0);
			System.out.println("x="+x);//try代码块出现异常之后的代码不会被执行，因此出现异常后这句不会执行
		}catch(Exception e)//Exception e = new ArithmeticException();
		//这里创建一个Exception类型的引用变量来保存期子类ArithmeticException的对象
		{
			System.out.println(e.getMessage());//获取异常信息。
			System.out.println(e.toString());//获取异常名称：异常信息
			e.printStackTrace();//获取异常名称：异常信息以及异常来源的位置
			//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。该方法打印异常的堆栈的跟踪信息。
		}
		System.out.println("over");
	}
}

class Demo
{
	int div(int a,int b)
	{
		return a/b;
	}
}

2、try-catch-finally

try {
    //可能产生的异常的代码区
   }catch (ExceptionType1 e) {
   //捕获并处理try抛出异常类型为ExceptionType1的异常
   }catch (ExceptionType2 e){
  //捕获并处理try抛出异常类型为ExceptionType2的异常
   }finally{
  //无论是出现异常，finally块中的代码都将被执行
   }

  try-catch-finally的处理过程：
A）try没有捕获异常时，try代码块中的语句依次被执行，跳过catch。如果存在finally则执行finally代码块，否则执行后续代码；
B）try捕获到异常时，如果没有与之匹配的catch子句，则该异常交给JVM处理。如果存在finally，则其中的代码仍然被执行，但是finally之后的代码不会被执行（此时编译出错并由虚拟机在控制台抛出异常，执行完finally之后，代码不会继续执行，下面的部分就交给虚拟机）；
对于（try-finally）语句，如果你要在一个功能中定义一些一定会执行的代码，可以将这些代码放到try-finally语句的finally中，就一定会执行！！！
C）try捕获到异常时，如果存在与之匹配的catch，则跳到该catch代码块执行处理。如果存在finally则执行finally代码块，执行完finally代码块之后继续执行try-catch-finally块之后的代码；
  记住一点：catch是用于处理异常，如果没有catch就代表异常没有被处理过，如果该异常是检测时异常，那么必须声明（在方法外throws），否则编译不通过。
另外注意，try代码块出现异常之后的代码不会被执行。（见下图：）

  总结
try代码块：用于捕获异常。其后可以接零个或者多个catch块。如果没有catch块，后必须跟finally块，来完成资源释放等操作，另外建议不要在finally中使用return，不用尝试通过catch来控制代码流程。

catch代码块：用于捕获异常，并在其中处理异常。

finally代码块：无论是否捕获异常，finally代码总会被执行。**如果try代码块或者catch代码块中有return语句时，finally代码块将在方法返回前被执行。**注意以下几种情况，finally代码块不会被执行：
1、 在前边的代码中使用System.exit(0)退出应用，系统退出，jvm虚拟机结束；
2、 程序所在的线程死亡或者cpu关闭；
3、 如果在finally代码块中的操作又产生异常，则该finally代码块不能完全执行结束，同时该异常会覆盖前边抛出的异常。
  例子1：

/*
finally代码块：定义一定执行的代码,通常用于关闭资源。
 */
//自定义一个负数异常
class FuShuException extends Exception
{
	FuShuException(String msg)
	{
		super(msg);
	}
}

class Demo
{
	int div(int a,int b)throws FuShuException
	{
		if(b<0)
			throw new FuShuException("除数为负数");
		return a/b;
	}
}

public class ExceptionTest {

	public static void main(String[] args) 
	{ 
		Demo d = new Demo();
		try
		{
			int x = d.div(4,-1);
			System.out.println("x="+x);
		}
		catch(FuShuException e)
		{
			System.out.println(e.toString());
			//如果出现异常我们希望程序结束，直接返回，这样finally还是会执行，但是System.out.println("over");不会执行
			return;//返回表示主函数结束
		}
		finally
		{
			System.out.println("finally");//finally中存放的是一定会被执行的代码。
		}
		
		System.out.println("over");
	}
}


/*
*例子：结合10-1的10分钟开始处
class NoException extends Exception
{
}

public void method()throws NoException
{

	连接数据库;

	数据操作;//throw new SQLException();数据库操作出现问题

	关闭数据库;//该动作，无论数据操作是否成功，一定要关闭资源。finally部分，一定要执行！既一定要关闭数据块！


	try
	{
		连接数据库;

		数据操作;//throw new SQLException();
	}
	catch (SQLException e)
	{
	//这里将数据块异常抛给外界不合适，外界处理不了，在这里对数据块异常进行处理具体看视频14分钟开始！
		会先对数据库进行异常处理;//数据块管理者
	//我把数据给你，你没有存储成功（出现异常），你处理完异常之后，你还是需要给我一个结果，说明数据存储失败，那么就报一个数据存储失败的异常（数据库管理者给数据库使用者抛一个使用者能够识别的异常）
		throw new NoException();//不暴露本层的问题，暴露调用者可以识别的问题！这叫做问题的封装！
	}
	finally
	{
		关闭数据库;//无论数据操作会不会抛出异常，这一部分都会执行，既数据库都会关闭！
	}
}
*/

1.2.3、异常抛出语句
1、throws抛出异常
  如果一个方法可能抛出异常，但是没有能力处理该异常或者需要通过该异常向上层汇报处理结果，可以在方法声明时使用throws来抛出异常。这就相当于计算机硬件发生损坏，但是计算机本身无法处理，就将该异常交给维修人员来处理。格式为：

public method Name(params) throws Exception1,Exception2….{}

  其中Exception1，Exception2…为异常列表，一旦该方法中某行代码抛出异常，则该异常将由调用该方法的上层方法处理。如果上层方法无法处理，可以继续将该异常向上层抛。（上层必须处理或者向上抛出）
  例子1：

public class ExceptionTest {

	public static void main(String[] args) //throws Exception 
	//如果不处理，在调用的main方法处抛出异常给虚拟机处理，编译通过。如果参数正确，运行；如果参数错误，不运行。
	{
		Demo d = new Demo();
		try
		{
			//如果调用的方法不说明它本身可能出现问题，我们不知道它是否会发生问题，在此处不处理，一当参数出错，就会导致程序停止
			//因此，对于一个可能出现错误的方法，我们必须使用throws的关键字，声明该功能有可能会出现问题。
			//在此处，div()方法抛出异常，如果这里我们不对其进行处理或向上抛出，在编译的时候会报错
			int x = d.div(4,1);
			System.out.println("x="+x);
		}catch(Exception e)
		{
			e.printStackTrace();//获取异常名称：异常信息以及异常来源的位置	
		}
		System.out.println("over");
	}
}
class Demo
{
	//在功能上通过throws的关键字声明了该功能有可能会出现问题。
	//这样，在调用该方法的上一级就会知道该方法调用时可能出现问题，那么他必须采取继续抛出异常或者处理该异常的措施
	int div(int a,int b) throws Exception 
	{
		return a/b;
	}
}

  例子2：多异常的处理

/*
 对多异常的处理。

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

2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
  不管定义多少个异常，虚拟机只会按代码顺序处理一个异常！！！
   如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。（否则父类会将子类覆盖，而无法处理具体的异常）
   
 3，建立在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace(),也不要简单的就书写一条输出语句。

 */
public class ExceptionTest {

	public static void main(String[] args) 
	{
		Demo d = new Demo();
		
		try
		{
			
			int x = d.div(4,0);
			System.out.println("x="+x);
//		}catch(Exception e)
//		{	//如果想具体的异常具体处理，就不能在这里设置总的Exception来处理异常，应该将父类放在最后
//			System.out.println("代码出现异常");
		}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)//一般不这样设置，因为我们总是想知道具体的异常，所以在不知道具体异常的情况下，就让程序停止
		{
			System.out.println("代码出现异常");
		}
		System.out.println("over");
	}
}

class Demo
{
	//抛出多个异常
	int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException 
	{
		int[] arr = new int[a];
		//如果传入4,0（有2个异常），由于角标越界的代码在数学错误的代码之前，因此会先捕捉到角标越界的异常并处理
		//处理完后不会再处理其他异常，而是直接执行try catch语句后的代码
		//我们发现抛出异常，就会对输入的数值进行修改，等待这个异常被修改正确，再继续运行就会发生数学异常，我们再次对数学异常进行处理，们既每次虚拟机只会按代码顺序处理一个异常
		//同样，如果把数学错误放在前面，就只会捕捉并处理数学错误，而不会处理角标越界
		System.out.println(arr[4]);
		int num = a/b;
		return num;
	}
}

2、throw抛出异常（自定义异常）
  在方法内，用throw来抛出一个Throwable类型的异常。一旦遇到到throw语句，后面的代码将不被执行。然后，便是进行异常处理——包含该异常的try-catch最终处理，也可以向上层抛出。注意我们只能抛出Throwable类和其子类的对象。

throw new ExceptionType(新异常的构造参数，必须在创建新异常的构造方法里面设置);

比如我们可以抛出：throw new Exception();
  也有时候我们也需要在catch中抛出异常,这也是允许的，比如说：

Try{
//可能会发生异常的代码
}catch(Exceptione){
      throw new Exception(e);
}

  例子1：

/*
 因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象，对于这些特有的问题可以按照java的对问题封装的思想，也就是自定义的异常封装。
 
 自定义异常需求：在本程序中，对于除数是负数，也视为是错误的是无法进行运算的。那么就需要对这个问题进行自定义的描述。
 注意点：
1） 当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
要么在内部try catch处理，要么在函数上声明让调用者处理。一般情况，函数内出现异常，函数上需要声明（函数名 throws ExceptionType），将异常抛出。

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

3）必须是自定义类继承Exception。继承Exception原因：异常体系有一个特点：因为异常类和异常对象都被抛出，他们都具备可抛性。
这个可抛性是Throwable这个体系中独有特点，只有这个体系中的类和对象才可以被throws和throw操作。
 
 */
//创建自己的异常
class FuShuException extends Exception
{
	//因为自定义的异常并未定义信息，因此需要我们在自定义类中设置构造方法，这样我们就可以自定义异常信息
	
	/*
	private String msg;
	FuShuException(String msg)
	{
		this.msg = msg;
	}
//	重写Exception的getMessage方法
	public String getMessage()
	{
		return msg;
	}
	其实上面这段的代码Throwable父类已经做过了，如本页最后的代码
	因此我们FuShuException作为Throwable的子类，可以用super(msg)来直接完成上面代码的操作
	*/
	
	FuShuException(String msg)
	{//父类Throwable已经定义了getMessage()方法，我们用super(msg)调用父类的构造方法并给将msg传给父类，
	//这样父类可以通过构造方法给getMessage()赋值，那么，我们就可以new FuShuException(msg).getMessage()
	//也就是在FuShuException类中可以使用getMessage()方法，不懂看最后面的代码
		super(msg);
	}
	//也可以定义空参数的构造函数
	FuShuException()
	{
		super();
	}
	//还有其他需求，比如我们想获取除数负数的值，定义新的构造方法
	private int fushuValue;
	FuShuException(String msg,int b)
	{
		super(msg);
		fushuValue = b;
	}
	//我们这里再设置一个方法给外界获取除数负数
	public int getValue()
	{
		return fushuValue;
	}
	
}

class Demo
{
	//由于这个方法抛出一个我们创建的新的异常，那么如果我们本方法不处理，就必须抛出给调用者处理
	int div(int a,int b) throws FuShuException 
	{
		//我们自定义的异常java不认识，因此一当满足条件，我们用throw关键字手动抛出
		if(b<0)//如果除数小于0，那么我们将新创建的FuShuException的对象抛出，表示出现了这个异常
			throw new FuShuException("出现了除数是负数的情况 / by fushu",b);
		return a/b;
	}
}

public class ExceptionTest {

	public static void main(String[] args) 
	{
		Demo d = new Demo();
		
		try
		{
			
			int x = d.div(4,-5);
			System.out.println("x="+x);
		}catch(FuShuException e)
		{
			System.out.println(e.toString());//toString方法自动调用getMessage()
//			System.out.println("被除数为负数");
			//在捕获异常的时候，就可以通过getValue来获取除数负数
			System.out.println("负的除数为："+e.getValue());
		}
		System.out.println("over");
	}
}

/*
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);
	}
}
new Exception().getMessage();

class Person
{
	String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
}

class Student extends Person
{
	Student (String name)
	{
		super(name);
	}
}

new Sttdent("lisi").getName();
*/

结果是：

FuShuException: 出现了除数是负数的情况 / by fushu
负的除数为：-5
over

  throws和throw的区别：
1）throws使用在函数上，throw使用在函数内；
2）throws后面跟的异常类，可以跟多个，用逗号隔开。throw后跟的是异常对象。

1.3、RunningtimeException运行时异常
  先看一个例子

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

1）如果在函数内容抛出该异常（throw），函数上可以不用声明，编译一样通过，且调用该函数的上一级一样可以捕捉处理
2）如果在函数上声明了该异常（throws）。调用者可以不用进行处理，编译一样通过；虚拟机会处理！

之所以不用在函数声明，是因为不需要让调用者处理。
当该异常发生，我们希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
所以我们不需要设置代码处理 RunningtimeException，让其被虚拟机处理报错，停止程序，让我们修改代码！！！
因此，就算我们在方法内抛出RunningtimeException及其子类的对象，也不需要在函数上声明（throws）;
就算我们在方法上声明抛出这些类，也不需要在调用处设置代码处理！
具体看最下面的例子
 */
//
class FuShuException extends Exception
{	
	
}

class Demo
{
	int div(int a,int b) //在函数内抛ArithmeticException的时候，函数外不抛这个异常没事,但是如果抛出的是Exception，就不行。
	//原因：ArithmeticException是RunningtimeException的子类，对于RunningtimeException及其子类，
	//我们在函数内手动将其抛出，函数上不需要声明将其抛出（不需要在函数上throws RunningtimeException）
	{
		//对于算术异常这种java会自动抛出的异常，我们尝试手动将其抛出
		//由于算数异常的构造方法有一个包含String参数的构造方法：ArithmeticException(String s)，我们尝试给其加上参数
		if(b == 0)
			throw new ArithmeticException("出现算数异常:除数为零");
		
		return a/b;
		
	}
	//再设置一个除数的函数，我们直接在函数体外抛出算数异常
	int div2(int a,int b) throws ArithmeticException
	{	
		return a/b;
	}
}

public class ExceptionTest {

	public static void main(String[] args) 
	{
		Demo d = new Demo();
		
		try
		{
			int x = d.div(4, 0);
			System.out.println("x="+x);
		}catch(ArithmeticException e)
		{
			System.out.println(e.toString());
		}
		System.out.println("over");
		
		//按道理说我们在div2方法抛出了异常，在调用它的时候应该处理异常，但是不处理依然可以编译通过，但是不能运行！
		//ArithmeticException是RunningtimeException的子类，对于RunningtimeException及其子类，
		//在方法体外抛出它，在调用该方法的时候也可以不处理，不抛出，因为它是运行时异常
		int x = d.div2(4, 0);
		System.out.println("x="+x);
		System.out.println("over2");
	}
}
/*
 * 第一部分运行结果是：这里我们手动try-catch异常，对运行时异常进行手动处理
 java.lang.ArithmeticException: 出现算数异常:除数为零
over
可以手动抛出java会自动抛出的类来添加我们想输出异常信息（如果该类有参数是String的构造函数）

 * 第二部分运行结果是：这部分我们没有处理异常，而是虚拟机检测到运行时异常自己对运行时异常进行处理
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at Demo.div2(ExceptionTest.java:26)
	at ExceptionTest.main(ExceptionTest.java:47)
 */


/*
class Person
{
	public void checkName(String name)
	{
		
		//if(name.equals("lisi"))//NullPointerException，如果传入null，name不能为空，
		否则 出现空指针异常，程序就必须停止，因为name都没有值，无法进行运算，必须修正代码让程序运行
		
		如下，按理说，如果传进来null，打印结果也应该为no，为了实现传入null程序也可以运行，我们修改代码
		equals()内可以传入空的值，但是调用它的name不能为空（既调用方法不能为空），我们将代码改为下面：
		if("lisi".equals(name))//if(name!=null && name.equals("lisi"))
			System.out.println("YES");
		else
			System.out.println("no");
	}
}

main()
{
	Person p = new Person();
	p.checkName(null);
}
*/

  整合上面RunningtimeException的例子，对于自定义异常，如果该异常的发生，程序无法再继续进行运算，就让自定义异常继承RuntimeException。这样我们就不需要在出现异常的方法外声明该异常（throws），也不需要在调用出处理该异常（try catch），而是给虚拟机处理，发现该错误并警告，让我们可以修改错误的代码让该异常不再发生！
  也就是说，RunningtimeException异常不需要标识抛出（throws），也不需要我们在代码内部用try-catch处理，只要你敢让程序出现这种异常，它就让程序停下来，使用该方法的人必须修正代码（如修改输入的参数不为0）；而非RunningtimeException抛出，说明我们可以在内部编写try-catch语句处理它，而不需要修改我们的代码。
  也就是非RunningtimeException异常不会完全影响运算，可以捕捉处理；而
RunningtimeException异常影响运算，必须让程序停下。
  RunningtimeException异常及其子类编译的时候是可以通过的，但是运行时虚拟机才会检测其错误而不通过！
  对于异常分两种：
1）编译时被检测的异常，需要我们设置（try-catch）代码处理或者抛出（throws），否则编译失败，这种异常是可处理的；
2）编译时不被检测的异常(运行时异常。RuntimeException以及其子类)
**（这一段具体看9-11视频）**理解一下这个视频，运行时异常的原理就懂了！
  例子2

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

对于FuShuException,我们认为如果除数是负数，程序也无法继续运行，
这个时候，更确切的方式是让FuShuException继承RuntimeException
 */

class FuShuException extends RuntimeException
{
	FuShuException(String msg)
	{
		super(msg);
	}
}

class Demo
{//这个方法抛出的FuShuException与ArithmeticException都是RuntimeException，
//因此，我们在这个方法体外面不声明抛出异常，在自己的代码里面不设置处理（如果在这里处理，反而使得这个异常对调用者隐藏，这样反而无法使得调用者修改参数），让虚拟机处理，以便可以显示异常，让调用者修改输入参数处理。
	int div(int a,int b) 
	{
		if(b<0)
			throw new FuShuException("出现了除数为负数了");//自己定义的运行时异常，必须自己在相应的位置抛出，虚拟机才会识别并触发
		if(b==0)
			throw new ArithmeticException("被零除啦");//原有的运行时异常，就算我们不在这里抛出，虚拟机也会识别
		return a/b;
	}
}

public class ExceptionTest {

	public static void main(String[] args) 
	{
		Demo d = new Demo();
		int x = d.div(4,-9);
		System.out.println("x="+x);		
		
		System.out.println("over");
	}
}
/*
*结果是：
Exception in thread "main" FuShuException: 出现了除数为负数了
	at Demo.div(ExceptionTest.java:22)
	at ExceptionTest.main(ExceptionTest.java:34)
程序停下，虚拟机报错提醒我们修改代码更正程序
*/

1.4、异常覆盖时的异常特点（视频10-3）
  异常在子父类覆盖中的体现；
1）类在覆盖父类方法时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类；
2）如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。或者是这些异常的子类！
3）如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果这个时候子类方法发生了异常，就必须要进行try处理，绝对不能抛。

  总结就是，子类的异常必须是父类的异常或父类异常的子类，子类的异常的数量少于等于父类！子类有父类没有的异常必须处理！
  例子：

class AException extends Exception
{}

class BException extends AException
{}

class CException extends Exception
{}
/*
Exception 
	|--AException
		|--BException
	|--CException
*/
class Fu
{
	void show()throws AException
	{
	
	}
}

class Test
{
	void function(Fu f)
	{
		try
		{
			f.show();
		}
		catch (AException e)
		{

		}
		
	}
}

class Zi extends Fu
{
	void show()throws CException//出错，不能抛出父类异常及其子类之外的异常 
	{
		//子类不能抛出CException，如果子类这个方法中真的出现CException，只能try处理，而不能抛出！
	}
}

class  
{
	public static void main(String[] args) 
	{
		Test t = new Test();
		t.function(new Zi());
	}
}

1.5、异常总结
  具体见视频（10-5）

/*
异常是什么？
是对问题的描述，将问题进行对象的封装。
------------
异常体系：
	Throwable
		|--Error
		|--Exception
			|--RuntimeException

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

--------------
throw和throws的用法：

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


当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败。
注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。
--------------
如果函数声明了异常，调用者需要进行处理，处理方法可以throws可以try。

异常有两种：
	编译时被检测异常
		1）该异常在编译时，如果没有处理(没有抛也没有try)，编译失败；
		2）该异常被标识，代表这可以被处理。
	运行时异常(编译时不检测)
		1）在编译时，不需要处理，编译器不检查，但是运行时虚拟机会处理，停止程序，报错提醒调用者修改输入参数等代码，以使程序正常运行；
		2）该异常的发生，建议不处理，让程序停止，需要对代码进行修正。
--------------
异常处理语句：
try
{
	需要被检测的代码；
}
catch ()
{
	处理异常的代码；
}
finally
{
	一定会执行的代码；
}

有三个结合格式：
1.	try
	{
		
	}
	catch ()
	{
	}

2.	try
	{
		
	}
	finally
	{
	
	}


3.	try
	{
		
	}
	catch ()
	{
	}
	finally
	{
	
	}



注意：
1，finally中定义的通常是 关闭资源代码。因为资源必须释放。
2，finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。

--------------
自定义异常：
	定义类继承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内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句，也不要不写。
		当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
		try
		{
			throw new AException();
		}
		catch (AException e)
		{
			throw e;
		}

		如果该异常处理不了，但并不属于该功能出现的异常，可以将异常转换后，再抛出和该功能相关的异常。
		或者异常可以处理，但是需要将异常产生的和本功能相关的问题提供出去，让调用者知道并处理，可以将捕获异常处理后，转换新的异常。
		try
		{
			throw new AException();
		}
		catch (AException e)
		{
			// 对AException处理。
			throw new BException();
		}

		比如，汇款的例子。

	
异常的注意事项：
	在子父类覆盖时：
	1，子类抛出的异常必须是父类的异常的子类或者子集。
	2，如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

参阅
ExceptionTest.java 老师用电脑上课
ExceptionTest1.java 图形面积。

2、java异常补充
补充1：
  Java处理异常的方式是中断处理。

• 异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

补充2：
  异常产生过程的解析——就业班-异常-03

补充3：
  throw关键字的演示

package lkj.demo1;

public class ExceptionTest
{
    public static void main(String[] args) {
        int[] arr = null;

//        int[] arr = new int[3];
//        int e = getElement(arr,3);
//        System.out.println(e);
    }
    /*
        定义一个方法,获取数组指定索引处的元素
        参数:
            int[] arr
            int index
        以后(工作中)我们首先必须对方法传递过来的参数进行合法性校验
        如果参数不合法,那么我们就必须使用抛出异常的方式,告知方法的调用者,传递的参数有问题
        （这种方法一般使用运行期异常，因为要显示在控制台给调用者提示，必须由虚拟机处理异常）
        注意:
            NullPointerException是一个运行期异常,我们不用处理,默认交给JVM处理
            ArrayIndexOutOfBoundsException是一个运行期异常,我们不用处理,默认交给JVM处理
     */
    public static int getElement(int[] arr,int index){
        /*
            我们可以对传递过来的参数数组,进行合法性校验
            如果数组arr的值是null
            那么我们就抛出空指针异常,告知方法的调用者"传递的数组的值是null"
         */
        if(arr == null){
            //按条件抛出相应的空指针异常，这里的方法可以不用抛出，JVM也会识别到
            //甚至我们对于JVM里面有定义的运行时异常，我们不抛出JVM在这种异常发生的时候也会自动识别
            //对于我们自己定义的运行期异常，则需要我们在相应的异常发生地点手动抛出，否则虚拟机无法识别
            throw new NullPointerException("传递的数组的值是null");
        }

        /*
            我们可以对传递过来的参数index进行合法性校验
            如果index的范围不在数组的索引范围内
            那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"
         */
        if(index<0 || index>arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
        }

        int ele = arr[index];
        return ele;
    }
}

补充4：
  Objects类的非空判断——使用该方法可以判断传入的对象是否为空，为空的话Objects.requireNonNull()方法会自动抛出空指针异常

package com.itheima.demo01.Exception;

import java.util.Objects;

/*
    Objects类中的静态方法（该方法JDK1.7之后才有，1.6的文档查不到）
    public static <T> T requireNonNull(T obj):查看指定引用对象不是null。
    源码:
        public static <T> T requireNonNull(T obj) {
            if (obj == null)
                throw new NullPointerException();
            return obj;
        }
 */
public class ExceptionTest {
    public static void main(String[] args) {
        method(null);
    }

    public static void method(Object obj){
        //对传递过来的参数进行合法性判断,判断是否为null
        /*if(obj == null){
            throw new NullPointerException("传递的对象的值是null");
        }*/

        //使用Objects的requireNonNull方法可以对参数是否为空进行判断，为空的话会直接抛出空指针异常
        //Objects.requireNonNull(obj);
        Objects.requireNonNull(obj,"传递的对象的值是null");
    }
}

补充5：
  Throwable类中定义了3个异常处理的方法

String getMessage() 返回此 throwable 的简短描述。
String toString() 返回此 throwable 的详细消息字符串。
void printStackTrace()  JVM打印异常对象,默认此方法,打印的异常信息是最全面的

补充6：
  当使用多个catch捕获子父类异常的时候，为什么子类异常必须在父类异常之前捕获

补充7：
  如果finally有return语句,永远返回finally中的结果,避免该情况。

package com.itheima.demo03.Exception;
/*
    如果finally有return语句,永远返回finally中的结果,避免该情况.
 */
public class Demo02Exception {
    public static void main(String[] args) {
        int a = getA();
        System.out.println(a);//100
    }

    //定义一个方法,返回变量a的值
    public static int getA(){
        int a = 10;
        try{
            return a;
        }catch (Exception e){
            System.out.println(e);
        }finally {
            //一定会执行的代码
            a = 100;
            return a;
        }

    }
}

补充8：
  如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类如果产生该异常，只能捕获处理，不能声明抛出。

补充9：
  自定义异常练习

package com.itheima.demo01.Exception;

import lkj.demo1.MyException;

import java.util.Scanner;

/*
    要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

    分析:
        1.使用数组保存已经注册过的用户名(数据库)
        2.使用Scanner获取用户输入的注册的用户名(前端,页面)
        3.定义一个方法,对用户输入的中注册的用户名进行判断
            遍历存储已经注册过用户名的数组,获取每一个用户名
            使用获取到的用户名和用户输入的用户名比较
                true:
                    用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";
                false:
                    继续遍历比较
            如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
 */
public class ExceptionTest {
    static String[] usernames = {"张三","李四","王五"};
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String name = sc.next();
        for(String us : usernames)
        {
            if(us.equals(name))
            {
                try
                {
                    throw new MyException("用户名已经被注册");
                }
                catch (MyException e)
                {
                    e.printStackTrace();
                    return; //结束方法，如果不停止方法，后面“恭喜您注册成功还是会打印出来”
                }
            }
        }
        //如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
        System.out.println("恭喜您,注册成功!");
    }
}