【JAVA】|JAVA语言基础----异常(续1)、集合(List、ArrayList)

本文深入探讨了Java异常处理机制,包括异常捕获的各种方式,如分别捕获、统一捕获和分组捕获,以及异常处理中的重载与重写原则。同时,详细讲解了finally块的作用和执行流程,并介绍了集合框架的基本概念,重点讨论了List接口的特性及其实现类ArrayList的工作原理。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

异常

捕获方式
1、分别捕获–针对方法上抛出的所有异常进行分别处理(提供对应的catch进行分别处理)
2、同意捕获–针对方法上抛出的所有异常进行统一处理(提供一个catch以及抛出异常类的公共父类)
3、分组捕获–提供|来间隔一组之间的异常类进行统一处理(jdk1.7出现)

public class ExceptionDemo1 {
    public static void main(String[] args) {
        
        
       /* //分别捕获
        try {//try快里存放的是可能会出问题的代码
            String s = readFiles(null);
        } catch (FileNotExitsException e) {//catch块会一直检测try块里是否有异常
            //如果出现异常根据对应的异常类类型来捕获对应抛出的异常

            System.out.println("问题及其处理。。。");
        }
        catch (FilesNotFoundException e){
            System.out.println(e.getMessage());
        }//当异常被处理之后后续代码正常执行
        //获取异常描述信息
        //调用父类的方法来间接的获取父类的私有化属性值
        catch (NullPointerException e){
            //打印栈轨迹
            e.printStackTrace();
        }*/


       /* //统一捕获--提供一个catch来捕获方法上抛出的所有异常
        try {//try快里存放的是可能会出问题的代码
            String s = readFiles(null);
        } catch (Exception e) {//catch块会一直检测try块里是否有异常
            //如果出现异常根据对应的异常类类型来捕获对应抛出的异常

            System.out.println("问题及其处理。。。");
        }*/


        //分组捕获----用|来间隔一组的异常类,一组之间进行统一处理
        try {//try快里存放的是可能会出问题的代码
            String s = readFiles(null);
        } catch (FileNotExitsException | NullPointerException | FilesNotFoundException e) {//catch块会一直检测try块里是否有异常
            //如果出现异常根据对应的异常类类型来捕获对应抛出的异常

            System.out.println("问题及其处理。。。");
        }








        /*try {//try快里存放的是可能会出问题的代码
            String s = readFiles(null);
        } catch (FileNotExitsException e) {//catch块会一直检测try块里是否有异常
            //如果出现异常根据对应的异常类类型来捕获对应抛出的异常

            System.out.println("问题及其处理。。。");
        }
        catch (FilesNotFoundException e){
            System.out.println(e.getMessage());
        }//当异常被处理之后后续代码正常执行
        //获取异常描述信息
        //调用父类的方法来间接的获取父类的私有化属性值
        catch (NullPointerException e){
            //打印栈轨迹
            e.printStackTrace();
        }*/
        System.out.println("读取完成");
    }
    //定义读取文件的方法
    //方法上可以抛出多个异常(中间用逗号分隔)
    //如果方法上必须要抛出的异常就是编译时异常
    public static String readFiles(String path) throws FileNotExitsException, FilesNotFoundException {
        //判断路径是否是null
        if (path == null) {
            //进了判断说明path为null
            //发现问题,反馈问题
            throw new NullPointerException();
        }



        //判断是不是txt文件
        if (!path.endsWith("txt") ) {
            //进了判断说明不是txt文件
            //发现问题
            //反馈问题(描述信息),往上传递异常类的对象
            throw new FilesNotFoundException("你文件类型错了!!!!!");

        }
        //判断路径是否是w盘符
        if(path.startsWith("W")){
            //进了判断说明以W开头
            //说明出现问题
            //反馈问题----网上传递异常类对象
            //反馈问题后面代码都不执行
            throw new FileNotExitsException();
        }
        //读取文件内容
        return "文件内容";
    }
}

//自定义异常类
//自定义异常类继承了除了RuntimeException类以及子类以外的其他类,自定义异常默认就是编译时异常
class FileNotExitsException extends Exception{

}
class FilesNotFoundException extends Exception{
    /* //属性私有化
     private String message;
     //提供获取私有化属性的get方法
     @Override
     public String getMessage() {
         return message;
     }*/
    //
    public FilesNotFoundException(String message) {
        super(message);
    }
}



重载与重写
1、重载之和方法名以及参数列表有关系(和其他的都没有关系)
import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;

public class ExceptionDemo2 {

}
class EDemo1{
    //方法重载与异常无关
    public void m()throws IOException {}
    public void m(int i){}
}
class EDemo2 extends EDemo1{
    //子类不能抛出比异常更大范围的编译时异常
    @Override
    public void m()throws EOFException, FileNotFoundException,
                          NullPointerException {}
}

2、重写原则
方法签名一致
如果父类的方法返回值类型时基本类型/void,那么子类的方法返回值类型和父类保持一致
当父类的方法返回值类型是一个引用数据类型,那么子类的方法返回值要么和父类方法返回值一致要么是父类方法返回值类型的子类
子类方法不能抛出比父类更大范围的编译时异常
子类方法访问权限修饰符要么和父类一致要么比父类的访问权限修饰符大

finally块
无论异常是否捕获都要把块里的内容执行完毕

public class ExceptionDemo3 {
    public static void main(String[] args) {
        try{
            int i = 1/0;
            System.out.println("try");
        }catch (Exception e){
            System.out.println("catch");
        }finally {
            //无论异常是否出现都会执行的内容
            System.out.println("finally");
        }
    }
}

关于finally的拓展

public class ExceptionDemo4 {
    public static void main(String[] args) {
        System.out.println();
    }

    //
    public static int m(){
        try{
            //当try块和catch块中分别协商return有返回值
            return 1;
        }catch (Exception e){
            return 1;
        }finally {
            //单独在finally写rerurn有返回值
            //return 1;
        }
        //最后写return有返回值
        //如果能保证前面一定有返回值此时这里就不能出现return
        //return 1;
    }
}


public class ExceptionDemo5 {
    public static void main(String[] args) {
        System.out.println(m());
    }

    public static int m(){
        int i = 1;
        try{//当没有出现catch时Java就认为try块没有问题
            /*
            重上往下依次编译执行
            此时执行return i++;-----return 1;但是发现后面有finally块,
            保证必须要执行finally中的内容,
            此时只能把return1;这句代码的状态以及值进行挂起不执行
            接着执行finally块里的内容---i++---i=3,此时finally块已经执行完毕
            回头执行之前挂起的状态以及值return 1;返回值就是1
             */
            return i++;
        }finally {
            return i++;
            //return i++;一定执行完finally块中的内容直接就把return执行完毕
            //此时方法就结束了,前面挂起的内容就不会执行,被清除
        }
    }
}


public class ExceptionDemo6 {
    public static void main(String[] args) {
        System.out.println(m());

    }
    public static Person m(){
        Person p = new Person();
        p.name="乐言";
        p.age=19;
        p.gender='男';

        try{
            p.name="悟空";
            p.age=500;
            p.gender='男';
            return p;
            /*
            从上往下一次编译和执行
            当执行到此代码是,return p(地址值指向此代码);发现后续有finally块
            此时要把return p;状态以及地址值进行挂起
            接着执行finally块里的内容,根据地址值把堆里的属性改成林有有,执行完毕
            回头执行挂起的内容return p(地址值指向原来的堆内存  ,堆内存的属性值改为林有有)
            所以返回值就是林有有
             */
        }finally {
            p.name="林有有";
            p.age=23;
            p.gender='女';
        }

    }
}

class Person{
    String name;
    int age;
    char gender;

    //重写toString方法

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}


public class ExceptionDemo7 {
    public static void main(String[] args) {
        System.out.println(m());
    }
    public static String m(){
        String str = "LOL";
        try {
            /*
            挂起---return str(指向王者荣耀)
            接着执行finally块中的内容----str="黑悟空";(新对象覆盖str的引用)
            回头执行挂起的内容---return str(指向王者)
             */
            str = "王者荣耀";
            return str;
        }finally {
            str="黑悟空";
        }
    }
}


变量是Java中最小的容器

集合(Collection)

集合是可以存储多个数据的容器,且长度可变
<大写字母>—泛型—代表集合的元素类型,由于类型指定集合元素类型只能是引用数据类型。

int[] arr;----arr的类型是数组类型(引用类型),元素类型是int类
Collection<String> c;   //c的类型是引用类型,元素类型是String类型
Collection<Integer> c;   //可以储存整型数据

Collection是集合的顶级接口
子接口:List Set Queue
List(顺序表):
保证数据存放有序
可以存储重复元素
可以通过下标来操作元素
实现类:Arraylist LinkedLise Vector Stack
Arraylist(顺序表)
底层由数组实现的数据存储,默认出事容量为10,底层根据右移运算进行扩容,每次扩容实在原容量的基础上增加一半

import java.util.ArrayList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        //创建集合对象
        //向上造型的对象
        List<java.lang.String> list = new ArrayList<>();
        //添加元素
        list.add("abc");
        list.add("ab");
        list.add("bc");
        list.add("ac");
        //插入元素
        //最大支持的插入下标是元素个数
        list.add(2,"123");

        //根据下标来删除元素
        //最大支持的删除下标是元素个数-1
        list.remove(3);

        //根据指定内容删除元素
        //如果指定内容没有出现在元素中就不做任何操作
        list.remove("ac");


        //清空集合
        //list.clear();

        //判断指定内容是否包含在元素中
        System.out.println(list.contains("abc"));

        //根据指定下标来获取元素
        System.out.println(list.get(0));

        //返回指定内容第一次出现的下标
        System.out.println(list.indexOf("abc"));

        //判断集合是否为空
        System.out.println(list.isEmpty());

        //替换元素
        list.remove(0);
        list.add(0,"123");
        list.set(0,"456");

        //返回元素个数
        System.out.println(list.size());

        //截取子列表
        //指定下标含头不含尾
        System.out.println(list.subList(1,3));

        //把集合元素放到数组中
      /*  Object[] os = list.toArray();
        for (Object o:os){
            String s = (String) o;
        }*/
        //传入数组对象返回对应类型的数组
        //给定的数组长度大于等于0
        String[] ss = list.toArray(new String[10]);


        //保证数据存放有序
        System.out.println(list);

    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值