7.20_java学习_异常

一：异常

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

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

2，异常的处理：try/catch/finally

3，对捕捉到的异常对象进行常见方法操作
哎函数上声明异常
便于提高安全性，让调用出进行处理，不处理编译失败！

4，对多异常的处理
（1）声明异常时，建议声明更为具体的异常，这样处理的可以更具体
 (2) 声明几个异常，就对应有几个catch块
     如果多个catch块中的异常出现继承guanx，父类异常catch块放在最下面
建议：在进行catch处理时，catch中一定要定义具体处理方式
不要简单的输出一条println语句！
*/
class ExcptionDiv
{
	int Div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
		//在功能上通过throws的关键字声明了该功能有可能会出现问题！
	{
		int arr = new int[a];

		System.out.println(arr[4]);
		return a/b;
	}
}
class Excption1
{
	public static void main(String[] args)throws Exception//抛给java虚拟机
	{
		ExcptionDiv a = new ExcptionDiv();
		try{
		a.Div(4,0);//new AritchmeticExcption()跳转到catch
		System.out.println("Hello World!");
		}catch(Exception e)//Exception e = ArithmeticException
		{
			System.out.println("over");
			System.out.println(e.toString());//异常名称，信息
			e.printStackTrace//异常名称，异常信息。异常出现位置
			//其实jvm默认的异常处理机制，就是在调用printStackTrace
			//方法打印异常的堆栈信息。
		}
	}
}

 

二：自定义异常

/*
自定义异常

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

需求：在本程序中，对于除数是负数。
那么就需要对这个问题进行自定义的描述

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

3，一般情况在，函数内出现异常，函数上需要声明

4，发现打印的异常结果中只有异常的名称，却没有异常的信息
如何定义异常信息呢？
	因为父类中已经把异常信息的操作都完成了。
	所以子类只要在构造是，将异常信息传递给父类通过super
	就直接可以通过getMessage方法获取自定义的异常信息

5,自定义异常：必须是自定义类继承Exception、
注意：继承Exception原因：
异常体现有一个特点，因为异常类和异常对象都被抛出
他们都具备可抛性。这个可抛性是throwable这个体现中的独有特点
只有这个体现中的类和对象才可以被throw和throws所操纵

6，hrows和throw的区别

1），throws使用在函数上
   throw使用在函数内

2），throws后面跟的异常类，可以跟多个，用逗号隔开。
   throw后面的是异常对象
*/
class FuShuException extends Exception
{
	String mess;
	FuShuException(String mess)
	{
		this.mess = mess;
	}
	public String getMessage()
	{
		return mess;
	}
	//定义异常信息.  最好是下边这种形式比较简单！
	/*
	FuShuException(String mess)
	{
		super(mess);
	}
	*/
}
class Demo
{
	int div(int a,int b)throws FuShuException
	{
		if(b<0)
			throw new FuShuException("出数异常");//手动通过throw关键字抛出一个自定义异常
		return a/b;
	}
}
class Exception2
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,-1);
			System.out.println(x);
		}
		catch (Exception e)
		{
			System.out.println(e.toString());
			System.out.println("除数出现负数了");
		}
	}
}

三:特殊异常RuntimeException

/*
Exception中有一个特殊的子类异常RuntimeException 运行时异常

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

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

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

4，对于异常分两种
（1）编译时异常
（2）编译时不被检测的异常（运行时异常）

*/
class Demo
{
	int div(int a,int b)
	{
		if(b == 0)
			throw new ArithmeticException("除数异常");//是特殊异常的子类
	return a/b;
	}
}
class  Exception3
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		int x = d.div(3,0);
		System.out.println(x);
	}
}

四：练习

/*
练习：

毕老师用电脑上课
名词提炼法

开始思考上课中出现的问题。
比如：电脑蓝屏了
	   电脑冒烟
对问题进行描述。封装成对象。

可是当冒烟发生后，会出现讲课进度无法继续
出现了讲师的问题：课时计划无法完成，
throw函数结束标志
*/
class LanPingException extends Exception
{
	 LanPingException(String message)
	{
		super("message");
	}
}
class MaoYanException extends Exception
{
	 MaoYanException(String message)
	{
		super("message");
	}
}
class NoPlanException extends Exception
{
	
	NoPlanException(String message)
	{
		super("message");
	}
}
class Computer
{
	private int state = 3;
	public void run()throws LanPingException,MaoYanException
	{
		if (state == 2)
		{
			throw new LanPingException("蓝屏了");
		}
		if (state == 3)
		{
			throw new MaoYanException("冒烟了");
		}
		System.out.println("电脑运行");
	}
	public void reset()
	{
		System.out.println("重新启动");
	}
}
class Teacher
{
	private String name;
	private Computer com;

	Teacher(String name)
	{
		this.name = name;
		com = new Computer();
	}
	public void prelect()throws NoPlanException
	{
		try
		{
			com.run();
		}
		catch (LanPingException e)
		{
			com.reset();
		}
		catch(MaoYanException e)
		{
			test();
			throw new NoPlanException("课时无法继续");
		}
		
		System.out.println("上课");

	}
	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("放假或者换老师");
		}
	}
}