java-异常、集合-day01

异常

1.概念

用于发现问题、反馈问题以及解决问题的一套机制

2.Throwable类—异常的顶级父类

	子类

Error：是一个合理的应用程序，不应该试图抓住的严重问题
（改变外部需求、环境、资源等等）
Exception：是一个合理的应用程序可以处理也可以不处理

处理方式（1.抛出、2.捕获）

分类

编译时异常—在编译时期出错 一定要处理 除了RuntimeException
类以及子类以外其他的异常类
CloneNotSupportedException—克隆不支持异常
ParseException—解析异常

运行时异常—在运行时期出错 可以处理也可以不处理
RuntimeException类以及子类
ArithmeticException—算术异常
NullPointerException—空指针异常
ArrayIndexOutofBoundsException—数组下标越界异常
ClassCastException—类型转换异常
NumberFomatException—数字格式异常

捕获方式
	1.分别捕获---针对方法上抛出的所有异常进行分别处理

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

package cn.tedu.exception;

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

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










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





   /* //调用方法读取文件（txt）
    //方法上抛出几个编译时异常需要处理几个编译时异常
    try {//try块里存放的是可能会出问题的代码
        String s=readFiles(null);
    } catch (FileNotExitsException e) {//catch块会一直检测try块里是否有异常
        //如果出现异常根据对应的异常类的类型
        //来捕获对应抛出的异常
        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 FileNotExitsException,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 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){
        this.message=message;
    }*/

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



}

3.重载与重写

1.重载只和方法名以及参数列表有关系（和其他都没有关系）
2.重写原则
方法签名一致
如果父类的方法返回值类型是基本类型/void，
那么子类的方法返回值类型和父类保持一致
当父类的方法返回值类型是引用数据类型，
那么子类方法返回值类型要么和父类一致要么是父类方法返回值类型的子类
子类方法不能抛出比父类更大范围的编译时异常
子类的方法访问权限修饰符要么和父类一致要么比父类的访问权限修饰符大

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

4. 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 ExceptionDemo5 {
    public static void main(String[] args) {
        System.out.println(m());//1
    }

    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=500;
        p.gender='男';

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



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

集合（Collection）

1.概念

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

2.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");
        list.add("ab");
        //插入元素
        //最大支持的插入下标是元素个数
        //list.add(4,"123");

        //根据下标来删除元素
        //最大支持的删除下标是元素个数-1
        //list.remove(2);
        //根据指定内容来删除元素
        //如果指定内容没有出现在元素中就不做任何操作
        //list.remove("ab");

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

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

        //根据指定下标来获取元素
        //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;
        }*/
        //传入数组对象返回对应类型的数组
        //给定数组长度只要大于等于0即可
       //String[] ss=list.toArray(new String[1]);

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

实现类：ArrayList、LinkedList、Vector、Stack
ArrayList（顺序表）
底层由数组实现数据存储，默认初始容量为10。底层根据右移运算进行扩容，
每次扩容是在原容量的基础上增加一半。

小练习：用数组实现ArrayList