Java基础--异常及其简单处理

异常:
异常就是程序在运行的时候出现不正常的情况.
异常的由来:问题也是现实生活中的一个具体的事物,也可以通过java的类的形式进行描述.并封装成对象.其实异常就是java对不正常情况进行描述后的对象体现.把问题封装为对象.
异常就是对问题的描述,将问题进行对象的封装
异常体系:
Throwable
Error
Exception
RuntimeException
异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛
性.也就是说可以被throw和throws关键字操作
只有异常体系具备这个特点

throw throws 用法
前者定义在函数内,用于抛出异常对象
后者定义在函数上,用于抛出异常类,可以抛出多个用,隔开

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

异常有两种:
编译时被检测异常
该异常在编译的时候如果没有处理,编译失败
该异常被标识,代表着可以被处理
运行时异常
在编译的时候不需要处理,编译器不检查.
该异常的发生,建议不处理,让程序停止.需要对代码进行修正.

异常处理的语句:
1.try 2.catch 3.finally
1.需要被检测的代码
2.处理异常的代码
3.一定会执行的代码.通常定义的是关闭资源的代码.
格式:
1_2
1_3
1_2_3

finally 有一种情况是执行不到的,就是System.exit(0);

自定义异常:
定义类继承Exception或者RuntimeException
1.为了让该类具备可抛性
2.让该类具备操作异常的方法
当要定义自定义异常的信息时,可以使用父类已经定义好的功能
异常信息传递给父类的构造函数

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

自定义异常:
按照java的面向对象思想,将程序中出现的特有问题进行封装.

异常的好处:
1.将问题进行封装
2.将正常流程代码和问题处理代码相分离,方便于阅读

异常的处理原则:
1.处理方式有两种,try或者throws
2.调用到抛出异常的功能时,建议抛出几个就要处理几个.
一个try 多个catch
3.多个catch,父类的catch放在最下面
4.catch 内,需要定义针对性的处理方式,不要简单的定义
printStackTrace()输出语句,也不要不写.当捕获到的异常,
本功能处理不了时,可以继续在catch中抛出.
try{ throw new AE()}
catch(AE e){throw e}
如果该功能处理不了,单并不属于该功能出现的异常,那
么可以在异常转换后,再抛出和该功能相关的异常

或者异常可以处理,当需要将异常产生的和本功能相关的问题提供出去
当调用者知道,并处理,也可以捕获后转换新的异常.
try{ throw new AE()}
catch(AE e){ throw new BE()}

异常的注意事项:
在子父类覆盖的时候:
1.子类覆盖父类的方法时,抛出的异常必须是父类异常的子类或者子集
2.如果父类或者接口没有异常抛出时,子类覆盖出现异常只能try不能抛

try里面抛出异常,那么函数上也要声明.

continue break return throw 下面都不能有其他语句.

1>>>代码的问题分类

1. 严重的问题

通过Error类进行描述.对于此类一般不编写针对性的代码处理.

2. 非严重问题

通过exception类进行描述.对于此类则可以使用针对性的处理代码.
重点:exception.
无论error还是exception都具有一些共性内容,比如不正常的信息,引发原因等.

2>>>异常的处理

Java提供了特有的语句尽兴处理.
try{需要检测的代码}
catch(异常类变量)
{处理异常的代码}
finally{一定会执行的语句}

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

String getMessage();
e.getMessge();异常类型.
e.toString();异常类型,异常信息.
e.PrintStackTrace();异常类型,异常信息,异常出现的位置.
其实jvm默认的异常处理机制就是在调用该方法,打印异常的堆栈的跟踪信息.

2. 在功能上通过throws的关键字声明了该功能有可能出现问题.

使用此类方法时,在调用的时候主函数也应该throws Exception.
声明异常时建议声明更具体的异常,这样处理可以更加具体.比如ArithmeticException,或者ArrayindexoutofboundException.就可以针对性的处理异常了.

1. 对方声明几个异常,就应该有几个catch块,也不要定义多余的catch块.如果多个catch块中的异常存在继承关系,父类异常catch块放在最下面.
2. 建立在进行catch处理时,catch中一定要定义具体处理方式,不要简单的定义一句简单的e.toString()什么的,也不要简单的书写一条输出语句.由于项目中会有些特有的问题,这些问题并未全被java所描述并封装对象,所以对于这些特有的问题可以按照java的对问题的封装的思想,将特有的问题,进行自定义的异常封装.当在函数内部出现了throw抛出异常对象,就必须给出对应的处理动作,要么在内部try catch处理.

3>>>自定义异常和简单处理

package test3;

public class ExceptionDiy {

	public static void main(String[] args){
		Demo1  d = new Demo1();
		try {
			d.div(2, -1);
		} catch (FushuException e) {
			System.out.println("nonono minus"+e.getValue());
			System.out.println(e.toString());
		}
	}
}
//throws 跟多个异常,在函数上写,小括号大括号之间
//throw 在函数内写  后面跟的是异常类的对象
class FushuException extends RuntimeException//Exception //Error
{
//异常体系有一个特点:都需要被抛出,因为会导致程序跳转.都具备可抛性
//这个可抛性是throwable独有的特点,可以被throw throws关键字操作
//
//	private String msg;
//	public String getMessage()
//	{
//		return msg;
//	}父类已经把异常信息的操作都完成,所以在构造函数的
//	时候定义一下构造函数就好了.
	private int value;
	FushuException(String msg,int value)
	{
		super(msg);
		this.value = value;
	}
	public int getValue()
	{
		return value;
	}
}
class Demo1
{
	int div(int a , int b) throws FushuException
	{
		if (b<0)
			throw new FushuException("除数为负",b);
		return a/b;
	}
}

自定义异常:
必须是自定义继承Exception.
继承Exception原因:异常体系有一个特点:因为异常类和异常对象都需要被抛出,因为都具备可抛性,这个可抛性是Throwable体系独有的特点,只有这个体系中的类和对象才可以被Throws和Throw操作.
自定义异常:
定义类继承Exception或者RuntimeException

1. 为了让该自定义类具备可抛性
2. 让该类具备操作异常的共性方法

当要定义自定义异常的信息时,可以使用父类已经定义好的功能.
异常信息传递给父类的构造函数
Class MyException extends Exception
{
MyException(String message)
{
Super(message);
}
}
自定义异常:按照java的面向对象思想,将程序中出现的特有问题进行封装.

下面我们详解一下异常中的各种小知识点:

throw和throws有什么区别？ try、catch、finally分别在什么情况下使用？

*throw关键字用于抛出异常对象,后边跟的是异常的对象,用在函数内部
*
*throws关键字用于声明异常可能会发生.用在定义函数的语句上,可以同时声明多个异常.
*
*try在有代码可能发生异常并希望对其处理的时候使用.
*
*catch()与try配套使用,同一个try可以对应多个
*catch().当有多个catch()时,父类异常catch()写在子类异常下面.
*
*finally中放的是一定会执行的语句,除非遇到System.exit().finally内放置的代码一般是
*关闭资源的.可以跟try catch() 一起使用,也可以与try一起使用.与catch()一样,不可以单独出现.

另外,

class Demo(){
	int div(int a,int b){
/*不用throws 语句,因为同样上图也可以通过编译.
原因:
Exception类中有一个特殊的子类:RuntimeException运行时异常.
如果在函数内中抛出异常函数上可以不用声明,编译一样通过.
如果在函数上声明了该异常,调用者可以不用进行处理,编译一样通过.
*/

		if(b==0){
			throw new ArithmeticException("/ by zero");
		return a/b;
		}
	}
}

之所以不用再函数上声明是因为不需要让调用者处理.
当该异常发生希望程序停止,因为在运行时出现了无法继续运算的情况,希望停止程序后对代码进行修正.

异常处理与声明的原则:只要问题在内部解决就可以不用对外界声明.(全部的Exception都被解决的情况).

Try跟finally一起使用的时候,finally一起使用执行一定要执行的代码.如果没catch块就代表没有被处理过,如果该异常是检测时异常那么必须声明.
异常在子父类覆盖中的体现.

1. 子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法只能抛出父类的异常或者该异常的子类.
2. 如果父类方法抛出多个异常,那么子类在覆盖该方法时只能抛出父类异常的子集.(只要父类可以处理的异常就可以).
3. 如果父类或者接口中的方法没有异常抛出,那么子类在覆盖方法时也不可以抛出异常.如果子类方法发生了异常,呢么就必须进行try处理,绝对不可以抛.

下面我们通过一段话来解释一下异常和异常的处理:
有一个圆形和长方形,都可以获取面积,对于面积如果出现非法的数值,视为是获取面积时出现的问题,问题都用异常来表示.
注意:
先要对这个程序进行基本的设计.
把求面积定义为一个扩展功能,自定义个异常,继承Exception,防止参与面积运算的数值是负数.这时用try catch会继续运算程序其他的语句,当继承RuntimeException 的时候就会直接停止.
异常是什么?
是对问题的描述,将问题进行对象的封装.
异常体系:Throwable
|–Error
|–Exception
|–RuntimeException
异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性,也就是说可以被throw和throws关键字操作.只有异常体系具备这个特点.

异常有两种:
1.编译时被检测异常
该异常在编译时如果没有处理(没有抛也没有try),那么编译失败.该异常被标识,代表可以处理

2.运行时异常(编译时未检测)
在编译时不需要处理,编译器不检查,该异常的发生,建议不处理,让程序停止,需要对代码进行修正.

异常的好处:

1. 将问题进行封装
2. 将正常流程代码和问题处理代码相分离,方便于阅读

异常的处理原则:

1. 处理方式有两种:try或者throws
2. 调用到抛出异常的功能时,抛出几个,就要处理几个.

一个try对应多个catch

1. 多个catch,父类的catch往下放.
2. Catch内,需要定义针对性的处理方式.不要简单的定义简单的printStachTrace,输出语句,也不要不写.

当捕获到的异常,本功能处理不了时可以继续在catch中抛出.
try{
throw new Aexception
}
catch (Aexception e){
throw e
}
如果该异常处理不了,但并不属于该功能出现的异常,可以将异常转换后,再抛出和功能相关的异常.
或者异常可以处理,当需要将异常产生的和功能相关的问题提供出去,让调用者知道并处理,也可以将捕获异常处理后,转换成新的异常.
try{throw new Aexception();}
catch(Aexception e)
{
throw new Bexception();
}
比如银行汇款的例子,没有汇款成功,处理一下,然后抛出让用户处理的异常.

异常的注意事项:
在子父类覆盖时

1. 子类抛出的异常必须是子类的异常的子类或者子集
2. 如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能自己解决,try and catch,不能抛出.