Java学习 DAY15 异常捕获方式、集合引入

捕获方式

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

package cn.tedu.exception;

public class ExceptionDemo1 {
    public static void main(String[] args) {
        //调用方法读取文件
        //方法上抛出几个编译时异常就捕获几个编译时异常

        //分别捕获,提供对应的catch捕获

        //统一捕获---提供一个catch捕获方法上抛出的所有异常

        //分组捕获---用|来间隔一组的异常类，一组之间及进行统一处理
        try {//try块里存放的是可能会出问题的代码
            String s=readFiles("W:\\a.avi");//null
        } catch (FileNotExitException | FilesNotFoundException | NullPointerException e) {//catch块会一只检测try块里是否有异常
            //如果出现异常，根据对应的异常类的类型来捕获对应抛出的异常
            //e.printStackTrace();
            System.out.println("问题已经处理...");

        }/*catch (FilesNotFoundException e){//=new FilesNotFoundException("亲，你的文件类型不对!!!");
            //获取描述信息
            //调用父类的方法来间接的获取父类的私有化属性值
            System.out.println(e.getMessage());
        }catch (NullPointerException e){
            //打印栈轨迹
            e.printStackTrace();
        }*/
        //当异常被处理之后后续代码正常执行
        System.out.println("读取完成");
    }
    //定义读取文件的方法
    //方法上可以抛出多个异常（中间用逗号间隔）
    //如果方法上必须要抛出的异常就是编译时异常
    public static String readFiles(String path) throws FileNotExitException, FilesNotFoundException,NullPointerException {

        //判断路径是否是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 FileNotExitException();
        }

        //读取文件内容
        return "文件内容";
    }
}

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

}
class FilesNotFoundException extends Exception{
   /* //私有化属性
    private String message;

    //提供获取私有化属性的get方法
    @Override
    public String getMessage() {
        return message;
    }

    //有参构造给私有化属性进行赋值
    public FilesNotFoundException(String message){
       this.message=message;
    }*/

    //有参构造给父类的私有化属性进行赋值
    public FilesNotFoundException(String message){
        super(message);
    }
}

重载与重写
1.重载只和方法名以及参数列表有关系（和其他都没有关系）
package cn.tedu.exception;

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{}
}

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

finally块

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

package cn.tedu.exception;

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");
        }
    }
}

package cn.tedu.exception;

public class ExceptionDemo4 {
    public static void main(String[] args) {

    }

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

package cn.tedu.exception;

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块里内容
            //此时就只能把return 1；这句代码的状态以及值进行挂起不执行
            //接着执行finally块里内容---i++---i=3；finally块已经执行完毕
            //回头执行之前挂起的状态以及值return 1；返回值就是1
            return i++;
        }finally {
            i++;
            //return i++;一定会执行完finally块里的内容直接就把return执行完毕
            //此时方法就结束了，前面挂起的内容就被清楚

        }
    }
}

package cn.tedu.exception;

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=10;
        p.gender='男';
        try {
            p.name="乐爷";
            p.age=18;
            p.gender='男';
            //从上往下依次编译和执行
            //当代码执行到此处时，return p（地址值只想内容是乐爷）；发现后续有finally块
            //此时要把return p；状态以及地址值进行挂起
            //接着执行finally块里的内容，根据地址值
            //
            //
            // 把堆里属性值改成林有有，执行完毕
            //回头执行挂起内容return p(地址值只想原来的堆内存，堆内存属性值改为林有有)
            //返回值就是林有有
            return p;

        }finally {
            p.name="林有有";
            p.age=23;
            p.gender='女';
            //return p;
        }

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

    //重写toString方法

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

package cn.tedu.exception;

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="黑悟空";
            //回头执行挂起的内容---return str(指向王者)；
            str="王者荣耀";
            return str;
        }finally {
            str="黑悟空";
        }
    }
}

集合（Collection）

可以存储多个数据且长度可变的容器
<大写字母>—泛型—表示集合的元素类型，由于类型指定集合元素类型只能是引用数据类型。
int[] arr;//arr的类型是数组类型(引用类型)，元素类型是int类型
Collectionc;//c的类型是引用类型，元素类型是String类型
Collectionc;//可以存储int类型数据 1 234 645 897978

Collection是集合的顶级接口

子接口：List、Set、Queue

List（列表）
保证数据存放有序
可以存储重复元素
可以通过下标来操作元素

package cn.tedu.collection.list;

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

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

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

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

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

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

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

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

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

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

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


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

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

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