主要内容

编程实例：可视化日历
编程实例：遍历一个文件下的目录结构
异常处理机制

笔记详情

1. 可视化日历

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class VisualCalendar {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请按照格式输入时间（2018-12-20）:");
        String tempTime = sc.next();

        Calendar cal = Calendar.getInstance();

        try {
            DateFormat dateForm = new SimpleDateFormat("yyyy-MM-dd");
            Date date = dateForm.parse(tempTime);
            cal.setTime(date);
        } catch (Exception e) {
            // TODO: handle exception
        }

        int currentDate = cal.get(Calendar.DATE);   // 获取当前日期，在日历中进行标注
        int maxDate = cal.getActualMaximum(Calendar.DATE); // 一月中的最大天数

        cal.set(Calendar.DATE, 1); // 设置时间为本月的第一天

        System.out.println("日\t一\t二\t三\t四\t五\t六");

        // 打印若干个空白
        for (int j = 1; j < cal.get(Calendar.DAY_OF_WEEK); j++) {
            System.out.print("\t");
        }

        for (int i = 1; i <= maxDate; i++) {
            if (i == currentDate) {
                System.out.print("*");
            }
            System.out.print(i + "\t");

            if (cal.get(Calendar.DAY_OF_WEEK) % 7 == 0) {
                System.out.println();
            }

            cal.add(Calendar.DATE, 1);
        }
    }
}

2. 遍历一个文件下的目录结构

import java.io.File;

public class TestFile {

    public static void main(String[] args) {
        File myFile = new File("E:\\JAVA\\a");

        printFile(myFile, 0);
    }

    public static void printFile(File f, int level) {
        for (int i = 0; i < level; i++) {
            System.out.print("-");
        }

        System.out.println(f.getName());

        if (f.isDirectory()) {
            for (File f2 : f.listFiles()) {
                printFile(f2, level + 1);       // 调用递归函数
            }
        }
    }
}

最终的打印结果如下：

a
-1
--a
--b
-2
--c
-3
--d
---e

3. 异常处理机制

在Java中，对于异常的处理还是非常常见的，特别是在IO操作的时候，这个时候需要我们程序员手动来捕获异常并进行处理。一般的异常处理机制包括以下语句：

try {
    ...
    ...
} catch (FileNotFoundException e) {
    ...
} catch (IOException e) {
    ...
} finally {
    ...
}

一些可能出现异常的语句，我们需要放到try语句块中，然后在catch语句块中来捕获可能出现的异常，这个时候要注意一下，一个try语句是可以对应多个catch语句的，即一个代码块可以捕获多个异常进行处理。无论能够捕获到异常，finally语句都会执行。在进行IO操作的时候，我们在finally语句中执行关闭文件流的操作，或者在数据库连接中，释放数据库连接等。下面给出一个异常捕获的实例：

public static void main(String[] args) {
    FileReader file = null;
    try {
        file = new FileReader("E:\\JAVA\\fengzhen.txt");
        System.out.println((char) file.read());
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        System.out.println("不管是否捕获异常，我都会执行");

        try {
            file.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

除了上面的捕获异常方式，我们还可以在定义方法的时候通过 throw 语句来抛出异常，然后在调用方法的时候进行捕获异常，实例如下：

public class TestException {

    public static void main(String[] args) {
        // 调用方式的时候进行异常的捕获
        try {
            System.out.println(readFile());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 定义方法的时候，抛出异常
    public static char readFile() throws FileNotFoundException, IOException {
        FileReader file = null;
        file = new FileReader("E:\\JAVA\\fengzhen.txt");
        return (char) file.read();
    }
}

在类的继承中，如果子类对父类中的方法进行重写的时候抛出异常，这个时候要注意子类声明中的异常范围不能超过父类声明中的异常范围，即：