面向对象7_【异常】【异常的处理】【异常的应用】

异常

异常：是在运行时期发生的不正常情况。在java中用类的形式对不正常情况进行了描述和封装对象。描述不正常的情况的类，就称为异常类。 

  以前正常流程代码和问题处理代码相结合，现在将正常流程代码和问题处理代码分离。提高阅读性.

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

问题很多，意味着描述的类也很多，将其共性进行向上抽取，形成了异常体系。

 

throwable体系的特点：

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

throw  new arrayIndexOutofBondsException(“自定义抛出显示内容”)

 

对于角标是整数不存在，可以用角标越界表示，对于负数为角标的情况，准备用负数角标异常来表示。

 负数角标这种异常在java中并没有定义过。那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述。并封装成对象。

 

这种自定义的问题描述成为自定义异常。 

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

thorwable类所有异常和错误的超类，有两个子类error和exception，分别表示错误和异常。其中异常类Exception又分为运行时异常（RuntimeException）和检查异常（Checked Exception）。

两者的区别：Error和Exception

Error是程序无法处理的错误，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，java虚拟机（JVM）一般会选择线程终止。
Exception是程序本身可以处理的异常，这种异常分两大类：运行时异常和非运行时异常。程序中应当尽可能去处理这些异常。

运行时异常和非运行时异常

运行时异常都是RuntimeException类及其子类异常，如NullPointerException、IndexOutOfBoundsException等，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般是有程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。
非运行时异常是RuntimeException以外的异常，类型上属于Exception类及其子类。从程序角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常，一般情况下自定义检查异常。

 

throws 和throw的区别。

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

   throw使用在函数内。抛出的是异常对象。

class FuShuIndexException extends Exception //自定义异常类必须继承异常体系才具有可抛性
{
	FuShuIndexException()
	{}
	FuShuIndexException(String msg)
	{
		super(msg);
	}
}
class Demo
{
	public int method(int[] arr,int index)//throws NullPointerException//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");
	}
}

异常的处理

可以对异常进行针对性处理，无catch,不处理。能处理就try catch,不能处理就抛

如果try没有检测到异常，catch就不会运行

<span style="font-size:14px;"><strong>try
{
需要被检测的代码；//将被检测到的一场对象抛给catch
}
catch(异常类 变量)	//该变量用于接收发生异常的对象
{
处理异常的代码；(处理方式)
}
finally
{
一定会执行的语句；
}</strong></span>

<strong><span style="font-size:18px;">使用示例</span></strong>

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

class Demo 
{
	public int method (int[] arr,int index) throws FushuIndexException	//此处声明抛出，交由catch处理
	{
		if (index<0)
		{
			throw new FushuIndexException("角标不能为负");
		}
		return arr[index];
	}
}

class  ExceptionDemo1
{
	public static void main(String[] args) //throws FushuIndexException		此处不需要再抛出，因为给catch处理了
	{
		int[] arr= new int[3];
		Demo d=new Demo();
		try
		{
			int num=d.method(arr,-10);
			System.out.println("num="+num);
		}
		catch (FushuIndexException e)//异常类，要做针对性处理，不建议使用Exception
		{
			System.out.println("Message"+e.getMessage());//返回此异常对象的字符消息(异常信息)
			System.out.println("String"+e.toString());//异常名称:异常信息
			e.printStackTrace();//jvm默认异常处理机制	打印此异常对象的 异常名称 异常信息 异常位置
			System.out.println("负数角标异常");
		}											//log for java
		System.out.println("over");
	}
}

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

String getMessage(); 异常名称

toString() 异常名称： 异常信息

e.printStackTrace() 异常名称 信息 位置

其实jvm默认的异常处理机制，就是在调用printStackTrace方法。打印异常的堆栈的跟踪信息。

多catch

catch是用于给异常对象针对性处理，多catch最多只会执行一个，所以在定义参数列表的异常范围必须是从小到大，否则编译器会报错，例如（Exception e）是所有异常的根类，父类必须放在最后面

 

异常处理的原则：

1.函数中如果抛出了需要检测的异常，必须声明或捕捉，否则编译失败

2.如果调用到了声明异常的函数，必须throws或者try catch ，否则编译失败

3.能解决就catch,不能解决就用throws告诉调用者，由调用者解决

4.一个功能抛出了几个异常，调用时就必须对应多个catch针对性处理

finally{}

一定会执行的语句，除非退出虚拟机System.exit(0);

作用：关闭资源

try catch finally 代码块组合特点

try catch  当没有必要资源释放时，可以不用定义finally

try finally 异常无法直接catch处理,，但是资源需要被关闭

连接数据库示例

<span style="font-size:12px;"><strong>try{
	添加数据，出现异常SQLException();
}
catch(SQLException e){
	//处理代码
	throw new NoAddException();
}
finally{
	关闭数据库
}</strong></span>

异常的应用

异常转换和封装

能解决就解决，不能解决就抛出由调用者解决，多层调用要分清

练习：毕老师讲课

/*毕老师讲课
异常类
电脑 类
teacher类
主类
*/

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 resert()
	{
		state =0;
		System.out.println("重启");
	}
}

class Teacher
{
	private String name;
	private Computer comp;<strong>//类类型的参数</strong>
	Teacher(String name)
	{
		this.name=name;
		comp =new Computer();
	}
	void tea() throws NoPlanException
	{
		try
		{
			comp.run();
			System.out.println(name+"讲课");
		}
		catch (LanPingException e)
		{
			System.out.println(e.toString());//<strong>toString()方法返回异常名称和异常信息</strong>
			comp.resert();
			tea();
		}
		catch(MaoYanException e)
		{
			System.out.println(e.toString());
			test();
			throw new NoPlanException("课程无法完成");
		}
	}	
	public void test()
	{
		System.out.println("自己练习");
	}
}

class  ExceptionTest1
{
	public static void main(String[] args) 
	{
		Teacher t = new Teacher("毕老师");
		try
		{
			t.tea();  			
		}
		catch (NoPlanException e)
		{
			System.out.println("换人");
		}
	}
}

继承中异常的 注意事项

子类覆盖父类只能throws抛出父类的异常或者该异常的子类、子集，不能抛出父类异常以外的异常

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

interface  Inter
{
	void function();
}

class D implements Inter
{
	public void function()//throws Exception
	{}
}

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 A,B//可以抛AB不能抛C，可以不抛 
	{
	
	}
}

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

【个人小结】：

[1]可以直接手动throw系统(Exception体系)的异常对象，自定义输出的内容以提高阅读性

要注意是new一个异常对象！如果抛出已经存在的异常对象时可以不用new新对象

[2]如果自定义异常时必须定义异常类继承Exception或者RuntimeException

Exception需要在出现异常的函数上throws声明或者catch，如果继承了RuntimeException则不需要在函数上声明或者catch

[3]throws意味着问题的隐藏，throw的执行是把异常交给调用者或着系统来处理，抛出异常后同一区域后面的语句就执行不到了；catch就是在处理异常，所以catch后不需要在该函上声明throws该异常类了

[4]自定义异常类时需要用super（）来明确调用父类Exception 中哪一个构造函数，一般是String类的构造函数

异常体系要做重点掌握,开发中会经常遇到