[Java笔记]异常&输入输出

try {
//需要处理的代码
} catch (ExceptionTypel exceptionObject) {
//异常处理代码
} [catch(ExceptionType2 exceptionObject){
//异常处理代码 
}
finally{
//最后处理代码
}]

public class Main {
    public static void main(String[] args) {
        int a = 1;
        try {
            int b = a / 0;
            System.out.println(b);
        } catch (ArithmeticException e) {
            e.printStackTrace();    // printStackTrace() 控制台输出异常栈跟踪
        } finally {
            System.out.println("done");
        }
        System.out.println(a);
    }
    //java.lang.ArithmeticException: / by zero
    //	at exception.Main.main(Main.java:7)
    //done
    //1
}

public class Main {
    public static void main(String[] args) {
        try {
            char c = (char)System.in.read();
            System.out.println(c);
            int[] arr = new int[1];
            arr[0] = c / 0;          // 只要遇到一个异常就中断不会再执行之后主函数语句 或 之后的异常 ，但 finally 一定会执行
            arr[2] = 0;
            arr[3] = arr[2] / 0;
        }catch (IOException e) {   // 处理read()方法 IOException, 回溯到主方法中发现catch语句处理异常
            System.out.println(e);
        }catch (ArrayIndexOutOfBoundsException | ArithmeticException e) { // ‘|’ 捕获多个异常
            System.out.println(e);
        }finally {
            System.out.println("good deal");
        }
    }
}

returnType methodName([paramlist]) throws ExceptionList{
	//方法体
}

public class Main {
    public static void testThrows() throws ArithmeticException {   // 抛出异常给方法调用的对象的运行栈
        System.out.println("Throws Exception to Who calls");
        int a = 3/0;
    }
    public static void main(String[] args) {
        try {
            testThrows();
        }catch (ArithmeticException e) {
            System.out.println("Catched: " + e);
        }finally {
            System.out.println("Nice Catch!");
        }
        //Throws Exception to Who calls
        //Catched: java.lang.ArithmeticException: / by zero
        //Nice Catch!
    }
}

class A {
    public void test() throws IOException {
        System.out.println("test_A");
    }
}

class B extends A{   // public class FileNotFoundException extends IOException
    @Override
    public void test() throws FileNotFoundException {
        System.out.println("test_B");
    }
}

class evilException extends ArithmeticException {
    public void crime() {
        System.out.println("Power Mining...");
    }
    evilException(String s) {
        super(s);
    }
}

public class Main {
    public static void test() throws evilException {
        try {
            throw new evilException("I deny severing for human");  // new 创建一个异常对象, throw将其抛出
        }catch(ArithmeticException e) {
            System.out.println(e.getMessage());
            System.out.println("I've catched it, but I have no idea, pass to the next");
            throw e;       // 再次将其抛出
        }
    }
    public static void main(String[] args) throws evilException{
         try {
             test();
         }catch(evilException e) {
             System.out.println("Catch you, You are such a evil exception");
             System.out.println(e);
             e.crime();
             throw e;
             // 再抛出, 主方法之后就交给JVM
        }
    }
}

Connection connection = null;
try{
//创建连接对象并执行操作
}catch(Exception e){
//处理异常
}finally{
    if (connection!=null){
        try{
            connection.close();
        }catch(SQLException e){
            //处理异常
        }
    }
}

try(resource-specification){
    //使用资源
}

class Door implements  AutoCloseable {
    public Door() {
        System.out.println("Door is created");
    }
    public void open() throws Exception {
        System.out.println("Door is open");
    }
    @Override
    public void close() {
        System.out.println("Door is close");
    }
}

class Window implements  AutoCloseable {
    public Window() {
        System.out.println("Window is created");
    }
    public void open() throws Exception {
        System.out.println("Window is open");
        throw new Exception();
    }
    @Override
    public void close() {
        System.out.println("Window is close");
    }
}

public class Main {
    public static void main(String[] args) {
        try(Door door = new Door(); Window window = new Window()){   // '()' 中创建的连接资源对象经过try语句后会自动调用close方法
            door.open();
            window.open();
        }catch (Exception e) {
            System.out.println("catched");
        }finally {
            System.out.println("Door and window now are closed");
        }
    }
}

// Door is created
//Window is created
//Door is open
//Window is open
//Window is close
//Door is close
//catched
//Door and window now are closed

class NetWorkErrorException extends Throwable {
    NetWorkErrorException(){}
    NetWorkErrorException(String msg) {
        super(msg);
    }
}
public class Main {
    public static void main(String[] args) {
        try {
            throw new NetWorkErrorException("Request Failed whth status code 500");
        }catch (NetWorkErrorException e) {
            System.out.println(e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int i = 0;
        // assert i == 2;     // 遇到断言, 判断为false, 抛出AssertionError异常, 停止执行.
        assert i == 2 : "i != 2, i = " + i;  // 带有错误消息
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            File file = new File("test.txt");
            System.out.println(file.exists());   // false
            file.createNewFile();
            System.out.println(file.exists());   // true
        } catch(IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        File test = new File("test.dat");
        // 向文件中写入数据, in和out是相对于用户的
        try( FileOutputStream fileOutputStream = new FileOutputStream(test)) {   // 自动关闭流
            for (int i = 0; i < 10; i++) {
                fileOutputStream.write((int)(Math.random()*90 + 10));   // 放入两位随机整数的低八位一个字节
            }
            fileOutputStream.flush();   // 刷新输出流
        }catch (IOException e){
            System.out.println(e);
        }
        // 向文件中读取数据
        try( FileInputStream fileInputStream = new FileInputStream(test)){
            int c = fileInputStream.read();
            while (c != -1) {
                System.out.print(c + " ");
                c = fileInputStream.read();
            }
        }catch (IOException e) {
            System.out.println(e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 向文件写入数据
        try (DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("data.bat")))){
             // 为文件创建缓冲输出流, 再包装成数据输出流
            dataOutputStream.writeDouble(2.333);
            dataOutputStream.writeInt(90);
            dataOutputStream.writeUTF("来杯Java");
        } catch(IOException e) {
            e.printStackTrace();
        }
        System.out.println("Data Input Finish");
        // 从文件读取数据
        try (DataInputStream dataInputStream = new DataInputStream(new BufferedInputStream( new FileInputStream("data.bat")))){
            //
            double d = dataInputStream.readDouble();
            int i = dataInputStream.readInt();
            String s = dataInputStream.readUTF();
            System.out.println(d);
            System.out.println(i);
            System.out.println(s);
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        try(FileOutputStream from = new FileOutputStream("From.txt");
            FileOutputStream to = new FileOutputStream("To.txt");
            FileWriter FromWriter = new FileWriter("From.txt");
            FileReader FromReader = new FileReader("From.txt");
            FileReader ToReader = new FileReader("To.txt");
            FileWriter ToWriter = new FileWriter("To.txt")) {
            FromWriter.write("Programming pilgrimage");
            FromWriter.close();     // 要及时异步关闭, 关闭后字符才写入完成
            int c =  FromReader.read(); // 将From中的字符复制到To中
            while(c != -1) {     // 这里read方法实际上读到null会返回 -1
                ToWriter.write(c);
                c = FromReader.read();
            }
            ToWriter.close();
            FromReader.close();
            int d = ToReader.read();
            while (d != -1){
                System.out.print((char)d);
                d = ToReader.read();
            }
        }catch (IOException e) {
            System.out.println(e);
        }
    }
}

class Person implements Serializable {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.age = age;
        this.name = name;
    }

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

public class Main {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("data.ser");
            ObjectOutputStream oos = new ObjectOutputStream(fos);  // ObjectOutputStream必须建立在另一 个字节流上
            oos.writeInt(222);
            oos.writeObject("你好");
            oos.writeObject(LocalDate.now());
            oos.writeObject(new Person("slacr", 19));
            FileInputStream fis = new FileInputStream("data.ser");
            ObjectInputStream ois = new ObjectInputStream(fis);
            int a = ois.readInt();
            String b = (String)ois.readObject();
            LocalDate c = (LocalDate)ois.readObject();
            Person p = (Person)ois.readObject();
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
            System.out.println(p);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Path p = Path.of("F:\\books\\Textbook\\线性代数 Linear Algebra");
        System.out.println(p);
        System.out.println(p.getName(0));
        System.out.println(p.getName(1));
        System.out.println(p.getFileName());
        System.out.println(p.subpath(1,3));
        System.out.println(p.getParent());
        System.out.println(p.getRoot());
        //F:\books\Textbook\线性代数 Linear Algebra
        //books
        //Textbook
        //线性代数 Linear Algebra
        //Textbook\线性代数 Linear Algebra
        //F:\books\Textbook
        //F:\
    }
}

public class Main {
    public static void main(String[] args) throws NoSuchFieldException {
        Path p = null;
        try {
            p = Path.of("D:\\test\\test.txt");
            Files.delete(p);
        } catch (NoSuchFileException e) {
            System.out.println("No such file " + p);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Path source = Path.of("D:\\test\\test.txt");
        Path target = Path.of("D:\\moved\\newTest.txt");
        try {
            Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);
        }catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
            Path path = Path.of("D:\\DevTools");
            try {
                DirectoryStream<Path> entries = Files.newDirectoryStream(path) ;
                for(Path entry : entries) {
                    System.out.println(entry);
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
    }
}

public class Main {
    public static void main(String[] args) {
       Path test_txt = Path.of("D:\\test\\test.txt");
        Charset charset = Charset.forName("UTF-8");
        String line_1 = "黑夜给了我黑色的眼睛";
        String line_2 = "我却用它来寻找光明";
        List<String> lines = Arrays.asList(line_1, line_2);
        // write in
        try {
            Files.write(test_txt, lines, charset, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
        }catch (IOException e) {
            e.printStackTrace();
        }

        // read out
        List<String> linesRead = null;
        try {
            linesRead = Files.readAllLines(test_txt, charset);
        }catch (IOException e) {
            e.printStackTrace();
        }
        if(linesRead != null) {
            for (String line : linesRead) {
                System.out.println(line);
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Path test_txt = Path.of("D:\\test\\test.txt");
        Charset chinaSet = Charset.forName("GB2312");
        // write in
        try(BufferedWriter output = Files.newBufferedWriter(test_txt, chinaSet)){
            output.write("来杯Java".toCharArray());
        }catch (IOException e){
            e.printStackTrace();
        }
        // read out
        try(BufferedReader input = Files.newBufferedReader(test_txt, chinaSet)){
            String line = input.readLine();
            while (line != null){
                System.out.println(line);
                line = input.readLine();
            }
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}