java第十三次作业

package java第十次作业;

认识异常：异常是导致程序中断运行的一种指令流。如果不对异常进行正常处理，则可能导致程序的中断执行，造成不必要的损失。

package java第十三次作业;
class Exc{//创建一个类
	int i=10;//定义一个整型变量并初始化
}
public class ExceptionDemo01 {//创建一个类
 
	public static void main(String[] args) {//主方法
		int a=10;//定义一个整型变量并初始化
		int b=0;//定义一个整型变量并初始化
		int temp=a/b;//计算两个变量的商
		System.out.println(temp);//输出结果
 
	}
 
}

1、定义 ： 一个方法不处理这个异常，而是调用层次向上传递，谁调用这个方法，这个异常就由谁来处理。

2、throw : 将产生的异常抛出(强调的是动作)，抛出的既可以是异常的引用，也可以是异常对象。（位置: 方法体内） 调用可能会抛出异常的方法，必须添加try-catch代码块尝试去捕获异常 或者 添加throws 声明 来将异常 抛出给更上一层的调用者进行处理,这里需要注意一个细节:新的异常包含原始异常的所有信息，根据这个我们可以去追溯最初异常发生的位置。

3、throws : 如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异常（可以是一种类型，也可以是多种类型，用逗号隔开）（位置: 写在方法名 或方法名列表之后 ，在方法体之前。）
 

捕捉异常

1. try{//捕捉异常

2. 异常语句

3. }catch(Exception e){//处理异常

5. }

6. finally{//会执行的语句

7. 一定会执行的代码

   class Exc{//创建一个类
       int i=10;//定义一个整型变量并初始化
   }
   public class ExceptionDemo01 {//创建一个类
    
       public static void main(String[] args) {//主方法
           int a=10;//定义一个整型变量并初始化
           int b=0;//定义一个整型变量并初始化
           int temp=0;//定义一个整型变量并初始化
           try{ temp=a/b;//计算两个变量的商
           }catch(ArithmeticException e){//处理异常
               System.out.println(e);//输出异常信息
           }
           
           System.out.println(temp);//输出结果
    
       }
   

   

   class Exc{//创建一个类
   	int a=10;//定义一个整型变量并初始化
   	int b=10;//定义一个整型变量并初始化
   }
   public class ExceptionDemo01 {//创建一个类
    
   	public static void main(String[] args) {//主方法
   		
   		int temp=0;//定义一个整型变量并初始化
   		Exc e=null;//创建对象
   		//e=new Exc();//实例化对象
   		try{//捕捉异常
   			temp=e.a/e.b;//计算商
   			System.out.println(temp);//输出结果
   		}catch(NullPointerException e2){//处理异常
   			System.out.println("空指针异常："+e2);//输出异常信息
   		}catch(ArithmeticException e2){//处理异常
   			System.out.println("算数异常："+e2);//输出异常信息
   		}
   		finally{//最后一定会执行的代码
   			System.out.println("程序推出");//输出信息
   		}
    
   		
    
   	}
    
   
   

    

    

   try、catch和finally
   异常的捕获和处理需要采用try和catch来处理，
   try中包含了可能产生异常的代码
   try后面是catch，catch可以有一个或多个，catch中是需要捕获的异常
   当try中的代码出现异常时，出现异常下面的代码不会执行，马上会跳转到相应的catch语句块中，如果没有异常不会跳转到catch中
   finally表示，不管是出现异常，还是没有出现异常，finally里的代码都执行，finally和catch可以分开使用，但finally必须和try一块使用，如下格式使用finally也是正确的

   异常的捕获顺序
   异常的捕获：一般按照由小到大的顺序，也就是先截获子异常，再截获父异常,将IOException放到前面，会出现编译问题，因为IOException是FileNotFoundException的父类，所以截获了IOException异常后，IOException的子异常都不会执行到，所以再次截获FileNotFoundException没有任何意义,异常的截获一般按照由小到大的顺序，也就是先截获子异常，再截获父异常。这里只是为了说明捕获顺序，实际中，关闭流资源fis.close()是在finally语句块中处理的。
    

   常见异常：

8. 方法覆盖中的异常处理 
   方法覆盖(重写)规则：

   方法签名必须相同，方法名与参数列表就是方法签名

   方法的返回值类型可以相同 ，子类方法的返回值类型也可以是父类方法返回值类型的子类型

   子类方法的访问权限可以更宽泛(更大)
   a、如果父类方法使用public修饰，子类方法只能是public修饰
   b、如果父类方法使用protected修饰，子类方法可以是protected或者public修饰

   子类方法的异常要比父类方法的异常更小
   a、如果父类方法没有抛出异常，子类重写后也不能抛出异常
   b、如果父类方法抛出了异常，子类方法可以抛出相同的异常，也可以抛出父类异常的子异常，也可以不抛出异常 
    

   1.数组越界异常：ArrayIndexOutOfBoundsException

   2.数字格式化异常：NumberFormatException

   3.算数异常：ArithmeticException

   4.空指针异常：NullPointerException

   throws关键字

   1.在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，抛给方法的调用者处理

   2.格式：

   public void tell() throws Exception{} 
    

   
   public class ExceptionDemo02 {//创建类
    
   	public static void main(String[] args) {//主方法
   		tell(10,0);//调用方法并传入值
   	}
   	public static void tell(int i,int j)throws ArithmeticException{//创建类并抛出算数异常
   		int temp=0;//定义一个整型变量并初始化
   		temp=i/j;//计算商
   		System.out.println(temp);//输出信息
   	}
    
   
   

   

    

    

   1.throw关键字抛出一个异常，抛出的时候直接抛出异常类的实例化对象即可。

   public class ExceptionDemo02 {//创建类
    
   	public static void main(String[] args) {//主方法
   		try{//捕捉异常
   			tell(10,0);//调用方法并传入值
   		}catch(Exception e){//处理异常
   			System.out.println(e);//输出异常信息
   		}
   	}
   	public static void tell(int i,int j)throws ArithmeticException{//创建类并抛出算数异常
   		int temp=0;//定义一个整型变量并初始化
   		temp=i/j;//计算商
   		System.out.println(temp);//输出信息
   	}
    
   

   

    throw 和throws 关键字的区别

   1、写法上 : throw 在方法体内使用，throws 函数名后或者参数列表后方法体前
   2、意义 ： throw 强调动作，而throws 表示一种倾向、可能但不一定实际发生
   3、throws 后面跟的是异常类，可以一个，可以多个，多个用逗号隔开。throw 后跟的是异常对象，或者异常对象的引用。
   4、throw 用户抛出异常，当在当前方法中抛出异常后，当前方法执行结束（throw 后，如果有finally语句的话，会执行到finally语句后再结束。）。可以理解成return一样。
    

9.  1.自定义异常直接继承Exception就可以完成自定义异常类。

   class MyException extends Exception{//创建自定义异常类并继承父类
   	public MyException(String msg){//定义方法并传入一个字符串参数
   		super(msg);//调用父类构造方法
   	}
   }
   public class ExceptionDemo04 {//创建类
    
   	public static void main(String[] args) {//主方法
   		try{//捕捉异常
   			throw new MyException("自定义异常");//直接抛出自定义异常实例化对象
   		}catch(MyException e){//处理异常
   			System.out.println(e);//输出异常信息
   		}
    
   	}