基础类库学习（下）

转载

mb5fed701509fd9 2021-09-06 17:30:00

文章标签 java 代码块子类父类异常处理 文章分类 代码人生

学习类

此类作用
此类常用的方法
此类的相关面试题和练习

1、异常（异常体系概念）

类定义

用于描述程序运行出现非正常情况的一组类

顶层父类：Throwable

只有继承了Throwable类才能成为异常类是所有异常的父类

Error：错误

Throwable的子类

通过java代码逻辑不能处理的严重错误：error

Exception：异常

Throwable的子类

通过java代码逻辑可以处理的不正常情况：exception

2、异常体系的特点

异常类都必须直接或间接继承Throwable
子类都是以父类名字为后缀
异常类的子类常用方法都继承与Throwable异常之间的区别是类名和异常原

3、Throwable类

Throwable构造方法

Throwable()：无参构造，异常原因是null

Throwable(String mseesage)：有参构造，返回异常信息

Throwable常用方法

throwable.printStatckTrace()；打印异常信息

throwable.getMessage()；获取异常原因

throwable.toString()；获取异常描述

 Throwable  t1=new Throwable();
            //System.out.println(t1);//java.lang.Throwable
            //System.out.println("getMessage="+t1.getMessage());//getMessage=null
            t1.printStackTrace();
            //java.lang.Throwable
            //    at com.zhiyou100.day11.throwable.Demo01.main(Demo01.java:5)
            t1=new Throwable("出差错了");//java.lang.Throwable: 出差错了
            //System.out.println(t1);//java.lang.Throwable
            //System.out.println("getMessage="+t1.getMessage());//getMessage=出差错了
             t1.printStackTrace();
            //java.lang.Throwable：出差错了
            //    at com.zhiyou100.day11.throwable.Demo01.main(Demo01.java:5)

常见异常：

//{  :Error:(18, 2) java: 解析时已到达文件结尾

           //long[][][]  arr=new long[1024][1024][1024];//OutOfMemoryError: Java heap space

           //A a=new A();//Error:(19, 20) java: 找不到符号

           //Excption
           String s="";
           //s=null;
           //ystem.out.println(s.length());//NullPointerException
           s="";
           //System.out.println(s.charAt(0));//StringIndexOutOfBoundsException: String index out of range: 0

           int[] arr=new int[1];
           // System.out.println(arr[2]);//ArrayIndexOutOfBoundsException: 2
            List list=new ArrayList();
           // System.out.println(list.get(1));//IndexOutOfBoundsException: Index: 1, Size: 0

           //System.out.println(1/0);//ArithmeticException: / by zero

          //System.out.println(new SimpleDateFormat("yyyy-MM-dd").parse("1827/11/11"));//ParseException: Unparseable date: "1827/11/11"

          Object obj=new Object();
          //s=(String)obj;//ClassCastException: java.lang.Object cannot be cast to java.lang.String

          s="abc";
         //System.out.println(Integer.parseInt(s));//NumberFormatException: For input string: "abc"

         //s=new String(new byte[]{1,4,5,7,9},"UTy-0");//UnsupportedEncodingException: UTy-0


        List list2=new ArrayList();
        list2.add("acb");
        for(Object o:list2){
            //list2.add(1);//ConcurrentModificationException
        }

4、异常处理

java处理异常的方式：

1.抛出机制：把方法内可能产生的异常抛给方法的调用者
2.捕获机制：把方法中出现的异常通过代码逻辑处理掉，类似于现实中出现问题自己解决

4.1、抛出机制

通过在方法声明上添加throw异常类型把方法可能出现的异常抛给方法的调用者

package com.zhiyou100.day11.throwable;

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;

public class Demo02 {
    //一个类为什么要有main方法：程序的入口
    //jvm自动调用main方法中的代码
    public static void main(String[] args)throws ParseException {
        System.out.println(1);
        test2();
        System.out.println(2);
    }
    public static void test2() throws ParseException {
        test1();
    }
    //抛出机制
    //在方法声明上加throws ParseException 作用
    //1  当前方法可能出现异常：ParseException
    //2  如果当前方法出现异常ParseException 异常对象被抛给方法的调用者 去处理
    public static void test1()throws ParseException {
        System.out.println(11);
        System.out.println(new SimpleDateFormat("yyyy-MM-dd").parse("1827/11/11"));
        System.out.println(22);
    }



    //抛出机制注意事项：
    //1  如果通过抛出机制处理异常  一旦出现此类异常 当前方法结束  其他代码不再执行
    //2  如果一直通过抛出机制处理异常  异常最终被抛给虚拟机jvm
    //         jvm处理异常的方式固定：1 通过系统错误输出流打印异常详细信息  2 关闭虚拟机
    //3 子类重写父类的方法：子类方法不能抛出多个 大的异常

}

class Fu{
    protected void hehe() throws IOException {}
}
class Zi extends  Fu{
    public void hehe()throws FileNotFoundException, EOFException {}
}
//子类重写父类的方法：范围修饰符 范围不能缩小 可以扩大
//子类重写父类的方法：不能比父类抛出多的 大的异常

4.2、捕获机制

通过try-catch代码块，对产生的异常进行处理

package com.zhiyou100.day11.throwable;

import java.io.FileNotFoundException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo03 {
    public static void main(String[] args) {
         //捕获机制
        // 捕获机制注意事项
        //1  如果try代码块出现异常  try中的其他代码不再执行 而是执行对应的catch代码块
        //2  如果使用trycatch对异常进行处理 如果产生异常 当前方法正常执行
        //3  捕获父类异常的catch代码块 必须放在捕获子类异常catch代码块后面
        //4   如果在try或者catch代码块中 停止虚拟机  finally代码块 将不再执行
          test1();
    }
    public static void test1(){
        System.out.println(11);
        Date date;
        try{   //try代码块：可能产生异常的代码
            System.out.println("try---1");
            date=new SimpleDateFormat("yyyy/MM/dd").parse("1827/11/11");
            String s=null;
            //System.out.println(s.length());
            int[] arr=new int[1];
            //System.out.println(arr[1]);
            System.out.println("try---2");
        }catch(ParseException e){//定义引用接受捕获到的异常对象
            System.out.println("出现异常了！ParseException");//处理异常的代码
            date=new Date();
        }catch(NullPointerException e){//定义引用接受捕获到的异常对象
            System.out.println("出现异常了！NullPointerException");//处理异常的代码
        }catch(ArrayIndexOutOfBoundsException e){//定义引用接受捕获到的异常对象
            System.out.println("出现异常了！ArrayIndexOutOfBoundsException");//处理异常的代码
        }catch(IndexOutOfBoundsException e){//定义引用接受捕获到的异常对象
            System.out.println("出现异常了！IndexOutOfBoundsException");//处理异常的代码
        }finally{//无论是否出现异常 无论如何处理异常 都要执行的代码
            //一般是：关闭流 释放资源的代码
            System.out.println("finally代码块");
        }
        System.out.println(22);

       //int m=test3();//m=3    //int b=1; int a=b; a++;
        test4();
    }
    //return的作用：1 把方法的返回值返回给调用者  2 结束方法
    public static int test31(){//3
        int n=1;
        try{
            n=2;
            new SimpleDateFormat("yyyy/MM/dd").parse("1827/11/11");
            n=3;
            System.out.println(1111);
            return n;//  3
            //return 3;
        }catch(Exception e){
            n=4;
            return n;
            //return 4;
        }finally{
            n=5;
            System.out.println(1112);
            //return 5;
        }
    }
    public static int test32(){//5
        int n=1;
        try{
            n=2;
            new SimpleDateFormat("yyyy/MM/dd").parse("1827/11/11");
            return 3;
        }catch(Exception e){
            return 4;
        }finally{
            return 5;
        }
    }

    public static int test2(){
           int n=1;
           try{
               n=2;
               new SimpleDateFormat("yyyy/MM/dd").parse("1827/11/11");
               n=3;
           }catch(Exception e){
               n=4;
           }finally{
               n=5;
           }
           n=6;
           return n;//6
    }

    public static void test4(){
        try{
            System.out.println(11110);
            System.exit(0);// 如果在try或者catch代码块中 停止虚拟机  finally代码块 将不再执行
        }catch(Exception e){

            System.out.println(11111);
        }finally{
            System.out.println(1112);
        }
    }
}

5、异常分类

按照异常的严重情况（是否可以通过代码逻辑进行捕获）

Error:程序出现的非常严重的异常 不能通过代码逻辑进行处理只能停止程序修改代码

Exception:可以通过代码逻辑进行处理的异常情况

把Exception按是否继承RuntimeException分类

运行时异常（未检查异常）：直接或者间接继承RuntimeException

编译时异常（已检查异常）：没有继承RuntimeException

运行时异常和编译时异常的区别

6、自定义异常

根据项目需求定义jre中没有的异常a

注意事项：1 异常类必须直接或者间接继承Throwable

2 异常类之间的区别：异常类名+异常原因(通过构造方法的参数列表)

package com.zhiyou100.day11.throwable;

import java.util.Scanner;

public class Demo05 {
    //4 选择处理方式
    public static void main(String[] args)throws AgeTooBigException {
            //3 设置产生异常的条件
            int age=new Scanner(System.in).nextInt();
            if(age>150){
                   //产生一个异常情况
                   //new AgeTooBigException("年龄不能小于150！");//创建一个异常对象 不是程序出现异常情况
                  throw new AgeTooBigException("年龄不能小于150！");
            }
    }
    // 面试题：throws和throw的区别
    //相同之处：都是异常处理的关键字
    // 不同之处
    //1 位置不同：throws用在方法声明上 throw用在方法体中
    //2 后面跟的内容不同：throws后面跟多个异常类型 throw后面跟一个异常对象
    //3 作用不同：throws用在方法声明上 来表示当前方法可能产生哪些异常 一旦产生这些异常 异常会被封装为对象 抛给调用者
    //            throw用在方法体中 表示程序出现指定的异常情况
    


    // 面试题：final finally finalize的区别
	//final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
	//finally 是异常处理语句结构的一部分，表示总是执行。
	//finalize 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方提供垃圾收集时的其他资源回收，例如关闭文件等。
}
//1 创建一个Throwable的子类
class  AgeTooBigException extends Exception{
     //2 通过构造方法参数列表传递异常原因
      public AgeTooBigException(String message){
          super(message);
      }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。