Java之异常

/*

java中的异常处理一般分成两种
1.捕获
需要专门代码来处理


try{
出现异常的代码块
}catch(异常类型  名字){
处理异常的代码块
}finally{
一般情况下都是做关闭动作.
}


如果try块中的代码出现的异常，那么catch中指定的是出现的这种异常，
那么这个catch中的内容就会被执行.
如果try块中没有出现异常，代码正常运行，catch中的内容不会执行。

*/

class Demo7 
{
	public static void main(String[] args) 
	{
		ExceptionDemo7 ed=new ExceptionDemo7();

		ed.method();
	}
}


class ExceptionDemo7
{

	public void method(){
		
		try{
			int[] arr=new int[5];

			System.out.println(arr[5]);

		}catch(Exception e){
			System.out.println("数组下标越界");
			System.out.println(e.getMessage()); //错误信息
			System.out.println(e.toString());//得到异常类型:错误信息
			
			e.printStackTrace();//得到异常的详细信息(堆栈信息) 如果你没有处理异常，
			                    //jvm将异常信息展示出来是
			                     //其实也是在默认调用这个方法。
		}

	}


	//使用捕获的方式对异常进行处理
	public void show(){
		
		try{

			Object obj=null;
			//定义一个Object对象，初始值为null

			String s=obj.toString();  /*
										当程序运行到这里时，jvm发现obj为null,不可以调用toString方法，
										这时，jvm就将这个问题封装成了NullPointerException对象，
										并将这个对象，传递给了catch中的e,出现异常问题的代码下面的内容不在
										被执行。这时，catch中的内容就被执行了。

										*/
			//调用Object类中的toString方法
			
			System.out.println(s);
			//得到toString方法的返回值并打印

		}catch(Exception e){ //Exception e=new NullPointerException();
			
			System.out.println("出现问题了，空指针");

		}
	}
}
/*
	Exception in thread "main" java.lang.NullPointerException
        at ExceptionDemo7.show(Demo7.java:33)
        at Demo7.main(Demo7.java:22)
*/

异常处理的第二种方式  抛出

会使用到一个关键字  throws

处理异常时，到底是捕获还是抛出.

取决于当前程序中是否可以解决这个问题，如果可以解决，那么捕获，
如果不能解决，抛出。

class Demo8 
{
	public static void main(String[] args) 
	{
		ExceptionDemo8 ed=new ExceptionDemo8();
		
		try{
			ed.show();
		}catch(Exception e){
			System.out.println("出现了异常");
		}
		/*
			对于这时，可以采用try..catch。。
			另外也可以继续抛出 throws Exception
		*/
	}
}

class ExceptionDemo8
{
	//处理异常的第二种方式 throws
	public void show() throws Exception{
		
		int[] arr=null;

		System.out.println(arr.length);
	}
}

java中的异常分成两大类


1.编译异常
我们在编译的过程中，代码上就有要求，需要你对产生异常的代码进行
处理(捕获，抛出)  Exception类及其子类，RuntimeException类以外的所有类及其子类
2.运行异常
我们在运行时才产生的异常，这种异常我们可以不用代码对其进行处理，
当出现问题时，jvm，或服务器将其捕获到。
包括了RuntimeException及其子类.
*/

class Demo9 
{
	public static void main(String[] args) 
	{
		ExceptionDemo9 ed=new ExceptionDemo9();

		ed.show();
	}
}


class ExceptionDemo9
{

	public void show() throws RuntimeException {
	/*
		throws Exception 这个抛出的是编译异常，那么谁在调用这个方法，必须要对异常进行处理

		throws RuntimeException 使用这个方法，可以不用处理这个异常。
	*/
		
		int[] arr=null;

		System.out.println(arr.length);
	}
}

自定义异常

自定义异常其实就是我们自已写的一个类
这个类要想是一个异常类，那么必须继承自
Exception或其子类.

当你继承异常类后，我们自定义的异常类就有了
异常的一些特点.

throws 与 throw 区别

位置 :
throws用在 方法后面

throw 用在方法内 

后面跟的内容
throws 后面跟着的是异常，如果有多个，可以使用分号分开
throw 它后面跟着的是一个异常对象。

无论是throws还是throw都只能操作异常。

*/

class Demo10 
{
	public static void main(String[] args) 
	{
		ExceptionDemo10 ed=new ExceptionDemo10();
		
		try{
			ed.add(10,-20);
		}catch(Exception e){
			System.out.println(e.getMessage());
		}
	}
}

class ExceptionDemo10
{	
	/*
		这个方法要求两个数必须是正数.

		使用另外一个关键字  throw  

		它可以抛出一个异常
	*/
	public void add(int a,int b) throw Exception{
		
		if(a<0||b<0){
			throw new Fs("出现了负数");
		}
		int c=a+b;

		System.out.println(c);

	}
}

//自定义异常类  负数异常
/*
	如果当前的自定义异常是继承自 RuntimeException及其子类，
	那么在throw出这个异常对象时，就可以不用进行出现，因为
	你自定义的异常也是一个运行时异常
*/

class Fs extends Exception
{
	public Fs(){
	
	}
	public Fs(String message){
		super(message);
	}
}
/*
class Exception{
	
	public Exception(){}

	public Exception(String message){
		super(message);
	}
}

class Throwable{
	
	private String message;

	public Throwable(String message){
		
		this.message=message;
	}
}



*/

finally

finally块中的内容，无论是否产生异常，都会被执行。
我们就可以在其中完成一些关闭资源的动作.

class Demo11 
{
	public static void main(String[] args) 
	{
		ExceptionDemo11 ed=new ExceptionDemo11();

		ed.show();
	}
}

class ExceptionDemo11
{

	public void show(){
		
		try{
			Object obj=new Object();

			obj.toString();

		}catch(Exception e){

			System.out.println("出现异常");
	
		}finally{
			System.out.println("finally");
		}
	}
}

/*
异常细节

1.如果父类中的被重写方法抛出异常,那么子类中的重写的方法可以不抛出，或者抛出一样的异常

2.如果父类中的被重写方法抛出异常，那么子类可以抛出相同的异常或父类抛出异常的子类异常.

3.如果父类中的被重写方法抛出多个异常，那么子类中重写的方法可以不抛出任何异常，或者与父类
 相同的异常或这些异常的子类.

如果被重写的方法没有抛出任何异常,但是在重写的方法中出现的异常，这时
只能在内部处理 try....catch，不可以进行抛出。

*/

class Demo12 
{
	public static void main(String[] args) 
	{
		
	}
}

class Father
{
	public void show() throws AException,BException,CException{
		
		System.out.println("father show");
	}

	public void method(){
	
	}
}

class Son extends Father
{
	public void show()throws AAException,BBException{
		
		System.out.println("son show");
	}

	public void method() {
		try{
			int[] arr=null;

			arr.length;
			
		}
	}
}


class AException extends Exception
{
}

class AAException extends AException
{
}

class BException extends Exception
{
}

class BBException extends BException
{
}

class CException extends Exception
{
}

/*
异常转型示例
*/

class Demo13 
{
	public static void main(String[] args) 
	{
		try{
			new OperationDb().add(30);
		}catch(AgeOutException e){
			System.out.println("发现年龄出现问题，从新得到年龄，在调用添加操作");
		}
	}
}


class OperationDb
{
	void add(int age) throws AgeOutException{
		try{
			//连接数据库
			//操作数据库1
			if(age<20||age>50){
				throw new AddMessageException();
			}
			System.out.println("添加数据成功");

			//操作数据库1
		}catch(AddMessageException e){
			
			//我们不能对要操作的数据进行处理，应该给调用这个add方法者传递一个它能
			//处理的异常
			throw new AgeOutException();
		}finally{
			//关闭数据库
		}

		
	}
}

//添加信息异常
class AddMessageException extends Exception
{
}

//年龄超出异常
class AgeOutException extends Exception
{
}