7月23日JavaSE学习笔记

异常：

程序中一些程序处理不了的特殊情况

异常类 Exception 继承自 Throwable 类（可抛出的）

Error：错误/事故，Java程序无法处理，如 OOM内存溢出错误、内存泄漏...会导出程序崩溃

常见的异常：

NullPointerException 空指针异常

ArrayIndexOutOfBoundException 数组下标越界异常

StringIndexOutOfBoundsException 字符串下标越界

ArithmeticException: / by zero 数学运算异常：除数为0

...

异常的种类：

1.检查性异常（编译异常）：在编译时就会抛出的异常（代码上会报错）

需要在代码中编写处理方式，直接继承自 Exception

常出现在和程序之外的资源进行访问，如 FileNotFoundException 异常，文件找不到

2.运行时异常：在代码运行阶段可能会出现的异常

可以没有明文处理，可以通过代码避免异常的发生，继承自 RunTimeException

编写代码规避异常：

        String str = null;String name = "张三";boolean bool = name.equals(str);//确定的值放在前面比较System.out.println(bool);if(str!=null){System.out.println(str.length());}else {System.out.println("str是null值");}int i=12;int a=0;if(a!=0){System.out.println(i/a);}else {System.out.println(a);}

处理异常 try...catch...finally

try：尝试捕捉异常，其中是可能抛出异常的代码块

catch：捕获到的异常类型以及后续要进行处理的代码

finally：无论是否出现异常都会执行的代码块，常用于关闭资源，如关闭流、连接、线程池...

        //以处理文件为例File file = new File("D:\\easy.text");FileInputStream fis = null;//声明在外，提升作用域//检查性异常（编译异常）try{//try尝试捕捉异常，其中是可能抛出异常的代码fis = new FileInputStream(file);//中间代码如果有异常抛出被catch捕捉，后续代码没有机会执行}catch (FileNotFoundException e){//捕捉到异常后要处理的代码e.printStackTrace();//打印异常日志}finally {//无论是否出现异常都会执行的代码块if(fis!=null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}

当try的代码块中可能抛出多个异常需要处理时：

1.用多个catch块依次捕获异常（catch异常捕捉的顺序：子类异常优先处理，父类异常后置处理）

        try{List list = new ArrayList();//IndexOutOfBoundsExceptionlist.remove(8);int[] arr = new int[2];//ArrayIndexOutOfBoundsExceptionarr[8] = 22;String strA = "abc";//StringIndexOutOfBoundsExceptionstrA.charAt(8);}catch (ArrayIndexOutOfBoundsException e){e.printStackTrace();}catch (StringIndexOutOfBoundsException e){e.printStackTrace();}catch (IndexOutOfBoundsException e){e.printStackTrace();}

2.合并处理方案，用一个catch块捕捉多种异常：使用 | 声明多种异常

        //合并处理方案，一个catch块捕捉多种异常try{System.out.println(12/0);Object strA = "";System.out.println((Integer)strA);fis = new FileInputStream(file);}catch (ArithmeticException|ClassCastException|FileNotFoundException e){System.out.println("出现异常");}

3.通过声明父类异常来捕捉所有子类异常

        //通过声明父类异常来捕捉所有子类异常try{System.out.println(12/0);Object strA = "";System.out.println((Integer)strA);fis = new FileInputStream(file);}catch(Exception e){e.printStackTrace();}

注意：如果在catch块中抛出异常，后面没有finally就会中断程序；

如果有finally，finally会运行，并且正常返回，此方法会正常运行结束。

    public static int test(){try{System.out.println(12/0);return 1;}catch (Exception e){//throw new Exception();return 2;//执行，暂存2}finally {return 3;//运行，最后返回3，参考出栈将2覆盖，返回最后执行的return//如果方法没有正常结束，不会有返回值}}

try不能单独编写，后面必须有其他语句块（catch和finally之一）

检查性异常必须有catch明文处理，只有try和finally而没有catch时不能有检查性异常；

try块中没有检查性异常时，不能在catch块中随意捕捉检查性异常；

运行时异常在try中没有时也可以捕捉，可以捕捉Exception。

自定义异常：

检查性异常：直接继承Exception类

运行时异常：继承RunTimeException

异常声明

class StudentNameIsNullException extends Exception{public StudentNameIsNullException(){}public StudentNameIsNullException(String msg){super(msg);//传入消息}
}

在方法中声明并抛出异常：

throw 用于在方法中声明抛出具体哪种异常对象

throws 用于方法后指出此处可能抛出哪种异常

    public void introduce() throws StudentNameIsNullException,NullPointerException, IOException {//name==null是一种特殊情况，不符合业务需求if(name==null){//检查性异常要在方法后抛出：告知此处出现一种特殊情况要注意//具体抛出哪一种异常对象throw new StudentNameIsNullException("Student name is null");}System.out.println("我的名字是"+name);}

注意：抛出的异常在语法上可以扩展到父类，但是在具体业务中不应该扩展；

throw和throws没有处理异常，只是抛给上级调用者；

检查性异常要在方法后抛出，告知此处出现一种特殊情况需要处理；

运行时异常可以不用throws抛出。

class CollegeStudent extends Student{@Overridepublic void introduce()throws StudentNameIsNullException{//重写的方法抛出异常只能更少，更精确，范围更小，可以没有，不能扩大}
}

方法重写时：子类对父类中继承过来的方法进行重新定义

约束：返回值类型、方法名、参数列表不能变；

访问权限只能更开放；

抛出的异常只能更少，更精确，可以没有，不能扩大。

文件处理

java中对文件处理使用 java.io包

常用方法：

1.声明一个文件类型，传入一个字符串作为地址

        File f = new File("D:\\easy.txt");

2.是否存在该文件 exists()

        boolean bool = f.exists();//是否存在System.out.println(bool);

3.创建文件（或文件夹）createNewFile()

        if (!bool){//如果文件不存在try {bool = f.createNewFile();if(bool == true){System.out.println("成功创建文件");}}catch (IOException e){e.printStackTrace();}}

4.删除文件（或文件夹）delete()

删除文件夹时，这个文件夹必须是空文件夹

            //删除文件夹时，这个文件夹必须是空的文件夹//f = new File("D:\\123");bool = f.delete();//删除System.out.println("成功删除文件"+bool);

5.判断是否是文件 isFile()

        bool = f.isFile();//是否是文件System.out.println(bool);

6.判断是否是文件夹 isDirectory()

        bool = f.isDirectory();//是否是文件夹System.out.println(bool);

7.创建文件夹

mkdir() 前面的路径必须都存在才能创建文件夹

mkdirs() 只需要有盘，会把包括路径上不存在的文件夹都依次创建

        //前面的路径必须都存在才能创建文件夹f.mkdir();//只需要有盘，会把路径上不存在的文件夹依次创建f.mkdirs();

8.获取文件路径 getPath()

        String str = f.getPath();//获取路径System.out.println(str);

9.获取长度（二进制多少B）length()

        //获取长度long len = f.length();//返回long类型System.out.println(len/1024/1024+"MB");

IO输入输出流

流：流动的是数据，是二进制

流的分类：

1.根据流动的方向不同：输入流和输出流

2.根据流动的介质（单位）不同：字符流和字节流

字符流只能读取文本文件如： .txt .xml .properties .html .csv等

字节流可以读取所有文件类型

3.根据功能（作用）不同：节点流、工具流、打印流、数据流、对象流

字节输入流 InputStream

//字节流输入流public static void readFile(){FileInputStream fis = null;try {fis = new FileInputStream("D:\\easy.txt");byte[] arr=new byte[1024];int lenth=0;while ((lenth=fis.read(arr))!=-1){//arr中就是读取的数据String str = new String(arr,0,lenth);System.out.print(str);String.valueOf(arr);}}catch (IOException e){e.printStackTrace();}finally {if (fis!=null){try{fis.close();}catch (IOException e){e.printStackTrace();}}}}

字符输入流 Reader

    //字符输入流public static void readFile(){FileReader fr=null;try{fr = new FileReader("D:\\0723.txt");char[] arr=new char[1024];int lenth=0;while ((lenth=fr.read(arr))!=-1){String str = new String(arr,0,lenth);System.out.print(str);}}catch (IOException e){e.printStackTrace();}finally {if(fr!=null){try{fr.close();}catch (IOException e){e.printStackTrace();}}}}

字符缓冲流 BufferedReader

工具流，字节转换流：把几个字节转换成一个字符，把字节流转换成字符流

缓冲流，有一个默认容量8192的字符数组，对输入的数据进行缓存，方便读写操作。

    //字符缓存流public static void readFileBuffer(){FileInputStream fis=null;InputStreamReader isr = null;BufferedReader br=null;try{fis = new FileInputStream("D:\\0723.txt");isr = new InputStreamReader(fis);br = new BufferedReader(isr);String line;while ((line = br.readLine())!=null){System.out.println(line);}}catch (IOException e){e.printStackTrace();}finally {if(fis!=null){try{fis.close();}catch (IOException e){e.printStackTrace();}}if(isr!=null){try{isr.close();}catch (IOException e){e.printStackTrace();}}if(br!=null){try{br.close();}catch (IOException e){e.printStackTrace();}}}}

字节输出流 OutputStream

默认会覆盖文件原本的内容，如果想在原内容上追加，需要传入第二个参数为true。

    //字节输出流public static void writeFile(){String str = "老崔很水";byte[] arr=str.getBytes();FileOutputStream fos = null;try{//默认覆盖，如果像在原本内容上追加，传入第二个参数为truefos = new FileOutputStream("D:\\easy.txt",true);fos.write(arr);}catch (IOException e){e.printStackTrace();}finally {if(fos!=null){try{fos.close();}catch (IOException e){e.printStackTrace();}}}}

对象输出流 ObjectOutputStream

序列化：将内存对象转换成序列（流）的过程；

进行序列化的对象必须是可序列化的，实现Serializable接口（标识接口，不需要实现方法）

    //对象输出流public static void writeObject(){//将内存对象转换成序列（流）的过程叫做序列化//这个对象必须是可序列化的Serializable，标识接口，不需要实现方法Staff staff=new Staff();staff.name="张三";staff.sex="男";staff.salary=3500;//对象输出流ObjectOutputStream oos = null;FileOutputStream fos = null;try{fos=new FileOutputStream("D:\\easy.txt");oos=new ObjectOutputStream(fos);oos.writeObject(staff);}catch (IOException e){e.printStackTrace();}finally {try{if(fos!=null){fos.close();}}catch (IOException e){e.printStackTrace();}try{if(oos!=null){oos.close();}}catch (IOException e){e.printStackTrace();}}}

对象输入流 ObjectInputStream

反序列化：将对象序列读入程序，转换成对象的方式。反序列化会创建新的对象。

    public static void readObject(){//将对象序列读入程序，转换成对象的方式：反序列化//反序列化会创建新的对象FileInputStream fis = null;ObjectInputStream ois = null;try{fis = new FileInputStream("D:\\easy.txt");ois = new ObjectInputStream(fis);Object obj = ois.readObject();System.out.println(obj);}catch (Exception e){e.printStackTrace();}finally {try{if(fis!=null){fis.close();}}catch (IOException e){e.printStackTrace();}try{if(ois!=null){ois.close();}}catch (IOException e){e.printStackTrace();}}}

创建对象的方式：1.new 2.克隆 3.反序列化 4.反射