java基础<异常>

异常概述

一、概述

异常：就是程序在运行时出现不正常情况

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

对于问题的划分：
  一、严重的问题
  对于严重的问题，java通过Error类进行描述。
  对于Error，一般不编写针对性的代码对其进行处理。
  二、非严重的问题
  对于非严重的问题，java通过Exception类进行描述。
  对于Exception，可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等，所以讲这些共性进行抽取，抽取出一个二者的父类————Throwalbe。

Throwable
 |--Error
 |--Exception

异常try-catch

一、概述

java 提供了特有的语句进行处理

try
{
 需要被检测的代码
}
cathc(异常类 变量)
{
 处理异常的代码：(处理方式)
}
finally
{
 一定会执行的语句；
}

3.对捕获到的异常对象进行常见方法操作
 String getMessage();
 String toString();
 void printStackTrace();

二、代码

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


class ExceptionDemo
{
	public static void main(String[] args)
	{
		Demo d=new Demo();
		int x;
		try
		{
			x=d.div(4,0);
			System.out.println("x="+x);
		}
		catch (Exception e)
		{
			System.out.println("除零啦");
			System.out.println(e.getMessage());// /by zero;
			System.out.println(e);//java.lang.ArithmeticException: / by zero
			e.printStackTrace();//异常名称，异常信息，异常出现的位置。
			//其实jvm默认的异常处理方式，就是调用printStackTrace()方法
		}

		System.out.println("over");

	}
}

异常声明throws

一、概述

在函数上声明异常。

便于提高安全性，让调用者进行处理，不处理编译失败

二、代码

class Demo
{
	int div(int a,int b)throws Exception//在功能上，通过throws的关键字，声明了该功能有可能会出现问题。所以在调用该方法的时候，必须要进行处理(要么try,要么throws)，否则会报异常。
	{
		return a/b;
	}
}


class ExceptionDemo1
{
	public static void main(String[] args) //throws Exception //交给虚拟机来进行处理
	{
		Demo d=new Demo();
		int x;
		try
		{
			x=d.div(4,1);
			System.out.println("x="+x);
		}
		catch (Exception e)
		{
			System.out.println(e.toString());
		}
	

		System.out.println("over");

	}
}

多异常的处理

一、概述

多异常的处理


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


2.对方声明有几个异常，就对应有几个catch块，不要定义多余的catch块。
如果多个catch块中的异常出现继承关系，父类异常catch块要放在最下面，否则子类的异常将无法执行。


建议，在进行catch处理时，catch中一定要定义具体处理方式

二、代码

class Demo
{
	int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上，通过throws的关键字，声明了该功能有可能会出现问题。所以在调用该方法的时候，必须要进行处理(要么try,要么throws)，否则会报异常。
	{
		int[] arr=new int[b];
		System.out.println(arr[4]);
		return a/b;
	}
}


class ExceptionDemo1
{
	public static void main(String[] args) //throws Exception //交给虚拟机来进行处理
	{
		Demo d=new Demo();
		int x;
		try
		{
			x=d.div(4,1);
			System.out.println("x="+x);
		}
	/*	catch (Exception e)//不可以这样操作，因为有了这个catch，后面的catch将不会再捕获到异常。
		{

			System.out.println(e.toString());// /by zero;

		}
	*/
		catch (ArithmeticException e)
		{
			System.out.println(e.toString());
			System.out.println("被零除了");
		}
		
		catch (ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			System.out.println("角标越界");
		}
	

		System.out.println("over");

	}
}

自定义异常

一、概述

因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。
所以对于这些特有的问题，可以按照java的对问题封装的思想，将特有的问题，进行自定义的异常封装。


1.当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
要么在内部try catch 处理。
要么在函数上声明让调用者处理。


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


3.自定义异常需要继承Exception的原因
异常体系有一个特点：因为异常类和异常对象都可以被抛出。
他们都具备可抛性，这个可抛性是Throwable这个体系中独有的特点。
只有这个体系中的类和对象才可以被throws和throw操作。

二、代码

class FuShuException extends Exception
{
	private int value;
	/*
	private String msg;
	
	FuShuException(String msg)
	{
		this.msg=msg;
	}

	public String getMesage()
	{
		return msg;
	}
	*/
	FuShuException(String msg,int value)
	{
			super(msg);	
			this.value=value;
	}
	public int getValue()
	{
		return value;
	}
	
}

class Demo
{
	int div(int a,int b)throws FuShuException
	{

		if(b<0)
			throw new FuShuException("出现了负数",b);//手动通过throw关键字，抛出自定义异常对象。
		return a/b;
	}
}

class ExceptionDemo2 
{
	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());
			System.out.println("出现的负数是"+e.getValue());
		}
	}
}

RuntimeException

一、概述

Exception中有一个特殊的子类异常RuntimeException(运行时异常).


1.如果在函数内抛出该异常，函数上可以不用声明，编译一样通过。
2.如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。


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


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


对于异常分两种：
1.编译时被检测的异常。
2.编译时不被检测的异常（运行时异常，RuntimeException以及其子类)

二、代码

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


class Demo
{
	int div(int a,int b)//throws ArithmeticException
	{
		if(b<0)
			throw new FuShuException("除数为负数了");
		if(b==0)
			throw new ArithmeticException("被0除了");//手动通过throw关键字，抛出自定义异常对象。
		return a/b;
	}
}

class ExceptionDemo3 
{
	public static void main(String[] args) 
	{
		Demo d=new Demo();

		int x=d.div(4,0);
		System.out.println("x="+x);

	}
}

异常练习

一、概述

毕老师用电脑上课。

毕老师上课会出现的问题：
电脑蓝屏
电脑冒烟

二、代码

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


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


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


class Computer
{
	private int state=1;
	public void run() throws LanPingException,MaoYanException
	{
		if(state==2)
			throw new LanPingException("蓝屏了");
		if(state==3)
			throw new MaoYanException("冒烟了");
		System.out.println("电脑运行");
	}

	public void reset()
	{
		state=1;
		System.out.println("电脑重启");
		run();
	}
}



class Teacher
{
	private String name;
	private Computer comp;
	Teacher(String name)
	{
		this.name=name;
		comp=new Computer();
	}
	public void prelect() throws NoPlanException
	{
		try
		{
			com.run();

		}
		catch (LanPingException e)
		{
			com.reset();
		}
		catch (MaoYanException e)
		{
			test();//要放在throw上面，否则无法执行，throw同return一样，函数直接停止。
			throw new NoPlanException("课时无法继续"+e.getMessage());
			
		}
		
		System.out.println("讲课");	
	}

	public void test()
	{
		System.out.println("做练习");
	}
}



class ExceptionPractice 
{
	public static void main(String[] args) 
	{
		Teacher t=new Teacher("毕老师");
		try
		{
			t.prelect();
		}
		catch (NoPlanException e)
		{
			System.out.println(e.toString());
			System.out.println("换老师或者放假");
		}
		
	}
}

异常——finally

一、概述

finally代码块：定义一定执行的代码。

通常用于关闭资源。

二、代码

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


class Demo
{
	public static int div(int x,int y) throws FuShuException
	{
			if(y<0)
				throw new FuShuException("除数出现负数");
			return x/y;
	}
}

class ExceptionDemo4 
{
	public static void main(String[] args) 
	{
		int x;
		
		try
		{
			x=Demo.div(4,-1);
			System.out.println("x="+x);
		}
		catch (FuShuException e)
		{
			System.out.println(e.toString());
			return;
		}
		finally//一定会被执行的代码放在finally中
		{
			System.out.println("finally");
		}

		System.out.println("over");


	}
}

异常——处理语句其他格式

一、概述

异常处理语句的三种格式

①try
{
}
catch ()
{
}
或多个catch()
②
try
{

}
catch ()
{
}
finally
{
}
③
try
{
}
finally
{
}
注意：catch是用于处理异常。如果没有catch，就代表异常没有被处理过。

二、代码

class Demo
{
	public void method() throws Exception
	{
		try
		{
			throw new Exception();
		}
		finally
		{
			//关资源
		}
		//此种格式没有处理异常，所以需要在方法上声明。
		//此格式的目的是将异常的处理交给其他方法，但是有可能需要关闭资源，所以需要使用try——finally格式。
	}
}

异常——覆盖时的异常特点

一、概述

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

二、代码

class AException extends Exception
{}
class BException extends AException
{}
class CException extends Exception
{}

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

class Zi extends Fu
{
	void show() throws AExcetpion//或BException,如果一定要发生CException，那么只能try，不能抛
	{}
}
class Test
{
	void function(Fu f)
	{
		try
		{
			f.show()
		}
		catch (AException e)
		{

		}
	}
}

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

异常总结

1.异常：
异常时什么？是对问题的描述。将问题进行对象的封装。
——————————————————————————————————————————————————————————————————
2.异常体系：
	Throwable
		|--Error
		|--Exception
			|--RuntimeException
—————————————————————————————————————————————————————————————————
3.异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。
				也就是说，可以被throw和throws关键字所操作。
				只有异常体系具备这个特点。
————————————————————————————————————————————————————————————————————————————————————————————
4.throw 和 throws 的用法：

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

当函数内有throw抛出异常对象，并未进行try处理，必须要要在函数上声明，否则会编译失败。
注意，RuntimeException除外，也就是说，函数内抛出的是RuntimeException异常，函数上可以不用声明。

如果函数声明了异常，调用者需要进行处理，处理方法可以throws可以try.
—————————————————————————————————————————————————————————————————————————————————————————————
5.异常有两种：
		编译时被检测异常
			该异常在编译时，如果没有处理，编译会失败。
			该异常被表示，代表可以被处理。
		运行时异常(编译时不检测)
			在编译时不要处理，编译器不检查。
			该异常的发生，建议不处理，让程序停止，需要对代码进行修正。
————————————————————————————————————————————————————————————————————————————————————————————
6.异常处理的语句：
①try{}catch{}finally
②try{}catch{}
③try{}finally{}
注意：
1.finally中定义的通常是 关闭资源代码，因为资源必须要释放。
2.finally只有一种情况不会执行————System.exit(0);

class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}
——————————————————————————————————————————————————————————————————————————————————————————
7.自定义异常：
	定义类继承Exception或者RuntimeException
	1.为了让该自定义类具备可抛性。
	2.让该类具备操作异常的共性方法。

	当要定义自定义异常的信息时，可以使用父类已经定义好的功能。
	异常信息传递给父类的构造函数。
	class MyException extends Exception
	{
		MyException(String message)
		{
		super(message);
		}	
	}

自定义异常：是按照java的面向对象思想，将程序中出现的特有问题进行封装。
——————————————————————————————————————————————————————————————————————————————————————————
8.异常的好处：
	①将问题进行封装。
	②将正常流程代码和问题处理代码相分离，便于阅读
——————————————————————————————————————————————————————————————————————————————————————————
9.异常的处理原则：
	①处理方式有两种：try或者throws。
	②调用到抛出异常的功能时，抛出几个，就处理几个。
		一个try对应多个catch.
	③多个catch,父类的catch放到最下面。
	④catch内，需要定义针对性的处理方式，也不要不写。

	当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
	try
	{
		throw new MyException();
	}
	catch (MyException e)
	{
		throw e;
	}
	如果该异常处理不了，但不属于该功能出现的异常，
	可以将异常转换后，再抛出和该功能相关的异常。
	或者，异常可以处理，当需要将异常产生的合本功能相关的问题提供出去，
	当调用者知道，并处理。也可以将捕获异常处理后，转换新的异常。
	try
	{
		throw new MyException();
	}
	catch (MyException e)
	{
		//对MyException处理。
		throw new AException();
	}
	比如，汇款的例子。
———————————————————————————————————————————————————————————————————————————————————————————
异常的注意事项：
	在子父类覆盖时
	1.子类抛出的异常必须是父类异常的子类，或者子集
	2.如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try，不能抛。