Java 考证辅导课程回顾


Java 异常处理机制

1.1 异常的概念 1.程序出错或崩溃等意外情形为异常（Exception）。 2.三类程序错误：
编译错误：特别是初学阶段//盲猜红色波浪线
运行时错误：运行环境 JVM 出错；内存不足等。
逻辑错误：除数为 0；数组下标越界；打开不存在的文件；使用空指针等。

数组下标越界异常示例：

1
2
3
4
5
6
7
8
public class Error {
    public static void main(String[] args) {
        int[] value=new int[]{1,2,3,4};
        for (int i=0;i<=value.length;i++) {
            System.out.println(value[i]);
        }
    }
}

很明显的下标越界返回：
Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4 at com.company.phase04.Error.main(Error.java:7)
首先，编译程序不检查逻辑错误，逻辑错误与程序员有关。
其次，采用判断语句方式进行异常处理比较困难，对程序员要求高，代码量大。较好的处理方式是使用异常机制。
先来看看 Java 异常的继承关系 ↓

1
2
3
4
5
6
                  Throwable
                     ↑
        Error   →         ←    Exception
(不受检查异常，等死那种)             ↑
                RuntimeException       IOException等
(不受检查异常，运行异常[逻辑异常？])      (受检查异常，编译异常)

其实除了上面还有下面这些继承接口：
ThreadDeath、IOError、VituallMachineError 都继承自 Error；
SQLException 继承自 Exception；
ArithmeticException、ClassCastException、NullPointerException 继承自 RuntimeException。
检查性异常：要么通过 rey-catch 进行捕获，要么用 throws 抛出，否则编译无法通过。
1.1.2 异常的分类
Throwable 类：异常基类，所有异常都继承自 java.lang.Throwable 类，两直接子类。
Error 类：严重错误，程序员无须处理此类异常。
Exception 类：同 Java 应用程序抛出和处理的非严重错误。分为：
（1）运行时异常，即 RuntimeException 类：程序员不做处理，程序也通过编译。如除数为 0 异常。
（2）检查异常，又称为非运行时异常，程序员必须在编程时进行处理，否则就无法编译通过。检查异常示例：

1
2
3
4
5
6
7
8
9
10
package com.company.phase04;
import java.io.FileInputStream;
public class Error {
    public static void readFile(String fileName){
        FileInputStream file = new FileInputStream(fileName);//肯定报红的
    }
    public static void main(String[] args) {
        readFile("aa.txt");
    }
}

1.2 异常的捕获及处理
发生异常后如何操作？ 1.立即处理：捕捉异常并处理。 //try-catch 2.暂不处理：抛出并由上一级去处理。//throws
最上一级就到虚拟机那边了。
1.2.2 异常的两种处理方式
(1) 捕捉异常并处理
try{…}catch{…}
try 段为可能出异常的语句。
catch 段 e 引用异常实例。
finally 段，有无异常发生都要执行，经常用于回收资源。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.company.phase04;

public class Error_02 {
    public static void main(String[] args) {
        String [] monad = {"李云龙","马化腾","马云","王健林"};
        try {
            for (int i=0;i<=monad.length;i++){
                System.out.println(monad[i]);
            }
        }
        catch (RuntimeException e){
            System.out.println(e.toString());
        }
        catch (Exception e){
            e.printStackTrace();//printStackTrace的意思是打印出异常
        }finally {
            System.out.println("显示完毕");
        }
    }
}

除了 printStackTrace 外还可以 System.out.print(e)，不过显示的内容没前者深。
也有说用 printStackTrace 会导致锁死的，用 logger.error,再说。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.company.phase04;
import java.io.FileInputStream;
import java.io.IOException;

public class Error_03 {
    public static void main(String[] args) throws IOException {
        FileInputStream file = null;
        try {
            file = new FileInputStream("C:\\Users\\Administrator\\IdeaProjects\\Debug01\\src\\aa.txt");   //绝对路径就是好
            int b =file.read();   //从输入流中读取一个数据字节给b
            while (b!=-1){
                System.out.print((char)b);
                b = file.read();
            }
        }catch (IOException e){   //把捕捉到异常往这塞
            e.printStackTrace();  //输出异常的详情情况
        }finally {
            if (file!=null){
                file.close();     //关闭流链接并释放资源
}}}}

InputStream 中的 read，读取一个数据字节并返回下一个数据字节，如果到了末尾就返回-1。
close()方法用于关闭此 FileInputStream 并释放与此流链接的所有系统资源。
操作的类如果实现了 AutoCloseable 接口，就可以在 try 语句块退出时自动调用 close 方法关闭资源。
FileInputStream->InputStream->Closeable->AutoCloseable
(2)抛出并由上一级去处理
throws

1
2
3
4
5
6
7
8
9
package com.company.phase04;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class Error_01 {                  //↓没错就是它
    public static void main(String[] args) throws FileNotFoundException {
        FileInputStream file = new FileInputStream("aa.txt");
    }
}

(3))练习一下 1.计算圆的面积，半径不能为零和负数。

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.company.phase04;

public class Error_04 {
    public static void main(String[] args) {
        double s = 0;
        int r= -10;
        s=calculate(r);}
    public static double calculate(int r){
        try {
            if (r<=0) throw new RuntimeException(); //不加s。抛出,新增,异常
        }catch(Exception e){
            e.printStackTrace();
        }return Math.PI*r*r;}}

2.求平均数，参数不能为负数，如果参数存在负数，则抛出运行时异常，异常消息为”参数为负数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.company.phase04;
public class Error_05 {
    public static void main(String[] args) {
        double s = 0;
        s = avg(1,7,6,3,4);
        System.out.println(s);
    }
    public static double avg(double... data) {
        double sum = 0;
            for (double i : data){
                if (i<=0) {
                    throw new RuntimeException("参数不能小于零");
                }
                sum+= i;
            }
            return sum/data.length;
    }
}

3.参考 PPT 代码，变成读取自定义文本文件，并显示其文本内容。√ (在上面) 4.要求用户输入数字，捕获并处理用户输入错误的异常。//自制的，个人感觉良好

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.company.phase04;
import java.util.Scanner;
public class Error_06 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.next();
        run(str);//很正常的获取用户输入的参数
    }
    public static void run(String str){
        char[] value = str.toCharArray();//无视空格，把所有值都一位一位的传输给value，当然是char类型也就是ASCLL型
        for (char i:value){
            if (i<48||i>58){
                throw new RuntimeException("参数有误:"+i);
            }
        }
        System.out.println("没问题");//很简单吧
    }
}

————————第一课到此结束————————
第二节课没去，第三节课是代课，国信蓝桥学习。

细讲 Set 集合(HashSet)

Set 接口主要有两个实现类 HashSet 和 TreeSet。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.* ;

public class TestSet {
    public static void main(String[] args) {
        //创建一个HashSet对象，存放学生姓名信息
        Set nameSet = new HashSet();
        nameSet.add("王云");
        nameSet.add("刘静涛");
        nameSet.add("南天华");
        nameSet.add("雷静");
        nameSet.add("王云");        //增加已有的数据元素
        System.out.println("再次添加王云是否成功：" + nameSet.add("王云"));
        System.out.println("显示集合内容：" + nameSet);
        System.out.println("集合里是否包含南天华：" + nameSet.contains("南天华"));                                               //查集合是否存在该值
        System.out.println("从集合中删除\"南天华\"...");
        nameSet.remove("南天华");
        System.out.println("集合里是否包含南天华：" + nameSet.contains("南天华"));
        System.out.println("集合中的元素个数为：" + nameSet.size());
    }
}

在终端输入以下命令运行此程序。

1
2
javac TestSet.java
java TestSet   //就讲一次,主要是蓝桥实验楼要这样做

运行结果：
在次添加王云是否成功：false
显示集合内容：[雷静，王云，刘静涛，南天华]
集合里是否包含南天华：true
从集合中删除”南天华”…
集合里是否包含南天华：false
集合中的元素个数为：3

HashSet 判断重复元素是依靠其底层引入的 hashcode。
hashcode 最初定义在 Object 类中，如果两个对象相等，那么这两个对象的 hashcode 值相同，因此根据逆否定理可知如果两个对象的 hashcode 值不同，那么这两个对象不相等。
但是如果两个对象的 hashcode 值相同，则这两个对象可能相同，也可能不同，这就要引入 equals()来比较了。

向 HashSet 增添元素时，HashSet 会计算该元素的 hashcode，根据 hashcode 是否唯一来操作。
如果 hashcode 值与 HashSet 集合中的某个元素的 hashcode 值相同，那么 HashSet 就会进一步调用 equals()方法来判同，如果相同就会忽略掉新增元素。
可见这类做法是很严格的，跟 Hash 打上关系都会这样？

因此，当使用 HashSet 存放某个自定义对象时，就得在这个对象的定义类中重写 hashcode()和 equals()方法。

hashcode 是对象的映射地址。
equals()用于比较连个对象。
重写时，hashcode()需要自定义”映射地址”的映射规则。
equals()方法需要自定义对象的”比较规则”。
一般而言，映射规则和比较规则都需要借助于对象的所有属性进行计算。
下面看其方法的一个示例：

在看实例之前先看看 instanceof 二元操作符，类似于== < > 之类的。
它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.ArrayList;
import java.util.Vector;

public class Main {

public static void main(String[] args) {
   Object obj = new ArrayList();
      ObjectClass(obj);
   }
   public static void ObjectClass(Object o) {
      if (o instanceof Vector)
      System.out.println("对象是 java.util.Vector 类的实例");
      else if (o instanceof ArrayList)
      System.out.println("对象是 java.util.ArrayList 类的实例");
      else
      System.out.println("对象是 " + o.getClass() + " 类的实例");
   }
}

回来看示例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public class Vehicle {  //自定义一个Vehicle类/还是对象？

    private String name;   //成员属性如下
    private int oil;

    public Vehicle() {}   //无参构造
    public Vehicle(String name, int oil) {//有参构造
        this.name = name;
        this.oil = oil;
    }

    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public int getOil() {return oil;}
    public void setOil(int oil) {this.oil = oil;}
    //上面什么初始化调用啥的格式也懒得讲了

    @Override  //覆写equals方法
    public boolean equals(Object obj) {
        if (this == obj) {  //这里的this指向的是对象也就是Vehicle
            return true;    //地址比较对就对没毛病
        }

        if (obj instanceof Vehicle) {//如果obj确实是Vehicle的实例
            Vehicle vehicle = (Vehicle) obj; //那就强制转换成Vehicle格式并传递？
            if (this.name.equals(vehicle.getName()) && this.oil == vehicle.getOil()) {
                return true;//然后再把传输的数据和库中的数据比较
            }
        }
        return false;
    }

    // 用对象的所有属性值作为hashcode的计算因子,设计数学计算公式不是我们干的，
    // 目的是尽可能不重复hashcode
    @Override
    public int hashCode() {
        int result = 0;
        result = result * 31 + name.hashCode();
        result = result * 31 + oil;
        return result;
    }
    //他说还有这种方法(简易)
    //     @Override
    //     public int hashCode() {
    //     return name.hashCode() & oil;
    // }
}

运行结果：true、true、false

细讲 Set 集合(TreeSet)

TreeSet 类在实现了 Set 接口的同时，也实现了 SortedSet 接口，是一个具有排序功能的 Set 接口类。
TreeSet 集合中的元素默认是按照自然升序排列，并且 TreeSet 集合中的对象需要实现 Comparable 接口。

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.Set;
import java.util.TreeSet;

public class TestTreeSet{
    public static void main(String[] args){
        Set ts = new TreeSet();
        ts.add("王云");
        ts.add("刘静涛");
        ts.add("南天华");
        System.out.println(ts);   //简单的使用
    }
}

运行结果:[刘静涛, 南天华, 王云]
可见 String 类会进行字典顺序的排序，String 类实现了 Comparable 接口。

比较器

JDK 提供了 Comparable 和 Comparator 两个接口，都可以用于定于集合元素的排序规则。
若想定义自己的排序方式，简单的方法是让加入 TreeSet 集合中的对象所属的类数显 Comparable 接口来实现 compareTo(object o)方法，它也只有这一个方法，达到排序的目的。
这里的 compareTo(object o)和传统的 compareTo()方法似乎是有区别的。。
//compareTo(object o)是 Comparable 接口唯一的方法返回整数
先来看看菜鸟教程找到的 compareTo()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String args[]) {
        String str1 = "Strings";
        String str2 = "Strings";
        String str3 = "Strings123";

        int result = str1.compareTo( str2 );
        System.out.println(result);  //0

        result = str2.compareTo( str3 );
        System.out.println(result);  //-3 你以为就这样就给骗了

        result = str3.compareTo( str1 );
        System.out.println(result);  //3
    }

首先，返回值是整型。
其次，优先是比 ASCLL 值，怎么比？
所选字符串的首字符与被比字符串的首字符比，如果一致就比第二个，比下去。
不一致的返回相差的 ASCLL 码值，遇到长度不一样但是前面值都一样的情况就返回长度差距值。

回到正题。
来个需求，学生对象有两个数学，对应学号与姓名。希望将这些学生对象加入 TreeSet 集合后，按照学号大小从小到大进行排序，如果学号相同再按照姓名自然排序。

来看看实例怎么做到的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
import java.util.Set;
import java.util.TreeSet;
class Student implements Comparable {
    int stuNum = -1;
    String stuName = "";

    Student(String name,int num){
        this.stuNum = num;
        this.stuName = name;
    }  //初始化与赋值先不说

    public String toString(){
        return "学号为：" + stuNum + "的学生，姓名为：" + stuName;
    }  //不管是print打印会调用，不知道为啥下面的Object o也会自动调用
       //再其次是封装到TreeSet里的对象名称也会调用toString,没写toString会调用超类里的toString ?
    public int compareTo(Object o){
        Student input = (Student) o;  //先搞清楚,o似乎是上次代码运行过的对象，如果是第一次运行那么就调用最初自己。
        int res = stuNum > input.stuNum?1:(stuNum==input.stuNum)?0:-1;
               //这个stuNum值是来自new给过来的参数 也就是上面初始化拿来的
        if(res==0){
            res = stuName.compareTo(input.stuName);//不是递归调用是另一种用法
        }                         //↑这个input可不能写(Object o).stuName
        return res;//这个返回整数是真的离谱 0是等于 正数是大于 负数是小于
    }   //如果是"南天华,3"取进来对比"王云，1"就是大于，那么TreeSet疑似会调整下标，就[0][1][2]这种
}//我最下面的"张平，1"就是个例子，原本是"张平，3"，先说1，和上次对象"刘静涛，2"比，小于和更小的王云比
//如果是学号相同的情况下，就用另一种compareTo方法比，从首到尾，看ASCLL值，反正返回的是正负数来决定先后顺序
//如果是长度不同但是前面字符相同的情况，也会根据字符串长短返回多出或者少于的位数的值，反正也是正负整数。
//↑的另一种解释
//根据二叉树的排序进行比较，先取个值放第一个，再大的放右边小的放左边，相同情况再定义，看来是的TreeSet嘛，树，有序性
class TestTreeSet2 {
    public static void main(String[] args) {
        //用有序的TreeSet存储学生对象
        Set stuTS = new TreeSet();
        stuTS.add(new Student("王云", 1));  //new出来的是调用初始化，然后返回帧跑add方法，又是一帧
        stuTS.add(new Student("南天华", 3));//然后莫名调用compareTo方法,先拿上次的对象比，再根据res值调整
        stuTS.add(new Student("刘静涛", 2));//有趣的是compareTo(Object o)与TreeSet内的对象的名字都是经过toString印刷出来的
        stuTS.add(new Student("张平", 1));//只能说nb

        for(Object stu:stuTS)
            System.out.println(stu);
    }
}

来看外援优化版

1
2
3
4
5
6
7
8
9
class Student implements Comparable<Student> {...}//先是泛型的使用，表明compareble接口是Student类型的
//然后来看实现接口后的重写方法，有些情况下@Override不写也行
public int compareTo(Student o) {
        int res = this.stuNum - o.stuNum;  //直接对俩值加减比较搞
        if (res == 0) {
            res = this.stuName.compareTo(o.stuName);
        }
        return res;
    }

Comparable 接口与 conpareTo() 内部比较器

如果程序员想定义自己的排序方式，一种简单的方法就是让加入 TreeSet 集合中的对象所属的类实现 Comparable 接口，通过实现 compareTo(Object o)方法，达到排序的目的。

Comparable 接口实现了在 TreeSet 集合中的自定义排序。这种方法是通过集合元素重写 compareTo(Object o)[笑死了确定不是 T?]方法定义排序规则的。因为是在类内部实现比较，所以也通常将 Comparable 称为内部比较器。

Conparetor 接口与 compare() 外部比较器

Comparator 可以理解为一个专用的比较器，当集合中的对象不支持自比较或者自比较的功能不能满足程序员的需求时，就可以写一个实现 Comparator 接口的比较器来完成两个对象之间的比较，从而实现按比较器规则进行排序的功能。例如要比较的对象是 JDK 中内置的某个类，而这个类又没有实现 Comparable 接口，因此我们是无法直接修改 JDK 内置类的源码的，因此就不能通过重写 compareTo(Object o)方法来定义排序规则了，而应该使用 Comparator 接口实现比较器功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import java.util.*;
//定义一个姓名比较器
class NameComparator implements Comparator {
//实现Comparator接口的compare()方法
    public int compare(Object op1, Object op2) {
        Student eOp1 = (Student)op1;
        Student eOp2 = (Student)op2;//可以改Studentd的，改泛型
        //通过调用String类的compareTo()方法进行比较
        return eOp1.stuName.compareTo(eOp2.stuName);
    }
}
//定义一个学号比较器
class NumComparator implements Comparator {
    //实现Comparator接口的compare()方法
    public int compare(Object op1, Object op2) {
        Student eOp1 = (Student)op1;
        Student eOp2 = (Student)op2;
        return eOp1.stuNum - eOp2.stuNum;
    }
}
public class TestComparator
{
    public static void main(String[] args)
    {
        //用LinkedList存储学生对象
        LinkedList stuLL = new LinkedList();
        stuLL.add(new Student("王云",1));
        stuLL.add(new Student("南天华",3));
        stuLL.add(new Student("刘静涛",2));
        //使用sort方法，按姓名比较器进行排序
        Collections.sort(stuLL,new NameComparator());
        System.out.println("***按学生姓名顺序输出学生信息***");
        Iterator it = stuLL.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        //使用sort方法，按学号比较器进行排序
        Collections.sort(stuLL,new NumComparator());
        System.out.println("***按学生学号顺序输出学生信息***");
        it = stuLL.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}
//定义学生对象，未实现Comparable接口
class Student{
    int stuNum = -1;
    String stuName = "";
    Student(String name, int num) {
        this.stuNum = num;
        this.stuName = name;
    }
    public String toString() {
        return "学号为：" + stuNum + "的学生，姓名为：" + stuName;
    }
}

Collection 工具类

静态类，可以直接 Collection.sort();这样调用。
这里的 sort(List list,Comparetor c);
如果就填个 list，list 内存放 obj 对象，就是根据 obj 所属类重写内部比较器 Comparable 中的 compareTo()方法定义的。
至于后面的 Comparetor c 可以自定义规则放上去。
shuffle(List list)方法可以随机排序。
reverse(List list)可以翻反转 list 集合中数据元素的顺序。

提一句话：关于 toString 与 compareTo/compare 自动调用问题。

toString 会在打印的时候自调用(print)
compareTo 之类的，疑似在创建/构造对象的时候回自调用。

2021/10/26 晚来的字符流字节流缓冲流~二进制流

不用看，都是自学的，老师讲的什么垃圾。

啥是输入流输出流？
流是一种 FIFO 的数据结构。//先进先出
输入流就是数据输入到内存，输出流就是将内存中的数据输出出去。
一般情况都会要个 buf 当缓冲区，buf 这个缓冲区大小可以自定，让数据从文件一块块的挖到内存里。

按流向分：
·输入流：java.io.InputStream 抽象类 /Reader
·输出流：java.io.OutputStream 抽象类 /Writer 这两者是字符流的输入与输出
·其他流：如缓冲流，二进制流什么的
按处理单元分：
·字节流：FileInputStream/FileOutputStream|输入字节流/输出字节流。
带 Stream 的可以说就是字节流了。
字节流就是将内容转换为二进制进行传输，1 字节=8b/二进制，也就是 8 位通用字节流，
因为二进制可以传输任何类型的数据，因此字节流也可以传输任何类型的数据。//比如复制 jpg 为 txt 后缀，再自己改 txt 后缀为 jpg 也可以，
系统的后缀其实没啥用，可以说是只是打开方式的一种，比如画图板啥的。
·字符流：Reader/Writer|输入字符流/输出字符流。
真实使用不一定就这两者，也可能会用到它们的子类，反正也是字符流。
字符流是 16 位的 unicode 字符流(只处理字符，如文本文件)
·其他流//暂时不知

实例：利用字符流进行文本复制，并更改改标签内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package com.company.phase06;

import java.io.*;

public class FileCopyCharactor {
    public static void main(String[] args) throws IOException {
        Reader reader = null;
        Writer writer = null;   //不往外写，到时候关闭不了流，即close不能，流不出去，导致复制出来的文本是空的
        try {
            reader = new FileReader("d:/个人介绍.txt");      //流入文件
            writer = new FileWriter("d:/个人介绍(魔改).txt");//流出文件
            char[] buf = new char[4];//字符流就是要char字符来做缓冲区，字节流就是用byte字节来做缓冲区
            int len = -1;//标记，看后面
            StringBuffer sb = new StringBuffer(); //如果用 String str = ""的话，不好处理最后溢出覆盖问题
            while((len = reader.read(buf)) != -1){//文件read空了本来就是return -1 的吧。
            //实测输出的len值为 44444443，也就是说运行一次read，就会将文本内容刷进buf缓存区里，而return的值是read到的字符串数量
                sb.append(buf,0,len);//0~len位，len在最后是3，所以写入索引最后就能避免因为缓冲区刷不掉而导致的文本复制错误问题
            }
            System.out.println(sb);
            String content = sb.toString();//刷成字符串,虽然好像没啥变化的样子，总之就当是赋值
            content = content.replace("{name}","乐乐侠")//replace方法能将对应标签替换
                    .replace("{what}","拯救世界")//这边用链式的方法写入
                    .replace("{aihao}","世界和平");//一定要写 content = ······，不然替换个寂寞

            writer.write(content);//流了，但没完全流|好像可以用writer.flush真的刷出去
            System.out.println(content);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            if (reader!=null) reader.close();  //管道不关，流不出去，性能无法释放，不过一般会搭配if语句用
            if (writer!=null) writer.close();  //这些关闭语句一般也是写finally里的
        }
    }
}

运行结果：
你好，我是{name},目前正在{what},个人爱好{aihao}
你好，我是乐乐侠,目前正在拯救世界,个人爱好世界和平
d 盘目录下也多了个文件，写的就是 ↑ 这玩意儿

关于缓冲流。就是自带一个 buf，自带缓冲。在你拿捏不定缓冲区大小的时候可以使用。
二进制流就是 BufferadReader 改 DataInputStream 这样，其他基本上都差不多,也就是将字节流转换为二进制流，其他各种流原理都差不多，先输入再输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.company.phase06;

import java.io.*;

public class FileCOpyecharactorBuffered  {
    public static void main(String[] args) throws IOException {
        Reader reader = null;
        Writer writer = null;
        BufferedReader br = null;
        BufferedWriter bw = null;//写外面好关
        try {
            reader = new FileReader("d:/个人介绍.txt");
            writer = new FileWriter("d:/完整介绍.txt");
            br = new BufferedReader(reader);
            bw = new BufferedWriter(writer);//这种自带缓冲流就是这样写的

            String line = null;//行
            StringBuffer sb = new StringBuffer();//容器

            while((line = br.readLine()) != null){//行行读
                sb.append(line);//行行写
                sb.append((char)13);}//机智如我，加个回车解决换行问题

            String content = sb.toString();
            writer.write(content);//写出去
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally{
            if (bw!=null) bw.close();//1.先出
            if (br!=null) br.close();//1.后入
            if (writer!=null) writer.close();//2.先外
            if (reader!=null) reader.close();//2.再内
            //bw[外] = new BufferedWriter(writer[包在里面的内]);
        }
    }
}

2021/11/4 反射

反射：
反射机制是在【运行状态】中：
对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意一个方法和属性；
反射提供的功能：
在运行时判断任意一个对象所属的类；
在运行时狗仔任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法；
生成动态代理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.company.phase07;

public interface MyInterface {
    void interfaceMethod();
}
//上面是没啥用的接口
//下面可能还有加一些私有方法啊，什么方法,然后再多实现些接口
package com.company.phase07;

public class Person implements MyInterface{
    private int id;
    private String name;
    private int age;

    public Person(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Person(int id) {this.id = id;}
    public Person() {}

    public int getId() {return id;}
    public void setId(int id) {this.id = id;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public int getAge() {return age;}
    public void setAge(int age) {this.age = age;}

    @Override
    public void interfaceMethod() {
        System.out.println("interface Method.....");
    }//肯定要覆写下接口的方法，随便搞

    public void staticMethod(){
        System.out.println("static Method.....");
    }//静态的方法，反正也一样
}

接下来才是重点
关于 Class和 Class<?>的区别，
T：表示确定是 java 类
?：不确定是 java 类，没准是接口呢

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.company.phase07;//这个类名，com目录下的company目录下的phase07

public class ReflectDemo01 {
    public static void main(String[] args) {
        //获取反射对象（反射入口）：Class，
        //1、Class.forName(全类名) 2、XX.class 3、对象.getClass()
        try {                                  //↓要注意了，对应包下的对应的类
            Class<?> perClass1 = Class.forName("com.company.phase07.Person");
            System.out.println(perClass1);//forName这种方法要做纠错处理
        } catch (ClassNotFoundException e) {

            e.printStackTrace();//不过说是推荐用这个方法,好像是可以加载class类
        }

        //类名.class，拿反射入口
        Class<?> perClass2 = Person.class;
        System.out.println(perClass2);

        //对象.getClass()，整对象就要对象
        Person person = new Person();//new一个要搞的东西的对象
        Class<?> perClass3 = person.getClass();
        System.out.println(perClass3);
    }
}
//以上方法都需要容器Class<?> perClass = null

运行结果:
class com.company.phase07.Person
class com.company.phase07.Person
class com.company.phase07.Person

三者相等皆为 true。

接下来，通过反射来获取方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void demo02(){
        //只要是反射就必须要拿入口
        Class<?> per = null;
        try {
            per = Class.forName("com.company.phase07.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //来拿方法吧可以拿private和publick
        //先来拿公共方法
        Method[] methods = per.getMethods(); //methods翻译：方法;方法很多，数组存恒河里
        for (Method method:methods) {
            System.out.println(method);
            //public java.lang.String com.company.phase07.Person.getName()
            //讲的很清楚 String就是在lang包里的，getName()也是，只不过我们平时简写了
            //拿的方法很多，父类的方法也一并获取了，这里就不拿出来了，占行
            //但是拿不到private的，这就是公共方法
            //总结：本类以及父类、接口中的所有方法，符合访问修饰符规律
        }
    }

接下来获取所有的接口，java 单继承，多实现

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void demo03(){
        //获取所有的接口，java单继承，多实现
        Class<?> per = null;
        try {
            per = Class.forName("com.company.phase07.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Class<?>[] interfaces = per.getInterfaces();
        for (Class<?> inter:interfaces){
            System.out.println(inter);
        }
    }

运行结果：
interface com.company.phase07.MyInterface
interface com.company.phase07.MyInterface2

获取所有的父类

1
2
3
4
5
6
7
8
9
10
public static void demo04() {
    Class<?> per = null;
    try {
        per = Class.forName("com.company.phase07.Person");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    Class<?> superclass = per.getSuperclass();//如出一辙
    System.out.println(superclass);
}

运行结果：
class java.lang.Object
它的父类就是 object

获取所有的构造方法

1
2
3
4
5
6
7
8
9
10
11
12
public static void demo05() {
    Class<?> per = null;
    try {
        per = Class.forName("com.company.phase07.Person");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    Constructor<?>[] constructors = per.getConstructors();//这里要搞构造函数类型。。。
    for (Constructor<?> constructor:constructors){
        System.out.println(constructor);
    }
}

运行结果:
public com.company.phase07.Person()
public com.company.phase07.Person(int)
public com.company.phase07.Person(int,java.lang.String,int)

获取所有的属性

1
2
3
4
5
6
7
8
9
10
11
12
public static void demo06() {
    Class<?> per = null;
    try {
        per = Class.forName("com.company.phase07.Person");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    Field[] fields = per.getFields();
    for (Field field:fields){
        System.out.println(field);
    }
}

运行结果：public java.lang.String com.company.phase07.Person.desc
这边又要在 Person 里加 public 类型的属性，不然 private 的可拿不到

现在讲如何获取 private 修饰的方法或者属性
其实很简单，方法改成 xx.getDeclaredMethods 或 xx.getDeclaredFields 就行
重点是 Decleared。

接下来获取当前反射所代表类(接口)的对象(实例)[看起来有点重要]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void demo08() {
    Class<?> per = null;
    //CLass<?> perClass = null;给下面注释用的
    try {
        per = Class.forName("com.company.phase07.Person");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }//常规操作，拿反射入口
    Object instance = null;
    try {
        instance = per.newInstance(); //Instance翻译：实例
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    Person person = (Person) instance;//Object类嘛，这边强转
    person.interfaceMethod();//确实可以调用
    //简便的写法就是Person per = (Person) perClass.newInstance()
    //上面的perClass就是给↑这个用的
}

运行结果：interface Method…..

newInstance()和 new()区别

1、两者创建对象的方式不同，前者是实用类的加载机制，后者则是直接创建一个类：

2、newInstance 创建类是这个类必须已经加载过且已经连接，new 创建类是则不需要这个类加载过

3、newInstance: 弱类型(GC 是回收对象的限制条件很低，容易被回收)、低效率、只能调用无参构造，new 强类型（GC 不会自动回收，只有所有的指向对象的引用被移除是才会被回收，若对象生命周期已经结束，但引用没有被移除，经常会出现内存溢出）

@SuppressWarnings(value={“all”})

这样可以抑制来自编译器的警告，可以跳过检查，()里面的值与参数可以更改

通过反射来操作对象、属性与方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public static void demo01() throws IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
        Class<?> perClass = null;//拿反射入口
        try {
            perClass = Class.forName("com.company.phase07.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        Person per = (Person) perClass.newInstance(); //通过反射入口拿对象
        Field field = perClass.getDeclaredField("id");//通过反射入口属性
        Method method = perClass.getDeclaredMethod("privateMethod",null);//通过反射入口拿方法，一样的道理,这里是无参
        field.setAccessible(true);//修改修饰符的规则(修改属性的访问权限)，哪怕是private也可以拿来用,但是如果是public类型，哪怕改false也可以用,下面一样的道理
        field.set(per,1);//差不多可以理解为pre.setId(1);对象.方法(值) 这里1,2,3的顺序改为2,1,3
        System.out.println(per.getId());
        //==============================
        method.setAccessible(true);
        method.invoke(per,null);//pre.privateMethod();这么理解，那个null就是参数

        Method method2 = perClass.getDeclaredMethod("privateMethod2",String.class);//这里反射类型是String类
        method2.setAccessible(true);
        method2.invoke(per,"张三");
        //要记得方法是会被调用的
    }

运行结果：
1
private Method…..
private Method…..张三

通过反射来操作构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//先来复习下
//        Constructor<?>[] constructor = perClass.getConstructors();//拿全部公共类型的构造方法
//        for (Constructor constructorr:constructor){
//            System.out.println(constructorr);
//        }

//        Constructor<?>[] constructor1 = perClass.getDeclaredConstructors();//拿全部各种类型的构造方法
//        for (Constructor constructorr:constructor1){
//            System.out.println(constructorr);
//        }

        Constructor<?> constructor = perClass.getConstructor(int.class);//带参的,拿指定参数的构造方法
        //有个细节，Integer这种包装类和int不是一个东西,他们在↑这里不能互相转换来拿，所以只能门当户对来搞

//        Constructor<?> constructorr = perClass.getDeclaredConstructor(String.class);//无视修饰符规则拿
//        System.out.println(constructorr);

        Person per = new Person(12);//这里只是对比下，好像没啥区别
        System.out.println(per.getId());

        Person perr = (Person)constructor.newInstance(12);//因为上面反射的是int类的所以这里是要填有参
        System.out.println(perr.getId());

        Constructor<?> constructor3 = perClass.getConstructor();//无参就这样写，可以是null
        Person perrr = (Person)constructor3.newInstance();
        System.out.println(perrr);

Properties 类的使用

Properties 类继承了 Hashtable，以 Map 的形式进行放置值， put(key,value) get(key)。
主要的方法有：
properties()构造方法；
setProperties(String,String)设置值；/可以理解为 key 和 value
load(Reader/LineReader/InputStream)加载文件；
store(OutputStream/Write,String)保存到文件；
loadFromXML(InputStream)加载 xml 文件；
storeToXML(OutputStream,String,String)保存到 xml 文件；
getproperty(String,或再加个 String)获取属性；
propertyNames()输出 key 值；
stringPropertyNames()输出 key 值；
list(PrintStream/PrintWriter)输出打印；

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

年轻人打算写博客玩<br><br>诶~没错就是玩<br><br>玩nm！