黑马程序员_Java_异常

/*
异常：就是程序在运行时出现的不正常情况，其实就是java对不正常情况进行描述后的对象体现，通过java的类的形式进行描述，并封装成对象。


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


无论Error还是Exception都具有一些共性内容。
比如：不正常情况的信息，引发原因等


Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。


如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。


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


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


Throwable
	|--Error
	|--Exception
	|--RuntimeException
	|--自定义异常

*/


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


//二.对捕获的异常对象进行常见方法操作
//String getMessage();获取异常信息类Excetion 是继承于Throwable类的
class Throwable
{
	private String message;
	Throwable(String message)
	{
		this.message=message;
	}
	public String getMessage()
	{
		return message;
	}
}


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


//之前学习过类似的：
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name =name;
		this.age=age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class Student extends Person
{
	Student(String name,int age)
	{
		super(name,age);
	}
}
new Student("jean",18).getName();
new Student("lili",20).getAge();



/*三.对多异常的处理：（函数中只要有异常发生就不会进行了，要退出了）
1.声明异常时，建议声明更为具体的异常，这样处理的更具体ArithmeticException
2.对方声明几个异常，就对应有几个catch块（不要定义多余的catch块）
	如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面


独立在进行catch处理时，catch中一定要定义具体的处理方式。
不要简单定义一句e.printStackTrace();
也不要简单的就书写一条输出语句。


*/
class Demo
{
	//在函数上声明异常，便于提高安全性，让调用者进行处理，不处理编译失败
	int div(int a ,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通过throws的关键字声明了该功能可能会出现问题
	{
		int[] arr =new int[a];
		System.out.println(arr[2]);
		return a/b;
	}
}


class ExceptionDemo 
{
	public static void main(String[] args) 
	{
		Demo d =new Demo();
		
		try
		{
			int x =d.div(2,2);	
			System.out.println(x);
		}
		catch (ArithmeticException e)//Exception e =new ArithmetricException();多态
		{
			System.out.println("div by zero ");
			System.out.println(e.getMessage()); // / by zero;
			System.out.println(e.toString());//异常名称：异常信息


			e.printStackTrace();//异常名称：异常信息，异常出现的位置
				//其实JVM 默认的异常处理机制，就是调用printStackTrace方法
				//打印异常的堆栈的跟踪信息
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			System.out.println("jiaobiao越界");
		}
		
		System.out.println("end");
		//byte[] arr =new byte[1024*1024*341];//在内存分配了341M，
		//Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	}
}



/*
四.异常在子父类覆盖中的体现：
1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或该异常的子类


2.如果父类方法抛出多个异常，那么子类在抛出异常时只能抛出父类异常的子集。


3.如果父类或接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。


4.如果子类方法发生了异常，就必须要进行try..catch处理，绝对不能抛出。
*/


class AException extends Exception
{
}


class BException extends AException
{
}


class CException extends Exception
{
}
/*
Exception
	|--AException
		|--BException
	|--CException
*/
class Fu
{
	void show() throws CException
	{}
}


class Test
{
	void function(Fu f)
	{
		try
		{
			f.show();
		}
		catch (CException e)
		{
		}
	}
}


class Zi extends Fu
{
	void show() throws CException
	{
		try
		{
			
		}
		catch (CException e)
		{
		}
	}
}
class Yichang 
{
	public static void main(String[] args) 
	{
		Test t =new Test();
		t.function(new Zi());
	}
}




/*五.自定义异常：

必须是自定义类继承Exception。

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都可以被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

只有这个体系中的类和对象才可以被throws和throw操作。

throws和throw的区别
throws使用在函数上。
throw使用在函数内。

throws后面跟的是异常类。可以跟多个。用逗号隔开。
throw后面跟的是异常对象。
*/