API-文件数据IO操作、异常

一.文件数据IO操作

1.Stream:

节点流：功能简单，只能进行byte读写

FIS  FOS

扩展流=高级流=过滤流=过滤器：

功能复杂，封装算法：在基本的byte流基础上扩展了复杂类型

读写：缓冲区，对象，字符串

2.高级扩展流使用更加便捷！扩展流依赖节点流！

加密文件->节点流->解密流->对象流

3.文本文件保存编码，和文本文件读取的编码不一致时，因为windows默认的是默认的GBK，所以有些文件是乱码的。

4.BufferedReader缓冲字符输入流：其内部提供了缓冲区，可以提高读取效率。

代码练习

public class ReaderDemo01 {
    public static void main(String[] args) throws IOException {
        String file="demo.txt";
         /*
         * BufferedReader 也是扩展流，依赖最底层的节点流。 
         */
        //缓冲字符输入流Reader，不是Writer
        BufferedReader out=
        new BufferedReader(
        //理解，记忆不深，是InputStreamReader，不是InputStreamWriter
        new InputStreamReader(
        new BufferedInputStream(
        new FileInputStream(file)),"utf-8"));
        String str;
         /*
         * readLine() 可以从文件中读取一行文本（到
         * 回车字符为止），返回文本中不包含回车字符，
         * 如果读取到文件的末尾，返回null 
         * 如下代码可以从文件中读取所以的行
         */
        while((str=out.readLine())!=null){
            System.out.print(str);
        }
        out.close();
    }
}

5. PrintWriter是具有自动行刷新的缓冲该字符输出流。

import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
public class WriterDemo {
    public static void main(String[] args) throws UnsupportedEncodingException, FileNotFoundException {
/*
         * 创建 PrintWriter 使用可以提供自动缓冲
         * 刷出功能参数，true的时候开启自动缓冲刷出。
         * 这个时候，调用 println, 方法会自动执行flush方法。
         * 这个自动刷出功能在网络通信软件中很有用途
         * 
         * 如果要测试自动刷出功能，可以将out.close()
         * 去掉测试！实际工作中必须关闭文件！
         */
        PrintWriter out=
                new PrintWriter(
                        new OutputStreamWriter(
                                new BufferedOutputStream(
                                        new FileOutputStream("demo01.txt")),"utf-8"),true);
//        PrintWriter out = 
//            new PrintWriter(file, "utf-8"); 
        
        /*
         * PrintWriter 提供了非常便于输出文本的方法 println print。
         * println方法可以向文件中输出一行文本，输出以后会自动
         * 插入回车字符，作为一行的结束。
         */
        out.println("老师，您今天辛苦了");
        out.println("您今天上午一定要过来");
        out.write("要不我白来实验室刷存在感了");
        out.close();
    }
}

二、异常

1. Java异常结构中定义有Throwable类。Exceotion和Error是其派生的两个子类。

（1）Exception（程序可处理异常）表示由于网络故障、件损坏、设备错误、用户输入非法等情况导致的异常，这类异常是可以通过Java异常捕获机制处理的。

包括：

      1） IOException异常：其中IOException包括FileNotFoundException异常

      2）ParseException

      3）RuntimeException（非检查异常）：编译器不检查这类异常。一个方法抛出非检查异常，调用时候编译器忽略是否处理异常检查！抛出非检查异常时候不用声明。

该类异常包括：NullPointerException，NumberFormatException，ArrayIndexOutOfBoundsException

（2）Error（不可恢复错误，无法处理）表示Java运行时环境出现的错误，例如:JVM内存溢出等。

      该类异常包括：OutOfMemoryError，StackOverflowError

2.异常处理try-catch

   try {...} 语句指定了一段代码，该段代码就是一次捕获并处理例外的范围。在执行过程中，该段代码可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句分别对这些异常做相应的处理。如果没有列外产生，所有的catch代码段都被略过不执行

4.多个catch

  每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常 。catch捕获的异常类型由上至下的捕获异常类型的顺序应是子类到父类的。

  通常在书写代码的时候，我们应当在最后一个catch中捕获Exception，这样可以保证代码不会因为出现一个未在catch中声明的异常而导致捕获失败使得程序终止。

5. finally语句为异常处理提供一个统一的出口，无论try所指定的程序块中是否抛出例外,finally所指定的代码都要被执行，通常在finally语句中可以进行资源的消除工作，如关闭打开的文件、删除临时文件等。

finally语句块只能定义在try语句块之后，或者最后一个catch语句块之后，且只能定义一次。

6.throw和throws关键字

throw关键字：在某些时刻，您可能会想要自行抛出异常，例如在异常处理结束后，再将异常抛出，让下一层异常处理区块来捕捉，若想要自行抛出异常，可以使用“throw”关键词，并生成指定的异常对象。

throws关键字：程序中会声明许多方法（Method），这些方法中可能会因某些错误而引发异常，不希望直接在这个方法中处理这些异常，而希望调用这个它的方法来统一处理，这时候可以使用“throws”关键词来声明这个方法将会抛出异常

重写方法时的throws

当使用继承时，在父类的某个方法上声明了throws抛出某些异常，而在子类中重写该方法时，可以做以下的操作:

（1）不处理异常（重写方法时不声明throws）

（2）可仅在throws中声明父类中声明的部分异常

（3）可在throws中声明父类方法中抛出的异常的子类异常

但是不能做以下操作：

（1）重写方法时在throws中声明抛出额外的异常

（2）重写方法时在throws中声明父类方法中声明的抛出异常的父类异常

7.Throwable中定义了一个方法可以输出错误信息，用来跟踪异常事件发生时执行堆栈的内容。该方法定义为:

    void printStackTrace()

  Throwable中定义了一个方法可以得到有关异常事件的信息。该方法定义为:

   String getMessage()

8.自定义异常

Java异常机制可以保证程序更安全和更健壮。虽然Java类库已经提供很多可以直接处理异常的类，但是有时候为了更加精准地捕获和处理异常以呈现更好的用户体验，需要开发者自定义异常。

public class [自定义异常类名] extends Exception{...}

当定义好自定义异常后，我们可以通过Eclipse来自动生成相应的构造方法。具体步骤如下:

(1)声明一个类并继承自Exception

(2)右键点击Source

(3)选择Generate Constructors from Superclass

(4)选中父类中所有构造方法后确认生成

9.异常实例说明

（1）Error-OutOfMemoryError异常

import java.util.ArrayList;
import java.util.List;
public class EXPDemo03 {
    public static void main(String[] args) {
        /*
         * OutOfMemoryError 是堆内存耗尽没有空间分配对象了！
         * 有个术语: 内存泄露
         * 原因：大量分配对象，而没有回收对象造成内存泄露！
         * 解决办法：及时回收对象，扩内存！
         * 出现以后Java系统立即崩溃！ 
         */
         //要复习集合了，又忘记知识点了
        List<Koo> list=new ArrayList<Koo>();
        for(int i=0; i<10000000; i++){
            Koo k = new Koo();
            //list.add(k);
            k = null;
        }
        System.out.println("OK"); 
    }
}
class Koo{
    int n=8;
    double d = 9;
}

（2）Error-StackOverflowError异常

public class EXPDemo04 {
    public static void main(String[] args) {
        /*
         * 由于反复递归调用test方法照成 栈内存不够
         * 分配 出现了 StackOverflowError
         */
        test();
    }
        /*
         *错误：编写方法是没有加static，因为main方法是static方法，
         *不能调用非静态的，所以test方法必须加static
         */
    public static void test(){
        int a = 4;
        int b = 5;
        test();
    }
}

（3）Exception--ParseException异常（编译器检查语法）

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

public class EXPDemo05 {

    public static void main(String[] args) {
        String str="2015-03-24";
        //日期这部分掌握的也不是很好啊。SimpleDateFormat都写错了，---真的欠练
        /* 
         * 字符串转换为日期对象
         */
        SimpleDateFormat format=
                new SimpleDateFormat("yyyy-MM-dd");
        str="甲午年仲秋";
        /*
         * parse 方法上声明了异常抛出，
         * Java 编译器检查：调用有异常，就必须处理 异常，否则有编译错误.
         * 好处：parse 出现错误的机会很高！
         *  可以强行要求程序员，必须对可能出现的 错误加以干预，减少运行期间对用户的影响！
         *  str = "甲子年仲秋";
         * 如：采用策略,如果str错误的，就采用当前时间
         */
        Date d;
        try{
            d=format.parse(str);
            System.out.println("成功解析时间");
        }catch(ParseException e){
            System.out.println("解析时间失败");
            d=new Date();
        }
        System.out.println(d);
    }
}

（4）Exception-RuntimeException(非检查异常)-NumberFormatException

public class EXPDemo02 {
    public static void main(String[] args) {
        String str = "A66";
        /*
         * parseInt 当参数不能转换为数字时候会出现意外结果：NumberFormatException
         * parseInt 如果参数能够转换为int数字。     
         * 如果出现意外结果，方法抛出一个异常对象，
         * 阻止软件继续运行，直到被try catch捕获为止
         */
        /*
         * 使用try 将可能出故障（异常）的代码库包裹起来，利用catch抓取可能出现的异常。
         * catch参数是抓取异常类型名
         * 执行流程：
         * 如果try中的代码没有执行故障（异常）就
         * 将try中的代码块执行，并不执行catch中的代码。
         * 如果有异常故障，就跳到catch中执行代码
         * 
         * 如果不处理异常，Java的当前线程会被终止执行！
         * 程序被异常"卡"掉了结束了。"闪退"
         * 
         * 程序中应用处理异常!
         */
        
        try{//异常处理语句块
            int n = Integer.parseInt(str);
            System.out.println(n);
        }catch(NumberFormatException e){
            System.out.println("解释失败！");
        }
        System.out.println("OK");
    }
}

 （5）finally实例说明

public class ExpDemo08 {
    public static void main(String[] args) {
        try{
            String s = "A";              //1 //1
            int a = Integer.parseInt(s); //2 //2
            System.out.println(a);       //3   
        }catch(NumberFormatException e){ 
            System.out.println("异常");        //3
        }finally{
            //finally 无论是否有异常，都会执行！
            System.out.println(
                    "我还会回来的！");       //4 //4
        }
        System.out.println("end");        //5 //5
    }
}

（6）多个catch实例说明

package day10;
public class EXPDemo10 {

    public static void main(String[] args) {
        int n = test("");
        System.out.println(n);//5
    }
    public static int test(String str){
        try{
            char c = str.charAt(0);
            return c - '0'; // '0'=48  '5'=53
        }catch(NullPointerException e){
            e.printStackTrace();
            return -1;
        }catch(StringIndexOutOfBoundsException e){
            e.printStackTrace();
            System.out.println("-2");
            return -2;
        }finally{
            System.out.println("-10");
            return -10;
        }
        //return -5; 不可执行的代码
    }
}

（7）throw和throws关键字

import java.io.IOException;
import java.io.PrintWriter;
public class EXPDemo09 {
    public static void main(String[] args) {
        
    }
    
    public static void save(String file, 
            String msg) 
            throws IOException{
        /*
         * 处理不了抛出去 
         */
        PrintWriter out = null;
        try{
            out=new PrintWriter(file);
            /**
             * 如果println 有异常，这个时候
             * 不会执行close(), 文件没有可靠关闭
             */
            out.println(msg);
        }catch(IOException e){
               //此处抛出，方法定义上必须也抛出
            throw e;
        }finally{
            //利用finally可靠关闭文件！
            if(out!=null){
                out.close();
            }
        }
    }
}