异常处理

异常的处理方式
        方式一：捕获处理
        捕获处理的格式

try
{
    可能发生异常的代码
}
catch(捕获的异常类型  变量名)
{
    处理异常的代码
}
        

        捕获处理要注意的细节：
            1. 如果一个try块中出现了异常的代码，经过处理之后，那么try-catch块外面的代码可以正常执行。
            2. 如果一个try块中出现了异常的代码，那么在try块中出现异常的代码后面 的语句无法执行。
            3. 一个try块后面可以跟多个catch块，也就是一个try块可以捕获多种异常的类型，但是捕获的
            异常类型必须从小到大进行捕获。


        方式二：抛出处理(throw throws)
        抛出处理要注意的细节：
            1. 如果一个方法内部抛出了一个编译时异常对象，那么该方法必须要声明抛出。
            2. 如果调用了一个声明抛出编译时异常的方法，那么调用者必须要处理。
            3. 如果一个方法抛出了一个异常对象，那么该方法也会马上停止（一个方法遇到了throw关键字，那么该方法就会马上停止）
            4. 在一种情况下只能抛出一种异常对象。  
        throw 关键字是用于方法体之内抛出异常对象 的，throws是用于方法 声明上声明抛出异常类型的。
 


 1.

public class Yichang1 
{
	public static void main(String[] args)
	{
		int[] arr = null;
		div(4,0,arr);
	}
	
	public static void div(int x, int y, int[] arr)
	{
		int a = 0;
		try
		{
			a = x/y;		//try里面第一句异常 ，那么第二句不会执行
			System.out.println("数组的长度： "+ arr.length);
		}
		catch(ArithmeticException e)
		{
			System.out.println("异常处理了.... ");
			System.out.println("toString: "+ e.toString());


		}
		catch(NullPointerException e)
		{
			System.out.println("空指针异常错误");
		}
		catch(Exception e)		//如果把这个放在最前面，Arithmetic和NullPointer都不执行，捕获应该从小到大进行
		{
			System.out.println("这里什么异常都能处理...");
		}
	
		System.out.println("x/y= "+a );
	}
}

运行结果：


异常处理了.... 
toString: java.lang.ArithmeticException: / by zero
x/y= 0


 


2.

public class Yichang2 
{
	public static void main(String[] args)
	{
		try
		{
			div(4,0);	//调用了一个   申明抛出异常类型的方法
		}
		catch(Exception e)
		{
			System.out.println("异常处理了...");
		}


	}
	public static void div(int x, int y) throws Exception
	{
		if(y==0)
		{
			throw new Exception();	//抛出一个异常
		}
		int a = 0;
		a = x/y;
		System.out.println(a);
	}
}

运行结果：


异常处理了...




throw 与throws两个关键字：
   1. throw关键字是用于方法内部抛出一个异常对象的，throws关键字是用于在方法声明上声明抛出异常类型的。
   2. throw关键字后面只能有一个异常对象，throws后面一次可以声明抛出多种类型的 异常。


 


3.自定义异常类

class NoIpException extends Exception
{
	public NoIpException(String message)
	{
		super(message);
	}
}


public class DIYYichang1 
{
	public static void main(String[] args) 
	{
		String ip = "192.168.1.1";
		ip = null;
		try
		{
			qq(ip);			//如果调用了一个声明抛出异常类型的方法，那么调用者必须要处理。
		}
		catch(NoIpException e)
		{
			e.printStackTrace();
			System.out.println("插网线去....");
		}
	}
	public static void qq(String ip) throws NoIpException
	{
		if(ip==null)
		{
			//抛出异常
			throw new NoIpException("没有插网线..");
		}
		System.out.println("正常显示好友列表...");
	}
}
 

运行结果：
NoIpException: 没有插网线..
    at DIYYichang1.qq(DIYYichang1.java:32)
    at DIYYichang1.main(DIYYichang1.java:19)
插网线去....


 


异常体系：
--------| Throwable  所有错误或者异常的父类
--------------| Error（错误）
--------------| Exception(异常) 异常一般都通过代码处理 


------------------| 运行时异常: 如果一个方法内部抛出了一个运行时异常，那么方法上 可以声明也可以不 声明，调用者可以以处理也可以不处理。
------------------| 编译时异常(非运行时异常、受检异常):  如果一个方法内部抛出了一个编译时异常对象，那么方法上就必须要声明，而且调用者也必须要处理。


运行时异常： RuntimeException以及RuntimeException子类 都是属于运行时异常。


编译时异常： 除了运行时异常就是编译异常。


 


 


4.

import java.io.*;




public class FinallyFile 
{
	public static void main(String[] args)
	{
		FileReader filereader = null;
		try
		{
		//找到目标文件
		File file = new File("D:\\1.txt");
		//建立程序与文件的数据通道
		filereader = new FileReader(file);
		char[] arr = new char[1024];
		int length = 0;
		length = filereader.read(arr);
		System.out.println("读取到的内容： "+ new String(arr,0,length));
		}
		catch(IOException e)
		{
			System.out.println("读取失败...");
		}
		finally
		{
			try
			{
				//关闭文件
				filereader.close();
				System.out.println("释放资源成功...");
			}
			catch(IOException e)
			{
				System.out.println("释放资源失败...");
			}
		}
	}
}

运行结果：


读取到的内容： 123555
释放资源成功...