Java基础——异常处理

一、概述

定义：是在运行时期发生的不正常情况。在Java中，用类的形式对不正常的情况进行了描述和封装对象。描述不正常的情况的类，就成为异常类。以前正常流程代码和问题处理代码相结合，现在讲正常流程代码和问题处理代码分离。提高阅读性。

其实一场就是java通过面向对象的思想将问题封装成了对象。用异常类对其进行描述。不同问题用不同的类进行具体的描述。比如角标越界、空指针等等。

关键字：try, catch, finally, throw, throws

二、体系

无论是error还是exception，问题发生就应该可以跑出，让调用者知道并处理。该体系的特点就在于throwable激起所有的子类都具有可抛型。

问题最终分成了两大类：Throwable（可抛出性）

1.一般不可处理的：Error

特点：是由JVM抛出的严重性的问题。这种问题一般不进行处理，直接修改程序。

2.可以处理的：Exception

该体系的特点：

子类的后缀名都是用其父类名，阅读性很强。

那么可抛型怎么提现呢？

• 两个关键字throw，throws所操作的类和对象都具备可抛型。

三、原理

1.将异常实例化

2.抛给调用自己的地方

如此循环

可以自己手动throw new xxxException("balabala");

四、自定义异常

当遇到异常没有被定义过的情况，那就按照Java异常的创建思想，面向对象，将错误进行自定义描述。并封装成对象。

注意：如果让一个类成为异常类，必须要继承异常体系，因为只有成为异常体系的子类才有资格具备可抛性。才可以变成两个关键字所操作：throw和throws

class Demo
{
	public int method(int[] arr,int index) throws FuShuIndexException//注意这里
	{		

		if(arr==null)
			throw new NullPointerException("数组的引用不能为空！");

		if(index>=arr.length)
		{
			throw new ArrayIndexOutOfBoundsException("数组的角标越界啦，哥们，你是不是疯了？："+index);
		}
		if(index<0)
		{
			throw new FuShuIndexException("角标变成负数啦！！");
		}
		return arr[index];
	}
}

class  ExceptionDemo3
{
	public static void main(String[] args) throws FuShuIndexException//和这里
	{
		int[] arr = new int[3];
		
		Demo d = new Demo();
		int num = d.method(null,-30);
		System.out.println("num="+num);
		System.out.println("over");
	}
	
}

异常的分类：
1，编译时被检测异常:只要是Exception和其子类都是，除了特殊子类RuntimeException体系。 
        这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
        这样的问题都可以针对性的处理。

2，编译时不检测异常(运行时异常):就是Exception中的RuntimeException和其子类。
        这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的而或者引发了内部状态的改变导致的。
        那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止,让调用者对代码进行修正。

所以自定义异常时，要么继承Exception。要么继承RuntimeException。

throws 和throw的区别。

1，throws使用在函数上。throw使用在函数内。
2，throws抛出的是异常类，可以抛出多个，用逗号隔开。 throw抛出的是异常对象。

五、try...catch异常捕捉

异常处理的捕捉形式：这是可以对异常进行针对性处理的方式。

具体格式是：

try
{
	//需要被检测异常的代码。
}
catch(异常类 变量)//该变量用于接收发生的异常对象
{
	//处理异常的代码。
}
finally
{
	//一定会被执行的代码。
}

举个小栗子：

class Demo
{
	public int method(int[] arr,int index) throws NullPointerException, FuShuIndexException
	{	
		if(arr==null)
			throw new NullPointerException("没有任何数组实体");
		if(index<0)
			throw new FuShuIndexException();
			
		return arr[index];
	}
}

class  ExceptionDemo4
{
	public static void main(String[] args) 
	{
		int[] arr = new int[3];		
		Demo d = new Demo();
		try
		{
			int num = d.method(null,-1);//调用了会抛出异常的方法，放到try里
			System.out.println("num="+num);
			
		}
		catch(NullPointerException e)
		{
			System.out.println("异常了");
		}
		catch (FuShuIndexException e)
		{
			System.out.println("负数角标异常!!!!");
		}
		System.out.println("over");
	}
	
}

 六、多catch考点

1.父类exception放在最先面

2.判断到底触发哪个异常

七、异常处理原则

1，函数内容如果抛出需要检测的异常，那么函数上必须要声明。否则必须在函数内用trycatch捕捉，否则编译失败。

2，如果调用到了声明异常的函数，要么trycatch要么throws，否则编译失败。

3，什么时候catch，什么时候throws 呢？

• 功能内容可以解决，用catch。
• 解决不了，用throws告诉调用者，由调用者解决 。

4，一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。

• 内部又几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

八、finally代码块

finally代码块是无论出现何种情况（try找没找到异常）都会执行的代码块。

class Demo
{
	public int show(int index)throws ArrayIndexOutOfBoundsException
	{

		if(index<0)
			throw new ArrayIndexOutOfBoundsException("越界啦！！");
		int[] arr = new int[3];
		return arr[index];
	}
}


class ExceptionDemo5 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			
			int num = d.show(-1);
			System.out.println("num="+num);
		}
		catch (ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());

//			return ;//finally可以执行到
//			System.exit(0);//退出jvm。finally不能执行到
		}
		finally//通常用于关闭(释放)资源。
		{
			System.out.println("finally");
		}

		System.out.println("over");

	}
}

九、总结

1.try catch finally 代码块组合特点：

1. try catch finally
2. try catch(多个)当没有必要资源需要释放时，可以不用定义finally。
3. try finally 异常无法直接catch处理，但是资源需要关闭。 

//该函数将返回0，而a++代码虽然会被执行但是并不会返回
int show() throws Exception
{
    int a=0;
	try
	{
		//开启资源。
		//巴拉巴拉搞事情，没有异常的话
        return a;
	}
	finally
	{
        a++;
		//关闭资源。
	}
}

2.异常应用

需求：毕老师用电脑上课。

//出现异常比如电脑蓝屏啦。冒烟啦。

class LanPingException extends Exception
{
	LanPingException(String msg)
	{
		super(msg);
	}
}

class MaoYanException extends Exception
{
	MaoYanException(String msg)
	{
		super(msg);
	}
}

class NoPlanException extends Exception
{
	NoPlanException(String msg)
	{
		super(msg);
	}
}
//问题涉及两个类：电脑和老师
class Computer
{
	private int state = 2;
	public void run()throws LanPingException,MaoYanException
	{
		if(state==1)
			throw new LanPingException("电脑蓝屏啦！！");
		if(state==2)
			throw new MaoYanException("电脑冒烟啦！！");

		System.out.println("电脑运行");
	}
	public void reset()
	{
		state = 0;
		System.out.println("电脑重启");
	}
}

class Teacher
{
	private String name;
	private Computer comp;
	Teacher(String name)
	{
		this.name = name;
		comp = new Computer();
	}
	
	public void prelect()throws NoPlanException
	{
		try
		{
			comp.run();
			System.out.println(name+"讲课");
			
		}
		catch (LanPingException e)
		{
			System.out.println(e.toString());
			comp.reset();
			prelect();
		}
		catch (MaoYanException e)
		{
			System.out.println(e.toString());
			test();
			//可以对电脑进行维修。
//			throw e;
			throw new NoPlanException("课时进度无法完成，原因："+e.getMessage());
		}

	}
	public void test()
	{
		System.out.println("大家练习");
	}
}	
class ExceptionTest 
{
	public static void main(String[] args) 
	{
		Teacher t  = new Teacher("毕老师");
		try
		{
			t.prelect();
			
		}
		catch (NoPlanException e)
		{
			System.out.println(e.toString()+"......");
			System.out.println("换人");

		}
	}
}

3.注意事项

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

简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集。 

注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try .

class A extends Exception {}

class B extends A {}
class C extends Exception {}

Exception
	|--A
		|--B
	|--C

class Fu
{
	void show()throws A {}
}

class Test
{
	void method(Fu f)//Fu f  = new Zi();
	{
		try
		{
			f.show();
		}
		catch (A  a) {}
	}
}

class Zi extends Fu
{
	void show()throws C {}
}

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