黑马程序员_JAVA异常类的笔记

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


异常类


一,异常概述: 
异常：程序运行过程中的不正常情况.
异常的由来: 问题也是现实生活中一个具体事务，也可以通过java 的类的形式进行描述，


并封装成对象。其实就是Java对不正常情况进行描述后的对象体现。


二,异常分类:
异常分为两大类:Exception与Error
后者为是严重错误问题,用Error描述的异常,必须对代码进行修改,如果不修改,程序将无法进行.
前者Exception也分为两种情况:
1)一种是编译时被检测的异常------ 只要是Exception和其子类都是，处理特殊子类RuntimeException的体系
这种异常一旦出现，希望在编译时就进行检测，让这种问题有针对的处理方式。(如日期类异常)
2)另一种是运行时出现的异常------ 编译时解决，运行时体现的异常,可以不处理异常，但是可能会直接运行时报错。(如数学异常)


三,常见的几种异常:
NullPointerException---------空指针异常    
 IndexOutOfBounds ----------集合越界异常
 StringIndexOutOfBounds-字符串越界异常
ArrayIndexOutOfBounds----数组角标越界异常
 ClassCastException----------类型转换异常
 ClassNotFoundException--类找不到异常 
四,异常的处理:
Java默认处理方式：JVM有一个默认的异常处理机制,即将该异常的名称、异常的信息、异常出现的位置打印在了控制台上，同时将程序停止运行。


标准打印流与错误打印流不同步。


异常相关操作：
1)创建异常对象（JDK已定义的异常会自动创建对象，自定义异常需要手动创建）
2)抛出异常（JDK已有定义的异常会自动抛出异常，自定义异常需要手动抛出）
3)处理异常
程序员在有异常抛出时，异常的处理方法有两种：
1)将异常捕获并处理
2)声明抛出异常
五,异常处理的方式(共三种)
第一种:异常处理方式：捕获
 将异常捕获并处理:
 格式一：
try{
需要检测的代码；
}catch(异常类  变量){
异常处理代码；
}


代码实现




[java] view plaincopy
package cn.itcast;  
/* 
 * 如果没有异常产生，就只运行try中的代码，catch中的代码直接跳过 
 * 如果产生了异常，就从产生异常的地方开始跳入catch代码块中运行代码.同时carch代码块捕获了该产生的异常对象. 
 * catch代码块执行完毕后,不会再执行try里边的剩余代码,而是直接执行完毕 
 */  
public class Demo {  
  
    public static void main(String[] args) {  
  
        System.out.println("try外边前边的代码");  
          
        try {  
            System.out.println("try里边异常产生前边的代码");  
            System.out.println(10/0);//产生异常对象，并抛出ArithmeticException异常对象  
            System.out.println("try里边异常产生后边的代码");  
        } catch (ArithmeticException e) {  
            System.out.println("catch里边处理异常的代码");  
            System.out.println("我把异常抓住了，但是我根本不管它");  
            System.out.println("除数不能为0！");  
        }  
          
        System.out.println("try外边后边的代码");  
    }  
  
}  


第二种与第三种:
格式二：try{
需要检测的代码；


}catch(异常类  变量){


异常处理代码；


}finally{


必须被执行代码


}




finally：必须要执行的代码，通常用来关闭资源




格式三：try{
需要检测的代码；


}finally{


必须被执行代码；


}


代码实现




[java] view plaincopy
package cn.itcast;  
  
public class Demo {  
  
    public static void main(String[] args) {  
  
            try{  
                System.out.println(10/10);  
            }catch(ArithmeticException e){  
                System.out.println("除数不能为0");  
            }finally{  
                System.out.println("我是finally当中的代码");  
            }  
              
            System.out.println("我是try后边的代码");  
            System.out.println("=================");  
              
            try{  
                System.out.println(10/0);  
            }finally{  
                System.err.println("我是finally当中的代码");  
            }  
    }  
  
}  


多异常处理:
 
  方式一：
捕获一个，处理一个


 方式二：


捕获多个，分别处理     注意：大异常不能放到前边


 格式三：
 一次捕获共同处理


注意：多个异常之间不能有子父类关系


异常常见方法
  
  toString：异常名称：异常描述
  public String getMessage()：返回此 throwable 的详细消息字符串。
  public void printStackTrace()  将此 throwable 及其追踪输出至标准错误流
  public void printStackTrace(PrintStream s)   将此 throwable 及其追踪输出至指定的位置(可以是log日志，一个文件可以是数据库可以是网页...)


五,throw与throws
throw:在功能方法内部出现某种情况,程序不能继续运行,需要进行跳转时


就用throw把异常对象抛出


throws:定义功能方法时,需要把出现的问题暴露出来让调用者去处理
那么就通过throws在方法上标识.


二者的区别：
throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常
throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常 
六,finally 与return
函数中已经出现返回语句返回值A，再在finally中修改A值，则最终的返回值仍为修改前A的值。但在该方法中A的值已经被修改了。
在return语句调用时，会产生一个返回路径。该路径内保存了要返回的值。
代码实现






[java] view plaincopy
package cn.itcast;  
/* 
 * 函数中已经出现返回语句返回值A，再在finally中修改A值，则最终的返回值仍为修改前A的值。但在该方法中A的值已经被修改了。 
 * 在return语句调用时，会产生一个返回路径。该路径内保存了要返回的值。 
 */  
public class Demo13 {  
  
    public static void main(String[] args) {  
  
        System.out.println(method());  
    }  
      
    public static int method() {  
          
        int i;  
        try {  
            //System.exit(0);  
            i = 100;  
            return i;  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            System.out.println("我是finally中的代码");  
            i = 200;  
//          return i;  
            System.out.println(i);  
        }  
          
        return i;  
          
    }  
  
}  


七,自定义异常
如果涉及其他需求，JDK没有提供相应的异常对象，则可以自己定义异常。
定义格式：继承Exception或者RuntimeException。同时需要带参的构造方法，用于接收异常信息。
class MyException{
public MyException(String message){
super(message);
}
}
现定义一个异常(代码实现)
[java] view plaincopy
<strong>package cn.itcast;  
/* 
 * 定义一个小于18岁的异常 
 */  
public class Under18Exception extends Exception {  
  
    public Under18Exception() {  
        super();  
    }  
  
    public Under18Exception(String message) {  
        super(message);  
    }  
  
      
}</strong>  


具体的代码实现(自定义异常)
[java] view plaincopy
<strong>package cn.itcast;  
/* 
 * 自定义异常： 
 *  如果涉及其他需求，JDK没有提供相应的异常对象，则可以自己定义异常。 
 * 定义方法： 
 *  继承Exception或者RuntimeException 
 *   
 *  throw:用于抛出异常对象。用于函数内容。 
 */  
public class Demo11 {  
      
    public static void main(String[] args) {  
  
        method();  
          
        try {  
            method2();  
        } catch (Under18Exception e) {  
            e.printStackTrace();  
        }  
//      throw new Exception();  异常对象可以使用自定义，也可以使用JDK提供的异常  
    }  
      
    public static void method(){  
        //只要小于18岁，就不让注册，就报异常  
          
        int age = 3;  
          
        if(age<18) {  
            //创建异常对象  
            Under18Exception u18 = new Under18Exception("注册百合网，必须大于等于18周岁！");  
            //抛出异常  
            try {  
                throw u18;  
            } catch (Under18Exception e) {  
//              e.printStackTrace();  
                System.out.println(e.getMessage());  
            }  
        }  
    }  
      
    //多个异常使用,并列抛出,这多个异常可以有子父类关系  
//  public static void method2() throws Under18Exception,ArithmeticException,Exception {  
    public static void method2() throws Under18Exception {  
        //只要小于18岁，就不让注册，就报异常  
          
        int age = 3;  
          
        if(age<18) {  
            //创建异常对象  
            Under18Exception u18 = new Under18Exception("注册婚恋网，必须大于等于18周岁！");  
            //抛出异常  
            throw u18;  
        }  
          
        System.out.println(10/0);  
    }  
  
}</strong>  


八,异常的细节与注意事项
1)如果父类抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集。   父异常大于子异常




2)父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。




3)此时子类产生该异常，只能捕获处理，不能声明抛出。




代码实现
[java] view plaincopy
<span style="font-size:14px;">package cn.itcast;  
  
import java.text.ParseException;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
  
/* 
 * 异常细节： 
 *      如果父类抛出了多个异常,子类覆盖父类方法时,只能抛出相同的异常或者是他的子集。   父异常大于子异常 
 *      父类方法没有抛出异常，子类覆盖父类该方法时也不可抛出异常。 
 *      此时子类产生该异常，只能捕获处理，不能声明抛出。 
 */  
public class Demo {  
  
    public static void main(String[] args) {  
          
    }  
}  
  
class Fu {  
    public void method() throws Exception{  
        System.out.println(10/0);  
    }  
      
    public void method2(){}  
}  
  
class Zi extends Fu{  
    public void method() throws ParseException {  
        String s = "1949-10-1";  
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");  
        Date date = sdf.parse(s);  
    }  
      
    public void method2() {  
        String s = "1949-10-1";  
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");  
        try {  
            Date date = sdf.parse(s);  
        } catch (ParseException e) {  
            e.printStackTrace();  
        }  
    }  
}</span><span style="font-size:18px;">  
</span>  














版权声明：本文为博主原创文章，未经博主允许不得转载。