黑马程序员_异常、包

吾凡庸

于 2014-05-16 18:53:22 发布

阅读量310

点赞数

本文链接：https://blog.csdn.net/wuguyu/article/details/26003591

版权

----------------------android培训、java培训、期待与您交流！ ----------------------

1.异常概述
异常：就是程序在运行时出现的不正常情况
异常也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象
其实就是java对不正常情况进行描述后的对象体现
对于严重的，java通过error类进行描述
对于error一般不编写针对性的代码对其进行处理
对于非严重的，java语言通过exception类进行描述
对于exception可以使用针对性的处理方式进行处理

2.异常体系

3.异常的处理

在方法上声明异常
便于提高安全性，让调用处进行处理，不处理编译失败
用try catch语句对异常进行处理

[java]view plaincopy 
   
 try  
    {  
     需要被检测的代码;  
    }  
    catch(异常类 变量)  
    {  
     处理异常的代码;（处理方式）  
    }  
    finally  
    {  
     一定会执行的语句;  
    }  

例:

[java]view plaincopy 
   
 class Test {  
     public static void main(String[] args) {  
         try {  
             int a = divid(4,0);     //检测代码  
         } catch (Exception e) {  
             System.out.println("被除数为0");    //处理  
         }  
           
     }  
     public static int divid(int a, int b) throws Exception{//声明异常  
         return a/b;  
     }  
 }     

对多异常的处理
a.声明异常时，建议声明更为具体的异常，这样处理的可以更具体
b.对方声明几个异常，就对应有几个catch块，不要定义多余的catch块
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面
建议在进行catch处理时，catch中一定要定义具体处理方式，不要简单的定义一句e.printStackTrace()或输出语句

4.自定义异常
因为项目中会出现特有的问题
而这些问题并未被java所描述并封装对象
所以对于这些特有的问题可以按照java的对问题封装的思想
将特有的问题，进行自定义的异常封装
当在方法内部出现了throw抛出异常对象，那么就必须要给对应的处理动作
要么在内部try catch处理
要么在函数上声明让调用者处理

一般情况在，函数内出现异常，函数上需要声明
发现打印的结果中只有异常的名称，却没有异常的信息
因为自定义的异常并未定义信息

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

自定义异常：
必须是自定义类继承Exception。

[java]view plaincopy 
   
 class Test {  
     public static void main(String[] args) {  
         int a = 0;  
         try {  
             a = add(4,-1);  
         } catch (FuShuException e) {  
             System.out.println(e.toString());  
             a = -1;  
         }  
         System.out.println(a);  
     }  
     public static int add(int a, int b) throws FuShuException{  
         if (a < 0 || b < 0) {  
             throw new FuShuException("有负数");  
         }  
         return a+b;  
     }  
 }  
 class FuShuException extends Exception {  
     private String msg;  
     FuShuException(String msg) {  
         super(msg);  
     }  
     public String getMessage() {  
         return msg;  
     }  
 }  

为什么继承Exception:
异常体系有一个特点：因为异常类和异常对象需要被抛出
它们都具备可抛性这个可抛性是Throwable这个体系中独有特点
只有这个体系中的类和对象才可以被throws和throw操作

毕老师讲课例:

[java]view plaincopy 
   
 class  ExceptionTest  
 {  
     public static void main(String[] args)   
     {  
         Teacher t = new Teacher("teacher Bi"); //创建对象毕老师  
         try  
         {  
             t.prelect();  
         }  
         catch (NoPlanException e)  
         {  
             System.out.println(e.toString());  
             System.out.println("change the teacher");  
         }  
     }  
 }  
 class Computer  
 {  
     private int state = 3;  
     public void run() throws LanPingException,MaoYanException  
     {  
         if (state == 2)//此时状况抛出蓝屏异常  
         {  
             throw new LanPingException("blue screen");  
         }  
         if (state ==3)//此时状况抛出冒烟异常  
         {  
             throw new MaoYanException("maoyan l ");  
         }  
         System.out.println("computer run");//非特殊状况时正常运行  
     }  
     public void reset()  
     {  
         state = 1;  
         System.out.println("computer reset");     
     }  
   
 }  
 class LanPingException extends Exception //封装蓝屏异常  
 {  
     LanPingException(String message)  
     {  
         super(message);  
     }  
 }  
 class MaoYanException extends Exception//封装冒烟异常  
 {  
     MaoYanException(String message)  
     {  
         super(message);  
     }  
 }  
 class Teacher //定义教师类  
 {  

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

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

6.RuntimeExcepiton

a.如果在函数中抛出RuntimeException异常，函数上可以不用声明，编译也会通过

b.如果在函数上声明了RuntimeException异常，调用者可以不同进行处理，编译通过

之所以不用在方法上声明，是因为不需要让调用者处理

当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况希望停止程序后对代码进行修改

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

[java]view plaincopy 
   
 class Test {  
     public static void main(String[] args) {  
         int c = add(1,2);  
         System.out.println(c);  
     }  
     public static int add(int x, int y) {  
         if (x + y < 5) {  
             throw new AException("不符合条件");  
         }  
         return x + y;  
     }  
 }  
 class AException extends RuntimeException {  
     private String msg;  
     AException(String msg) {  
         this.msg = msg;  
     }  
     public String toString() {  
         return msg;  
     }  
 }  

小结:普通异常在编译时就会出现，而Runtime异常编译时没有问题，运行时出现

7.finally

finally中存放的是一定会被执行的代码
finally代码块:通常用于关闭资源

[java]view plaincopy 
   
 //第一种格式  
 try  
 {  
       
 }  
 catch ()//可多个catch  
 {  
 }  
 //第二种格式  
 try  
 {  
       
 }  
 catch ()  
 {  
 }  
 finally  
 {  
 }  
 //第三种格式  
 try  
 {  
 }  
 finally  
 {  
 }  

a.finally中定义的通常是关闭资源的代码，因为资源必须释放
*System.exit(0);jvm结束
b.finally只有一种情况不会执行，当执行到System.exit(0);

8.异常在子父类覆盖中的体现

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

小结:由于多态的缘故，当方法中的参数是父类类型，结果传入的时子类的对象，那么如果子类抛出的不是父类的异常的本身或其子类，那么无法处理

9.包

定义包:package 包名; eg. package pack; package cn.itcast.day01;
包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰
不同包中的子类还可以访问父类中被protected权限修饰的成员
包与包之间可以使用的权限只有两种，public protected
public protected default private
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类(不同包) ok ok
不同包中 ok

[java]view plaincopy 
   
 package packb;  
 public class DemoB  
 {  
     protected void method()  
     {  
         System.out.println("DemoB run");  
     }  
 }  
 class C extends DemoB  
 {  
     /* 
     void method() //无法覆盖父类中的method 
     { 
         System.out.println("C run"); 
     } 
     */  
     protected void method()//能覆盖，因为protected权限大于default  
     {}  
 }  