【JavaSE五天速通｜第五篇】高级篇

适合有其他语言基础想快速入门JavaSE的。用的资料是 Java入门基础视频教程 ，从中摘取了笔者认为与其他语言不同或需要重点学习的内容

此篇中的多线程、反射、动态代理都是重点内容，这里讲的有些浅，在深入理解后，后续继续背八股

day09 字符集、IO流（一）

一、字符集

所谓编码，就是为一个字符编一个二进制数据

美国人常用的字符有英文字母、标点符号、数字以及一些特殊字符，这些字符一共也不到128个，所以他们用1个字节来存储1字符就够了。 美国人把他们用到的字符和字符对应的编码总结成了一张码表，这张码表叫做ASCII码表（也叫ASCII字符集）。

其实计算机只在美国用是没有问题的，但是计算机慢慢的普及到全世界，当普及到中国的时候，在计算机中想要存储中文，那ASCII字符集就不够用了，因为中文太多了，随便数一数也有几万个字符。

于是中国人为了在计算机中存储中文，也编了一个中国人用的字符集叫做GBK字符集，这里面包含2万多个汉字字符，GBK中一个汉字采用两个字节来存储，为了能够显示英文字母，GBK字符集也兼容了ASCII字符集，在GBK字符集中一个字母还是采用一个字节来存储。

1.2 汉字和字母的编码特点

需要我们注意汉字和字母的编码特点：

• 1. 如果是存储字母，采用1个字节来存储，一共8位，其中第1位是0
  2. 如果是存储汉字，采用2个字节来存储，一共16位，其中第1位是1
     
     当读取文件中的字符时，通过识别读取到的第1位是0还是1来判断是字母还是汉字
• 如果读取到第1位是0，就认为是一个字母，此时往后读1个字节。
• 如果读取到第1位是1，就认为是一个汉字，此时往后读2个字节。

1.3 Unicode字符集

为了解决各个国家字符集互不兼容的问题，由国际化标准组织牵头，设计了一套全世界通用的字符集，叫做Unicode字符集。在Unicode字符集中包含了世界上所有国家的文字，一个字符采用4个自己才存储。

在Unicode字符集中，采用一个字符4个字节的编码方案，又造成另一个问题：如果是说英语的国家，他们只需要用到26大小写字母，加上一些标点符号就够了，本身一个字节就可以表示完，用4个字节就有点浪费。

于是又对Unicode字符集中的字符进行了重新编码，一共设计了三种编码方案。分别是UTF-32、UTF-16、UTF-8; 其中比较常用的编码方案是UTF-8

下面我们详细介绍一下UTF-8这种编码方案的特点。

1.UTF-8是一种可变长的编码方案，工分为4个长度区
2.英文字母、数字占1个字节兼容(ASCII编码)
3.汉字字符占3个字节
4.极少数字符占4个字节

上图中怎么知道中间三个字符是需要连在一起解码的呢？——右侧的UTF-8编码规则

1.4 字符集小结

ASCII字符集：《美国信息交换标准代码》，包含英文字母、数字、标点符号、控制字符特点：1个字符占1个字节GBK字符集：中国人自己的字符集，兼容ASCII字符集，还包含2万多个汉字特点：1个字母占用1个字节；1个汉字占用2个字节Unicode字符集：包含世界上所有国家的文字，有三种编码方案，最常用的是UTF-8UTF-8编码方案：英文字母、数字占1个字节兼容(ASCII编码)、汉字字符占3个字节

1.5 编码和解码

使用Java代码完成编码和解码的操作。

其实String类类中就提供了相应的方法，可以完成编码和解码的操作。

• 编码：把字符串按照指定的字符集转换为字节数组
• 解码：把字节数组按照指定的字符集转换为字符串

注意1：字符编码时使用的字符集，和解码时使用的字符集必须一致，否则会出现刮码。如下例
注意2：英文，数字一般不会乱码，因为很多字符集都兼容了ASCII编码

public class Test {public static void main(String[] args) throws Exception {// 1、编码String data = "a我b";byte[] bytes = data.getBytes(); // 默认是按照平台（IDEA）字符集（UTF-8）进行编码的。System.out.println(Arrays.toString(bytes));  // [97, -26, -120, -111, 98]// 按照指定字符集进行编码。byte[] bytes1 = data.getBytes("GBK");System.out.println(Arrays.toString(bytes1)); // [97, -50, -46, 98]// 2、解码String s1 = new String(bytes); // 按照平台默认编码（UTF-8）解码System.out.println(s1); // a我bString s2 = new String(bytes1, "GBK");System.out.println(s2); // a我b}
}

二进制中，1开头的字节代表负数

（跳过）二、IO流（字节流）

（跳过）三、IO流资源释放

（跳过）day10 IO流（二）

day11 特殊文件、日志技术、多线程

一、属性文件

1.1 特殊文件概述

后面我们会用到两种特殊的文本文件，一种是properties文件，还有一种是xml文件

• 后缀为.properties的文件，称之为属性文件，它可以很方便的存储一些类似于键值对的数据。经常当做软件的配置文件使用。
• 而xml文件能够表示更加复杂的数据关系，比如要表示多个用户的用户名、密码、家乡、性别等。在后面，也经常当做软件的配置文件使用。

1.2 Properties属性文件

我们先学习Properties这种属性文件。首先我们要掌握属性文件的格式：

1. 属性文件后缀以.properties结尾
2. 属性文件里面的每一行都是一个键值对，键和值中间用=隔开。比如: admin=123456
3. #表示这样是注释信息，是用来解释这一行配置是什么意思。
4. 每一行末尾不要习惯性加分号，以及空格等字符；不然会把分号，空格会当做值的一部分。
5. 键不能重复，值可以重复

接下来，我们学习如何读取属性文件中的数据。

1.Properties是什么？Properties是Map接口下面的一个实现类，所以Properties也是一种双列集合，用来存储键值对。	  但是一般不会把它当做集合来使用。2.Properties核心作用？Properties类的对象，用来表示属性文件，可以用来读取属性文件中的键值对。

/*** 目标：掌握使用Properties类读取属性文件中的键值对信息。*/
public class PropertiesTest1 {public static void main(String[] args) throws Exception {// 1、创建一个Properties的对象出来（键值对集合，空容器）Properties properties = new Properties();System.out.println(properties);// 2、开始加载属性文件中的键值对数据到properties对象中去properties.load(new FileReader("properties-xml-log-app\\src\\users.properties"));System.out.println(properties);// 3、根据键取值System.out.println(properties.getProperty("赵敏"));System.out.println(properties.getProperty("张无忌"));// 4、遍历全部的键和值。//获取键的集合Set<String> keys = properties.stringPropertyNames();for (String key : keys) {//再根据键获取值String value = properties.getProperty(key);System.out.println(key + "---->" + value);}properties.forEach((k, v) -> {System.out.println(k + "---->" + v);});}
}

二、XML文件

XML是可扩展的标记语言，意思是它是由一些标签组成 的，而这些标签是自己定义的。本质上一种数据格式，可以用来表示复杂的数据关系。

XML文件有如下的特点：

• XML中的<标签名> 称为一个标签或者一个元素，一般是成对出现的。
• XML中的标签名可以自己定义（可扩展），但是必须要正确的嵌套
• XML中只能有一个根标签。
• XML标准中可以有属性
• XML必须第一行有一个文档声明，格式是固定的<?xml version="1.0" encoding="UTF-8"?>
• XML文件必须是以.xml为后缀结尾

• 像 <,>,& 等这些符号不能出现在标签的文本中，因为标签格式本身就有<>，会和标签格式冲突。
  如果标签文本中有这些特殊字符，需要用一些占位符代替。

&lt;  表示 <
&gt;  表示 >
&amp; 表示 &
&apos; 表示 '
&quot; 表示 "

<data> 3 &lt; 2 &amp;&amp; 5 &gt; 4 </data>

• 如果在标签文本中，出现大量的特殊字符，不想使用特殊字符，此时可以用CDATA区，格式如下

<data1><![CDATA[3 < 2 && 5 > 4]]>
</data1>

（跳过）2.2 XML解析

使用程序读取XML文件中的数据，称之为XML解析。这里并不需要我们自己写IO流代码去读取xml文件中的数据。其实有很多开源的，好用的XML解析框架，最知名的是DOM4J（第三方开发的）

三、日志技术

日志技术有如下好处

1. 日志可以将系统执行的信息，方便的记录到指定位置，可以是控制台、可以是文件、可以是数据库中。
2. 日志可以随时以开关的形式控制启停，无需侵入到源代码中去修改。

3.2 日志的体系

日志框架有很多种，比如有JUL（java.util.logging）、Log4j、logback等。但是这些日志框架如果使用的API方法都不一样的话，使用者的学习成本就很高。为了降低程序员的学习压力，行内提供了一套日志接口，然后所有的日志框架都按照日志接口的API来实现就可以了。

这样程序员只要会一套日志框架，那么其他的也就可以通过用，甚至可以在多套日志框架之间来回切换。比较常用的日志框架，和日志接口的关系如下图所示

这里推荐同学们使用Logback日志框架，也在行业中最为广泛使用的。

Logback日志分为哪几个模块

（跳过）3.3 Logback快速入门

三、多线程

线程其实是程序中的一条执行路径。
我们之前写过的程序，其实都是单线程程序，如下图代码，如果前面的for循环没有执行完，for循环下面的代码是不会执行的。

怎样的程序才是多线程程序呢？ 如下图所示，12306网站就是支持多线程的，因为同时可以有很多人一起进入网站购票，而且每一个人互不影响。再比如百度网盘，可以同时下载或者上传多个文件。这些程序中其实就有多条执行路径，每一条执行执行路径就是一条线程，所以这样的程序就是多线程程序。

4.1 线程创建方式1

Java为开发者提供了一个类叫做Thread，此类的对象用来表示线程。创建线程并执行线程的步骤如下

1.定义一个子类继承Thread类，并重写run方法
2.创建Thread的子类对象
3.调用start方法启动线程（启动线程后，会自动执行run方法中的代码）

public class MyThread extends Thread{// 2、必须重写Thread类的run方法@Overridepublic void run() {// 描述线程的执行任务。for (int i = 1; i <= 5; i++) {System.out.println("子线程MyThread输出：" + i);}}
}

public class ThreadTest1 {// main方法是由一条默认的主线程负责执行。public static void main(String[] args) {// 3、创建MyThread线程类的对象代表一个线程Thread t = new MyThread();// 4、启动线程（自动执行run方法的）t.start(); for (int i = 1; i <= 5; i++) {System.out.println("主线程main输出：" + i);}}
}

打印结果如下图所示，我们会发现MyThread和main线程在相互抢夺CPU的执行权（注意：哪一个线程先执行，哪一个线程后执行，目前我们是无法控制的，每次输出结果都会不一样）

最后我们还需要注意一点：不能直接去调用run方法，如果直接调用run方法就不认为是一条线程启动了，而是把Thread当做一个普通对象，此时run方法中的执行的代码会成为主线程的一部分。此时执行结果是这样的。

4.2 线程创建方式2

接下来我们学习线程的第二种创建方式。Java为开发者提供了一个Runnable接口，该接口中只有一个run方法，意思就是通过Runnable接口的实现类对象专门来表示线程要执行的任务。具体步骤如下

1.先写一个Runnable接口的实现类，重写run方法(这里面就是线程要执行的代码)
2.再创建一个Runnable实现类的对象
3.创建一个Thread对象，把Runnable实现类的对象传递给Thread
4.调用Thread对象的start()方法启动线程（启动后会自动执行Runnable里面的run方法）

public class MyRunnable implements Runnable{// 2、重写runnable的run方法@Overridepublic void run() {// 线程要执行的任务。for (int i = 1; i <= 5; i++) {System.out.println("子线程输出 ===》" + i);}}
}

public class ThreadTest2 {public static void main(String[] args) {// 3、创建任务对象。Runnable target = new MyRunnable();// 4、把任务对象交给一个线程对象处理。//  public Thread(Runnable target)new Thread(target).start();for (int i = 1; i <= 5; i++) {System.out.println("主线程main输出 ===》" + i);}}
}

4.3 线程创建方式2—匿名内部类

刚刚我们学习的第二种线程的创建方式，需要写一个Runnable接口的实现类，然后再把Runnable实现类的对象传递给Thread对象。

现在我不想写Runnable实现类，于是可以直接创建Runnable接口的匿名内部类对象，传递给Thread对象。

public class ThreadTest2_2 {public static void main(String[] args) {// 1、直接创建Runnable接口的匿名内部类形式（任务对象）Runnable target = new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 5; i++) {System.out.println("子线程1输出：" + i);}}};new Thread(target).start();// 简化形式1：new Thread(new Runnable() {@Overridepublic void run() {for (int i = 1; i <= 5; i++) {System.out.println("子线程2输出：" + i);}}}).start();// 简化形式2：new Thread(() -> {for (int i = 1; i <= 5; i++) {System.out.println("子线程3输出：" + i);}}).start();for (int i = 1; i <= 5; i++) {System.out.println("主线程main输出：" + i);}}
}

4.4 线程的创建方式3

我们先分析一下前面两种都存在的一个问题。然后再引出第三种可以解决这个问题。

• 假设线程执行完毕之后有一些数据需要返回，前面两种方式重写的run方法均没有返回结果。

public void run(){...线程执行的代码...
}

• JDK5提供了Callable接口和FutureTask类来创建线程，它最大的优点就是有返回值。
  在Callable接口中有一个call方法，重写call方法就是线程要执行的代码，它是有返回值的

public T call(){...线程执行的代码...return 结果;
}

第三种创建线程的方式，步骤如下

1.先定义一个Callable接口的实现类，重写call方法
2.创建Callable实现类的对象
3.创建FutureTask类的对象，将Callable对象传递给FutureTask
4.创建Thread对象，将Future对象传递给Thread
5.调用Thread的start()方法启动线程(启动后会自动执行call方法)等call()方法执行完之后，会自动将返回值结果封装到FutrueTask对象中6.调用FutrueTask对的get()方法获取返回结果

public class MyCallable implements Callable<String> {private int n;public MyCallable(int n) {this.n = n;}@Overridepublic String call() throws Exception {int sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return "线程求出了1-" + n + "的和是：" + sum;}
}

public class ThreadTest3 {public static void main(String[] args) throws Exception {// 3、创建一个Callable的对象Callable<String> call = new MyCallable(100);// 4、把Callable的对象封装成一个FutureTask对象（任务对象）// 未来任务对象的作用？// 1、是一个任务对象，实现了Runnable对象.// 2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果。FutureTask<String> f1  = new FutureTask<>(call);// 5、把任务对象交给一个Thread对象new Thread(f1).start();Callable<String> call2 = new MyCallable(200);FutureTask<String> f2  = new FutureTask<>(call2);new Thread(f2).start();// 6、获取线程执行完毕后返回的结果。// 注意：如果执行到这儿，假如上面的线程还没有执行完毕// 这里的代码会暂停，等待上面线程执行完毕后才会获取结果。String rs = f1.get();System.out.println(rs); // 线程求出了1-100的和是：5050String rs2 = f2.get();System.out.println(rs2); // 线程求出了1-200的和是：20100}
}

Future接口的方法——get()方法
获取任务执行结果，会阻塞直到任务完成。可以设置超时时间。

day12 多线程

一、多线程常用方法

下面我们演示一下getName()、setName(String name)、currentThread()、sleep(long time)这些方法的使用效果。

public class MyThread extends Thread{public MyThread(){}public MyThread(String name){super(name); //1.执行父类Thread(String name)构造器，为当前线程设置名字了}@Overridepublic void run() {//2.currentThread() 哪个线程执行它，它就会得到哪个线程对象。Thread t = Thread.currentThread();for (int i = 1; i <= 3; i++) {//3.getName() 获取线程名称System.out.println(t.getName() + "输出：" + i);}}
}

public class ThreadTest1 {public static void main(String[] args) {// Thread t1 = new MyThread();// System.out.println(t1.getName());  //Thread-0Thread t1 = new MyThread();t1.setName("1号线程") //设置线程名称;t1.start();System.out.println(t1.getName());  // 1号线程Thread t2 = new MyThread("2号线程");// t2.setName("2号线程");t2.start();System.out.println(t2.getName()); // 2号线程// 主线程对象的名字// 哪个线程执行它，它就会得到哪个线程对象。Thread m = Thread.currentThread();System.out.println(m.getName()); // mainm.setName("最牛的线程");System.out.println(m.getName()); // 最牛的线程for (int i = 1; i <= 5; i++) {System.out.println(m.getName() + "线程输出：" + i);}}
}

我们发现每一条线程都有自己了名字了。

2号线程输出：1
最牛的线程线程输出：1
1号线程输出：1
1号线程输出：2
1号线程输出：3
最牛的线程线程输出：2
2号线程输出：2
2号线程输出：3
最牛的线程线程输出：3
最牛的线程线程输出：4
最牛的线程线程输出：5

最后再演示一下join这个方法是什么效果。

public class ThreadTest2 {public static void main(String[] args) throws Exception {// join方法作用：让当前调用这个方法的线程先执行完。Thread t1 = new MyThread("1号线程");t1.start();t1.join();Thread t2 = new MyThread("2号线程");t2.start();t2.join();Thread t3 = new MyThread("3号线程");t3.start();t3.join();}
}

执行效果是1号线程先执行完，再执行2号线程；2号线程执行完，再执行3号线程；3号线程执行完就结束了。

我们再尝试，把join()方法去掉，再看执行效果。此时你会发现2号线程没有执行完1号线程就执行了**（效果是多次运行才出现的，根据个人电脑而异，可能有同学半天也出现不了也是正常的）**

二、线程安全问题

2.1 线程安全问题概述

线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题

场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？

如下图所示，小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作，才算是完成的取钱的操作。但是真实执行过程可能是下面这样子的
​ ① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了。
​ ② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了。
​ ③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走。
​ ④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-10万。

2.2 线程安全问题的代码演示

public class Account {private String cardId; // 卡号private double money; // 余额。public Account() {}public Account(String cardId, double money) {this.cardId = cardId;this.money = money;}// 小明 小红同时过来的public void drawMoney(double money) {// 先搞清楚是谁来取钱？String name = Thread.currentThread().getName();// 1、判断余额是否足够if(this.money >= money){System.out.println(name + "来取钱" + money + "成功！");this.money -= money;System.out.println(name + "来取钱后，余额剩余：" + this.money);}else {System.out.println(name + "来取钱：余额不足~");}}public String getCardId() {return cardId;}public void setCardId(String cardId) {this.cardId = cardId;}public double getMoney() {return money;}public void setMoney(double money) {this.money = money;}
}

在定义一个是取钱的线程类

public class DrawThread extends Thread{private Account acc;public DrawThread(Account acc, String name){super(name);this.acc = acc;}@Overridepublic void run() {// 取钱(小明，小红)acc.drawMoney(100000);}
}

public class ThreadTest {public static void main(String[] args) {// 1、创建一个账户对象，代表两个人的共享账户。Account acc = new Account("ICBC-110", 100000);// 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万。new DrawThread(acc, "小明").start(); // 小明new DrawThread(acc, "小红").start(); // 小红}
}

运行程序，执行效果如下。你会发现两个人都取了10万块钱，余额为-10万了。

2.3 线程同步方案

为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。

采用加锁的方案，就可以解决前面两个线程都取10万块钱的问题。怎么加锁呢？Java提供了三种方案

1.同步代码块
2.同步方法
3.Lock锁

2.4 同步代码块

同步代码块的作用就是把访问共享数据的核心代码锁起来，以此保证线程安全。

原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。

同步锁的注意事项

• 对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。

//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){//...访问共享数据的核心代码...
}

使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改Account类中的代码即可。

// 小明 小红线程同时过来的
public void drawMoney(double money) {// 先搞清楚是谁来取钱？String name = Thread.currentThread().getName();// 1、判断余额是否足够// this正好代表共享资源！synchronized (this) {if(this.money >= money){System.out.println(name + "来取钱" + money + "成功！");this.money -= money;System.out.println(name + "来取钱后，余额剩余：" + this.money);}else {System.out.println(name + "来取钱：余额不足~");}}
}

使用 this 而不是 字符串"黑马"（因为这个字符串在常量池中，只有一份，理论上也能作为锁） 的好处：

public class ThreadTest {public static void main(String[] args) {Account acc = new Account("ICBC-110", 100000);new DrawThread(acc, "小明").start(); // 小明new DrawThread(acc, "小红").start(); // 小红Account acc = new Account("ICBC-112", 100000);new DrawThread(acc, "小黑").start(); // 小黑new DrawThread(acc, "小白").start(); // 小白}
}

而如果是静态方法，无法获取this，官方建议我们使用class作为锁（因为这个class文件在我们系统中只有一份）：还是在Account这个类里面：

public static void test() {synchronized (Account.class) {}
}

总结：锁对象如何选择

1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法，建议使用this作为锁对象
3.对于静态方法，建议把类的字节码(类名.class)当做锁对象

2.5 同步方法

接下来，学习同步方法解决线程安全问题。其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。

// 同步方法
public synchronized void drawMoney(double money) {// 先搞清楚是谁来取钱？String name = Thread.currentThread().getName();// 1、判断余额是否足够if(this.money >= money){System.out.println(name + "来取钱" + money + "成功！");this.money -= money;System.out.println(name + "来取钱后，余额剩余：" + this.money);}else {System.out.println(name + "来取钱：余额不足~");}
}

接着，再问同学们一个问题，同步方法有没有锁对象？锁对象是谁？

同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。1.对于实例方法，锁对象其实是this（也就是方法的调用者）2.对于静态方法，锁对象时类的字节码对象（类名.class）

最终，总结一下同步代码块和同步方法有什么区别？

1.不存在哪个好与不好，只是一个锁住的范围大，一个范围小
2.同步方法是将方法中所有的代码锁住
3.同步代码块是将方法中的部分代码锁住

2.6 Lock锁

Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下

1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码lk.lock(); // 加锁//...中间是被锁住的代码...lk.unlock(); // 解锁

使用Lock锁改写前面DrawThread中取钱的方法，代码如下

// 创建了一个锁对象
private final Lock lk = new ReentrantLock();public void drawMoney(double money) {// 先搞清楚是谁来取钱？String name = Thread.currentThread().getName();try {lk.lock(); // 加锁// 1、判断余额是否足够if(this.money >= money){System.out.println(name + "来取钱" + money + "成功！");this.money -= money;System.out.println(name + "来取钱后，余额剩余：" + this.money);}else {System.out.println(name + "来取钱：余额不足~");}} catch (Exception e) {e.printStackTrace();} finally {lk.unlock(); // 解锁}}
}

三、线程通信（了解）

首先，什么是线程通信呢？

• 当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源挣抢。

线程通信的常见模式：是生产者与消费者模型

• 生产者线程负责生成数据
• 消费者线程负责消费生产者生成的数据
• 注意：生产者生产完数据后应该让自己等待，通知其他消费者消费；消费者消费完数据之后应该让自己等待，同时通知生产者生成。

比如下面案例中，有3个厨师（生产者线程），两个顾客（消费者线程）。

1.先确定在这个案例中，什么是共享数据？答：这里案例中桌子是共享数据，因为厨师和顾客都需要对桌子上的包子进行操作。2.再确定有那几条线程？哪个是生产者，哪个是消费者？答：厨师是生产者线程，3条生产者线程； 顾客是消费者线程，2条消费者线程3.什么时候将哪一个线程设置为什么状态生产者线程(厨师)放包子：1)先判断是否有包子2)没有包子时，厨师开始做包子, 做完之后把别人唤醒，然后让自己等待3)有包子时，不做包子了，直接唤醒别人、然后让自己等待消费者线程(顾客)吃包子：1)先判断是否有包子2)有包子时，顾客开始吃包子, 吃完之后把别人唤醒，然后让自己等待3)没有包子时，不吃包子了，直接唤醒别人、然后让自己等待

public class Desk {private List<String> list = new ArrayList<>();// 放1个包子的方法// 厨师1 厨师2 厨师3public synchronized void put() {try {String name = Thread.currentThread().getName();// 判断是否有包子。if(list.size() == 0){list.add(name + "做的肉包子");System.out.println(name + "做了一个肉包子~~");Thread.sleep(2000);// 唤醒别人, 等待自己this.notifyAll();this.wait();}else {// 有包子了，不做了。// 唤醒别人, 等待自己this.notifyAll();this.wait();}} catch (Exception e) {e.printStackTrace();}}// 吃货1 吃货2public synchronized void get() {try {String name = Thread.currentThread().getName();if(list.size() == 1){// 有包子，吃了System.out.println(name  + "吃了：" + list.get(0));list.clear();Thread.sleep(1000);this.notifyAll();this.wait();}else {// 没有包子this.notifyAll();this.wait();}} catch (Exception e) {e.printStackTrace();}}
}

注意wait要在notifyAll后面！！

public class ThreadTest {public static void main(String[] args) {//   需求：3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上//      2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃。Desk desk  = new Desk();// 创建3个生产者线程（3个厨师）new Thread(() -> {while (true) {desk.put();}}, "厨师1").start();new Thread(() -> {while (true) {desk.put();}}, "厨师2").start();new Thread(() -> {while (true) {desk.put();}}, "厨师3").start();// 创建2个消费者线程（2个吃货）new Thread(() -> {while (true) {desk.get();}}, "吃货1").start();new Thread(() -> {while (true) {desk.get();}}, "吃货2").start();}
}

执行上面代码，运行结果如下：你会发现多个线程相互协调执行，避免无效的资源挣抢。

厨师1做了一个肉包子~~
吃货2吃了：厨师1做的肉包子
厨师3做了一个肉包子~~
吃货2吃了：厨师3做的肉包子
厨师1做了一个肉包子~~
吃货1吃了：厨师1做的肉包子
厨师2做了一个肉包子~~
吃货2吃了：厨师2做的肉包子
厨师3做了一个肉包子~~
吃货1吃了：厨师3做的肉包子

四、线程池

什么是线程池技术？ 其实，线程池就是一个可以复用线程的技术。

要理解什么是线程复用技术，我们先得看一下不使用线程池会有什么问题，理解了这些问题之后，我们在解释线程复用同学们就好理解了。

假设：用户每次发起一个请求给后台，后台就创建一个新的线程来处理，下次新的任务过来肯定也会创建新的线程，如果用户量非常大，创建的线程也讲越来越多。然而，创建线程是开销很大的，并且请求过多时，会严重影响系统性能。

而使用线程池，就可以解决上面的问题。如下图所示，线程池内部会有一个容器，存储几个核心线程，假设有3个核心线程，这3个核心线程可以处理3个任务。
但是任务总有被执行完的时候，假设第1个线程的任务执行完了，那么第1个线程就空闲下来了，有新的任务时，空闲下来的第1个线程可以去执行其他任务。依此内推，这3个线程可以不断的复用，也可以执行很多个任务。

所以，线程池就是一个线程复用技术，它可以提高线程的利用率。

4.2 创建线程池

在JDK5版本中提供了代表线程池的接口ExecutorService，而这个接口下有一个实现类叫ThreadPoolExecutor类，使用ThreadPoolExecutor类就可以用来创建线程池对象。

接下来，用这7个参数的构造器来创建线程池的对象。代码如下

ExecutorService pool = new ThreadPoolExecutor(3,	//核心线程数有3个5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=28,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。TimeUnit.SECONDS,//时间单位（秒）new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待Executors.defaultThreadFactory(), //用于创建线程的工厂对象new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);

关于线程池，我们需要注意下面的两个问题

• 临时线程什么时候创建？

新任务提交时，发现核心线程都在忙、任务队列满了、并且还可以创建临时线程，此时会创建临时线程。

• 什么时候开始拒绝新的任务？

核心线程和临时线程都在忙、任务队列也满了、新任务过来时才会开始拒绝任务。

4.3 线程池执行Runnable任务

创建好线程池之后，接下来我们就可以使用线程池执行任务了。线程池执行的任务可以有两种，一种是Runnable任务；一种是callable任务。下面的execute方法可以用来执行Runnable任务。

先准备一个线程任务类
（线程任务=一个执行路径，注意虽然是继承了Runnable但是任务（不过Runnable应该本身就是任务的意思而不是线程）而不是线程（线程是Threads），因此下面是pool.execute(target);也就是说线程池中的线程执行target这个任务）

public class MyRunnable implements Runnable{@Overridepublic void run() {// 任务是干啥的？System.out.println(Thread.currentThread().getName() + " ==> 输出666~~");try {// 注意这里和后面的不一样，时间比较短。所以核心线程不会一直在忙Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}
}

ExecutorService pool = new ThreadPoolExecutor(3,	//核心线程数有3个5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=28,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。TimeUnit.SECONDS,//时间单位（秒）new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待Executors.defaultThreadFactory(), //用于创建线程的工厂对象new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 复用前面的核心进程
pool.execute(target); // 复用前面的核心进程

线程池启动后，程序是不会死亡的。除非：1、手动点击那个红点；or2、使用shutdown方法（shutdown方法会等到线程池的任务执行完毕之后，才会帮你把线程池关掉。这个方法比较柔和）；or3、使用shutdownnow方法（shutdownnow方法会立即把线程池关掉，即使线程池中的任务没有执行完。然后返回那些没有执行完的任务给你）

public class MyRunnable implements Runnable{@Overridepublic void run() {// 任务是干啥的？System.out.println(Thread.currentThread().getName() + " ==> 输出666~~");//为了模拟线程一直在执行，这里睡久一点。3个核心线程都被拖住了，所以新来的任务只能进入任务队列try {Thread.sleep(Integer.MAX_VALUE);} catch (InterruptedException e) {e.printStackTrace();}}
}

下面是执行Runnable任务的代码，注意阅读注释，对照着前面的7个参数理解。

ExecutorService pool = new ThreadPoolExecutor(3,	//核心线程数有3个5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=28,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。TimeUnit.SECONDS,//时间单位（秒）new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待Executors.defaultThreadFactory(), //用于创建线程的工厂对象new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
//下面4个任务在任务队列里排队
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);//到了临时线程的创建时机了
pool.execute(target);

ExecutorService pool = new ThreadPoolExecutor(3,	//核心线程数有3个5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=28,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。TimeUnit.SECONDS,//时间单位（秒）new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待Executors.defaultThreadFactory(), //用于创建线程的工厂对象new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
//下面4个任务在任务队列里排队
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);//下面2个任务，会被临时线程的创建时机了
pool.execute(target);
pool.execute(target);
// 到了新任务的拒绝时机了！
pool.execute(target);

执行上面的代码，结果输出如下

4.4 线程池执行Callable任务

接下来，我们学习使用线程池执行Callable任务。callable任务相对于Runnable任务来说，就是多了一个返回值。

执行Callable任务需要用到下面的submit方法

通过这个返回的未来对象Future对象，来获取线程池处理这个任务后返回的结果
这里之所以是Future而不是FutureTask。是因为Future是FutureTask的父类，这里是一种多态的写法

先准备一个Callable线程任务

public class MyCallable implements Callable<String> {private int n;public MyCallable(int n) {this.n = n;}// 2、重写call方法@Overridepublic String call() throws Exception {// 描述线程的任务，返回线程执行返回后的结果。// 需求：求1-n的和返回。int sum = 0;for (int i = 1; i <= n; i++) {sum += i;}return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;}
}

再准备一个测试类，在测试类中创建线程池，并执行callable任务。

public class ThreadPoolTest2 {public static void main(String[] args) throws Exception {// 1、通过ThreadPoolExecutor创建一个线程池对象。ExecutorService pool = new ThreadPoolExecutor(3,5,8,TimeUnit.SECONDS, new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.CallerRunsPolicy());// 2、使用线程处理Callable任务。Future<String> f1 = pool.submit(new MyCallable(100));Future<String> f2 = pool.submit(new MyCallable(200));Future<String> f3 = pool.submit(new MyCallable(300));Future<String> f4 = pool.submit(new MyCallable(400));// 3、执行完Callable任务后，需要获取返回结果。System.out.println(f1.get());System.out.println(f2.get());System.out.println(f3.get());System.out.println(f4.get());}
}

执行后，结果如下图所示

4.5 线程池工具类（Executors）

有同学可能会觉得前面创建线程池的代码参数太多、记不住，有没有快捷的创建线程池的方法呢？有的。Java为开发者提供了一个创建线程池的工具类，叫做Executors，它提供了很多静态方法可以创建各种不同特点的线程池。如下图所示

注意：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

接下来，我们演示一下创建固定线程数量的线程池。这几个方法用得不多，所以这里不做过多演示，同学们了解一下就行了。

public class ThreadPoolTest3 {public static void main(String[] args) throws Exception {// 1、通过Executors创建一个线程池对象。ExecutorService pool = Executors.newFixedThreadPool(17);// 老师：核心线程数量到底配置多少呢？？？// 计算密集型的任务：核心线程数量 = CPU的核数 + 1// IO密集型的任务：核心线程数量 = CPU核数 * 2// 2、使用线程处理Callable任务。Future<String> f1 = pool.submit(new MyCallable(100));Future<String> f2 = pool.submit(new MyCallable(200));Future<String> f3 = pool.submit(new MyCallable(300));Future<String> f4 = pool.submit(new MyCallable(400));System.out.println(f1.get());System.out.println(f2.get());System.out.println(f3.get());System.out.println(f4.get());}
}

计算密集型任务：这个任务基本上是在做一些运算，由cpu帮它算。比如这个地方求1～100的和就是一个计算密集型任务
IO密集型任务：比如任务涉及到要去读取这个文件数据或者要进行一些通信
CPU的核数：在任务管理器-性能中查看。这里显示内核是8，注意八核是16个逻辑处理器，也就是说16核的！所以对于计算密集型任务来说核心线程数量 = 16 + 1

Executors创建线程池这么好用，为什么不推荐同学们使用呢？原因在这里：看下图，这是《阿里巴巴Java开发手册》提供的强制规范要求。

大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

如果做的不是那种大型并发的系统，比如只有几百人几十人访问，就可以使用这个去创建线程池

五、补充知识

5.1 并发和并行

在讲解并发和并行的含义之前，我们先来了解一下什么是进程、线程？

• 正常运行的程序（软件）就是一个独立的进程
• 线程是属于进程，一个进程中包含多个线程
• 进程中的线程其实并发和并行同时存在（继续往下看）

我们可以打开系统的任务管理器看看（快捷键：Ctrl+Shfit+Esc），自己的电脑上目前有哪些进程。

知道了什么是进程和线程之后，接着我们再来学习并发和并行的含义。

首先，来学习一下什么是并发？
进程中的线程由CPU负责调度执行，但是CPU同时处理线程的数量是优先的，为了保证全部线程都能执行到，CPU采用轮询机制为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。（简单记：并发就是多条线程交替执行）

接下，再来学习一下什么是并行？
并行指的是，多个线程同时被CPU调度执行。如下图所示，多个CPU核心在执行多条线程、

像是上一节中说到内核8、16个逻辑处理器，说明可以处理16个线程。因此在电脑中现在有5000多个线程的情况下，CPU会每16个线程、16个线程的切换。这一刻处理这16个线程，下一刻处理另外16个线程，这就叫并发。

最后一个问题，多线程到底是并发还是并行呢？
其实多个线程在我们的电脑上执行，并发和并行是同时存在的。

5.2 线程的生命周期

所谓生命周期就是线程从生到死的过程中间有哪些状态，以及这些状态之间是怎么切换的。

为了让大家同好的理解线程的生命周期，先用人的生命周期举个例子，人从生到死有下面的几个过程。在人的生命周期过程中，各种状态之间可能会有切换，线程也是一样的。

接下来就来学习线程的生命周期。在Thread类中有一个嵌套的枚举类叫Thread.Status，这里面定义了线程的6中状态。如下图所示

NEW: 新建状态，线程还没有启动
RUNNABLE: 可以运行状态，线程调用了start()方法后处于这个状态
BLOCKED: 锁阻塞状态，没有获取到锁处于这个状态
WAITING: 无限等待状态，线程执行时被调用了wait方法处于这个状态
TIMED_WAITING: 计时等待状态，线程执行时被调用了sleep(毫秒)或者wait(毫秒)方法处于这个状态
TERMINATED: 终止状态, 线程执行完毕或者遇到异常时，处于这个状态。

注意上图会发现，sleep不会释放锁，和wait不一样，wait会释放锁

（跳过）day13 网络编程

day14 单元测试、反射

一、单元测试

1.1 单元测试快速入门

所谓单元测试，就是针对最小的功能单元，编写测试代码对其进行正确性测试。

为了测试更加方便，有一些第三方的公司或者组织提供了很好用的测试框架，给开发者使用。这里给同学们介绍一种Junit测试框架。

Junit是第三方公司开源出来的，用于对代码进行单元测试的工具（IDEA已经集成了junit框架）。相比于在main方法中测试有如下几个优点。

我们知道单元测试是什么之后，接下来带领同学们使用一下。由于Junit是第三方提供的，所以我们需要把jar包导入到我们的项目中，才能使用，具体步骤如下图所示：

先准备一个类，假设写了一个StringUtil工具类，代码如下

public class StringUtil{public static void printNumber(String name){System.out.println("名字长度："+name.length());}
}

接下来，写一个测试类，测试StringUtil工具类中的方法能否正常使用。

public class StringUtilTest{@Testpublic void testPrintNumber(){StringUtil.printNumber("admin");StringUtil.printNumber(null); // 无法通过，NullPointException}
}

写完代码之后，我们会发现测试方法左边，会有一个绿色的三角形按钮。点击这个按钮，就可以运行测试方法。

1.2 单元测试断言

接下来，我们学习一个单元测试的断言机制。所谓断言：意思是程序员可以预测程序的运行结果，检查程序的运行结果是否与预期一致。

我们在StringUtil类中新增一个测试方法

 public static int getMaxIndex(String data){if(data == null){return -1;}return data.length();}

public class StringUtilTest{@Testpublic void testGetMaxIndex(){int index1 = StringUtil.getMaxIndex(null);System.out.println(index1);int index2 = StringUtil.getMaxIndex("admin");System.out.println(index2);//断言机制：预测index2的结果Assert.assertEquals("方法内部有Bug",4,index2);}
}

运行测试方法，结果如下图所示，表示我们预期值与实际值不一致

1.3 Junit框架的常用注解

同学们，刚才我们以及学习了@Test注解，可以用来标记一个方法为测试方法，测试才能启动执行。

除了@Test注解，还有一些其他的注解，我们要知道其他注解标记的方法什么时候执行，以及其他注解在什么场景下可以使用。

接下来，我们演示一下其他注解的使用。我们在StringUtilTest测试类中，再新增几个测试方法。代码如下

public class StringUtilTest{@Beforepublic void test1(){System.out.println("--> test1 Before 执行了");}@BeforeClasspublic static void test11(){System.out.println("--> test11 BeforeClass 执行了");}@Afterpublic void test2(){System.out.println("--> test2 After 执行了");}@AfterCalsspublic static void test22(){System.out.println("--> test22 AfterCalss 执行了");}
}

执行上面的测试类，结果如下图所示，观察执行结果特点如下

1.被@BeforeClass标记的方法,执行在所有方法之前
2.被@AfterCalss标记的方法，执行在所有方法之后
3.被@Before标记的方法，执行在每一个@Test方法之前
4.被@After标记的方法，执行在每一个@Test方法之后

我们现在已经知道每一个注解的作用了，那他们有什么用呢？应用场景在哪里?

我们来看一个例子，假设我想在每个测试方法中使用Socket对象，并且用完之后，需要把Socket关闭。代码就可以按照下面的结构来设计

public class StringUtilTest{private static Socket socket;@Beforepublic void test1(){System.out.println("--> test1 Before 执行了");}@BeforeClasspublic static void test11(){System.out.println("--> test11 BeforeClass 执行了");//初始化Socket对象socket = new Socket();}@Afterpublic void test2(){System.out.println("--> test2 After 执行了");}@AfterCalsspublic static void test22(){System.out.println("--> test22 AfterCalss 执行了");//关闭Socketsocket.close();}
}

最后，我们再补充一点。前面的注解是基于Junit4版本的，再Junit5版本中对注解作了更新，但是作用是一样的。所以这里就不做演示了。

二、反射

什么是反射。其实API文档中对反射有详细的说明，我们去了解一下。在java.lang.reflect包中对反射的解释如下图所示

翻译成人话就是：反射技术，指的是加载类的字节码到内存，并以编程的方法解刨出类中的各个成分（成员变量、方法、构造器等）。

反射有啥用呢？其实反射是用来写框架用的，但是现阶段同学们对框架还没有太多感觉。为了方便理解，我给同学们看一个我们见过的例子：平时我们用IDEA开发程序时，用对象调用方法，IDEA会有代码提示，idea会将这个对象能调用的方法都给你列举出来，供你选择，如果下图所示

问题是IDEA怎么知道这个对象有这些方法可以调用呢? 原因是对象能调用的方法全都来自于类，IDEA通过反射技术就可以获取到类中有哪些方法，并且把方法的名称以提示框的形式显示出来，所以你能看到这些提示了。

那记事本写代码为什么没有提示呢? 因为技术本软件没有利用反射技术开发这种代码提示的功能，哈哈！！

好了，认识了反射是什么之后，接下来我还想给同学们介绍一下反射具体学什么？

因为反射获取的是类的信息，那么反射的第一步首先获取到类才行。由于Java的设计原则是万物皆对象，获取到的类其实也是以对象的形式体现的，叫字节码对象，用Class类来表示。获取到字节码对象之后，再通过字节码对象就可以获取到类的组成成分了，这些组成成分其实也是对象，其中每一个成员变量用Field类的对象来表示、每一个成员方法用Method类的对象来表示，每一个构造器用Constructor类的对象来表示。

1.1 获取类的字节码

反射的第一步：是将字节码加载到内存，我们需要获取到的字节码对象。

比如有一个Student类，获取Student类的字节码代码有三种写法。不管用哪一种方式，获取到的字节码对象其实是同一个。

public class Test1Class{public static void main(String[] args){Class c1 = Student.class;System.out.println(c1.getName()); //获取全类名 com.itheima.d2_reflect.StudentSystem.out.println(c1.getSimpleName()); //获取简单类名 StudentClass c2 = Class.forName("com.itheima.d2_reflect.Student");System.out.println(c1 == c2); //trueStudent s = new Student();Class c3 = s.getClass();System.out.println(c2 == c3); //true}
}

1.2 获取类的构造器

我们学习一下通过字节码对象获取构造器，并使用构造器创建对象。

获取构造器，需要用到Class类提供的几个方法，如下图所示：

public class Cat{private String name;private int age;public Cat(){}private Cat(String name, int age){}
}

1、接下来，我们写一个测试方法，来测试获取类中所有的构造器

public class Test2Constructor(){@Testpublic void testGetConstructors(){//1、反射第一步：必须先得到这个类的Class对象Class c = Cat.class;//2、获取类的全部构造器Constructor[] constructors = c.getDeclaredConstructors();//3、遍历数组中的每一个构造器对象。for(Constructor constructor: constructors){System.out.println(constructor.getName()+"---> 参数个数："+constructor.getParameterCount());}}
}

运行测试方法打印结果如下

2、刚才演示的是获取Cat类中所有的构造器，接下来，我们演示单个构造器试一试

public class Test2Constructor(){@Testpublic void testGetConstructor(){//1、反射第一步：必须先得到这个类的Class对象Class c = Cat.class;//2、获取类public修饰的空参数构造器Constructor constructor1 = c.getConstructor();System.out.println(constructor1.getName()+"---> 参数个数："+constructor1.getParameterCount());//3、获取private修饰的有两个参数的构造器，第一个参数String类型，第二个参数int类型Constructor constructor2 = c.getDeclaredConstructor(String.class,int.class);System.out.println(constructor2.getName()+"---> 参数个数："+constructor1.getParameterCount());}
}

1.3 反射获取构造器的作用

刚才上一节我们已经获取到了Cat类中的构造器。获取到构造器后，有什么作用呢？

其实构造器的作用：初始化对象并返回。

这里我们需要用到如下的两个方法，注意：这两个方法时属于Constructor的，需要用Constructor对象来调用。

如下图所示，constructor1和constructor2分别表示Cat类中的两个构造器。现在我要把这两个构造器执行起来（注意这里两个构造器都设成了private）

由于构造器是private修饰的，先需要调用setAccessible(true) 表示禁止检查访问控制，然后再调用newInstance(实参列表) 就可以执行构造器，完成对象的初始化了。

代码如下：为了看到构造器真的执行， 故意在两个构造器中分别加了两个打印语句

代码的执行结果如下图所示：

1.4 反射获取成员变量&使用

同学们，上一节我们已经学习了获取类的构造方法并使用。接下来，我们再学习获取类的成员变量，并使用。

在Class类中提供了获取成员变量的方法，如下图所示。

• 获取到成员变量的对象之后该如何使用呢？
  在Filed类中提供给给成员变量赋值和获取值的方法，如下图所示。

再次强调一下设置值、获取值的方法时Filed类的需要用Filed类的对象来调用，而且不管是设置值、还是获取值，都需要依赖于该变量所属的对象。代码如下

1.5 反射获取成员方法

在Java中反射包中，每一个成员方法用Method对象来表示，通过Class类提供的方法可以获取类中的成员方法对象。如下下图所示

public class Cat{private String name;private int age;public Cat(){System.out.println("空参数构造方法执行了");}private Cat(String name, int age){System.out.println("有参数构造方法执行了");this.name=name;this.age=age;}private void run(){System.out.println("(>^ω^<)喵跑得贼快~~");}public void eat(){System.out.println("(>^ω^<)喵爱吃猫粮~");}private String eat(String name){return "(>^ω^<)喵爱吃:"+name;}public void setName(String name){this.name=name;}public String getName(){return name;}public void setAge(int age){this.age=age;}public int getAge(){return age;}
}

接下来，通过反射获取Cat类中所有的成员方法，每一个成员方法都是一个Method对象

public class Test3Method{public static void main(String[] args){//1、反射第一步：先获取到Class对象Class c = Cat.class;//2、获取类中的全部成员方法Method[] methods = c.getDecalaredMethods();//3、遍历这个数组中的每一个方法对象for(Method method : methods){System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType());}}
}

运行结果如下图所示：打印输出每一个成员方法的名称、参数格式、返回值类型

也能获取单个指定的成员方法，如下图所示

获取到成员方法之后，有什么作用呢？

在Method类中提供了方法，可以将方法自己执行起来。

下面我们演示一下，把run()方法和eat(String name)方法执行起来。看分割线之下的代码

public class Test3Method{public static void main(String[] args){//1、反射第一步：先获取到Class对象Class c = Cat.class;//2、获取类中的全部成员方法Method[] methods = c.getDecalaredMethods();//3、遍历这个数组中的每一个方法对象for(Method method : methods){System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType());}System.out.println("-----------------------");//4、获取private修饰的run方法，得到Method对象Method run = c.getDecalaredMethod("run");//执行run方法,在执行前需要取消权限检查Cat cat = new Cat();run.setAccessible(true);Object rs1 = run.invoke(cat);System.out.println(rs1)//5、获取private 修饰的eat(String name)方法，得到Method对象Method eat = c.getDeclaredMethod("eat",String.class);eat.setAccessible(true);Object rs2 = eat.invoke(cat,"鱼儿");System.out.println(rs2)}
}

打印结果如下图所示：run()方法执行后打印猫跑得贼快~~，返回null； eat()方法执行完，直接返回猫最爱吃:鱼儿

1.6 反射的应用

按照前面我们学习反射的套路，我们已经充分认识了什么是反射，以及反射的核心作用是用来获取类的各个组成部分并执行他们。但是由于同学们的经验有限，对于反射的具体应用场景还是很难感受到的（这个目前没有太好的办法，只能慢慢积累，等经验积累到一定程度，就会豁然开朗了）。

我们一直说反射使用来写框架的，接下来，我们就写一个简易的框架，简单窥探一下反射的应用。反射其实是非常强大的，这个案例也仅仅值小试牛刀。

需求是让我们写一个框架，能够将任意一个对象的属性名和属性值写到文件中去。不管这个对象有多少个属性，也不管这个对象的属性名是否相同。

1.先写好两个类，一个Student类和Teacher类
2.写一个ObjectFrame类代表框本架在ObjectFrame类中定义一个saveObject(Object obj)方法，用于将任意对象存到文件中去参数：Object obj: 就表示要存入文件中的对象3.编写方法内部的代码，往文件中存储对象的属性名和属性值1)参数obj对象中有哪些属性，属性名是什么实现值是什么，中有对象自己最清楚。2)接着就通过反射获取类的成员变量信息了（变量名、变量值）3)把变量名和变量值写到文件中去

public class ObjectFrame{public static void saveObject(Object obj) throws Exception{PrintStream ps = new PrintStream(new FileOutputStream("模块名\\src\\data.txt",true));//1)参数obj对象中有哪些属性，属性名是什么实现值是什么，中有对象自己最清楚。//2)接着就通过反射获取类的成员变量信息了（变量名、变量值）Class c = obj.getClass(); //获取字节码ps.println("---------"+class.getSimpleName()+"---------");Field[] fields = c.getDeclaredFields(); //获取所有成员变量//3)把变量名和变量值写到文件中去for(Field field : fields){String name = field.getName();Object value = field.get(obj)+"";ps.println(name);}ps.close();}
}

使用自己设计的框架，往文件中写入Student对象的信息和Teacher对象的信息。

先准备好Student类和Teacher类

public class Student{private String name;private int age;private char sex;private double height;private String hobby;
}

public class Teacher{private String name;private double salary;
}

public class Test5Frame{@Testpublic void save() throws Exception{Student s1 = new Student("黑马吴彦祖",45, '男', 185.3, "篮球，冰球，阅读");Teacher s2 = new Teacher("播妞",999.9);ObjectFrame.save(s1);ObjectFrame.save(s2);}
}

打开data.txt文件，内容如下图所示，就说明我们这个框架的功能已经实现了

三、注解

3.1 认识注解&定义注解

解和反射一样，都是用来做框架的，我们这里学习注解的目的其实是为了以后学习框架或者做框架做铺垫的。

那注解该怎么学呢？和反射的学习套路一样，我们先充分的认识注解，掌握注解的定义和使用格式，然后再学习它的应用场景。

先来认识一下什么是注解？

Java注解是代码中的特殊标记，比如@Override、@Test等，作用是：让其他程序根据注解信息决定怎么执行该程序。

比如：Junit框架的@Test注解可以用在方法上，用来标记这个方法是测试方法，被@Test标记的方法能够被Junit框架执行。

再比如：@Override注解可以用在方法上，用来标记这个方法是重写方法，被@Override注解标记的方法能够被IDEA识别进行语法检查。

注解不光可以用在方法上，还可以用在类上、变量上、构造器上等位置。

上面我们说的@Test注解、@Overide注解是别人定义好给我们用的，将来如果需要自己去开发框架，就需要我们自己定义注解。

接着我们学习自定义注解

自定义注解的格式如下图所示

比如：现在我们自定义一个MyTest注解

public @interface MyTest{String aaa();boolean bbb() default true;	//default true 表示默认值为true,使用时可以不赋值。String[] ccc();
}

定义好MyTest注解之后，我们可以使用MyTest注解在类上、方法上等位置做标记。注意使用注解时需要加@符号，如下

@MyTest1(aaa="牛魔王",ccc={"HTML","Java"})
public class AnnotationTest1{@MyTest(aaa="铁扇公主",bbb=false, ccc={"Python","前端","Java"})public void test1(){}
}

注意：注解的属性名如果是value的话，并且只有value没有默认值，使用注解时value名称可以省略。比如现在重新定义一个MyTest2注解

public @interface MyTest2{String value(); //特殊属性int age() default 10;
}

定义好MyTest2注解后，再将@MyTest2标记在类上，此时value属性名可以省略，代码如下

@MyTest2("孙悟空") //等价于 @MyTest2(value="孙悟空")
@MyTest1(aaa="牛魔王",ccc={"HTML","Java"})
public class AnnotationTest1{@MyTest(aaa="铁扇公主",bbb=false, ccc={"Python","前端","Java"})public void test1(){}
}

注解本质是什么呢？

想要搞清楚注解本质是什么东西，我们可以把注解的字节码进行反编译，使用XJad工具进行反编译。经过对MyTest1注解字节码反编译我们会发现：

1.MyTest1注解本质上是接口，每一个注解接口都继承子Annotation接口
2.MyTest1注解中的属性本质上是抽象方法
3.@MyTest1实际上是作为MyTest接口的实现类对象
4.@MyTest1(aaa="孙悟空",bbb=false,ccc={"Python","前端","Java"})里面的属性值，可以通过调用aaa()、bbb()、ccc()方法获取到。 【别着急，继续往下看，再解析注解时会用到】

（跳过）3.2 元注解

各位小伙伴，刚才我们已经认识了注解以及注解的基本使用。接下来我们还需要学习几种特殊的注解，叫做元注解。

什么是元注解？

元注解是修饰注解的注解。这句话虽然有一点饶，但是非常准确。我们看一个例子

（跳过）3.3 解析注解

各位小伙伴，通过前面的学习我们能够自己定义注解，也能够把自己定义的注解标记在类上或者方法上等位置，但是总感觉有点别扭，给类、方法、变量等加上注解后，我们也没有干什么呀！！！

接下来，我们就要做点什么。我们可以通过反射技术把类上、方法上、变量上的注解对象获取出来，然后通过调用方法就可以获取注解上的属性值了。我们把获取类上、方法上、变量上等位置注解及注解属性值的过程称为解析注解。

解析注解套路如下

四、动态代理

4.1 动态代理介绍、准备功能

各位同学，这节课我们学习一个Java的高级技术叫做动态代理。首先我们认识一下代理长什么样？我们以大明星“杨超越”例。

假设现在有一个大明星叫杨超越，它有唱歌和跳舞的本领，作为大明星是要用唱歌和跳舞来赚钱的，但是每次做节目，唱歌的时候要准备话筒、收钱，再唱歌；跳舞的时候也要准备场地、收钱、再唱歌。杨超越越觉得我擅长的做的事情是唱歌，和跳舞，但是每次唱歌和跳舞之前或者之后都要做一些繁琐的事情，有点烦。于是杨超越就找个一个经济公司，请了一个代理人，代理杨超越处理这些事情，如果有人想请杨超越演出，直接找代理人就可以了。如下图所示

我们说杨超越的代理是中介公司派的，那中介公司怎么知道，要派一个有唱歌和跳舞功能的代理呢？

解决这个问题，Java使用的是接口，杨超越想找代理，在Java中需要杨超越实现了一个接口，接口中规定要唱歌和跳舞的方法。Java就可以通过这个接口为杨超越生成一个代理对象，只要接口中有的方法代理对象也会有。

接下来我们就先把有唱歌和跳舞功能的接口，和实现接口的大明星类定义出来。

4.2 生成动态代理对象

下面我们写一个为BigStar生成动态代理对象的工具类。这里需要用Java为开发者提供的一个生成代理对象的类叫Proxy类。（注意是要java.lang.reflect包中的Proxy，而不是java.net包）

通过Proxy类的newInstance(…)方法可以为实现了同一接口的类生成代理对象。 调用方法时需要传递三个参数，该方法的参数解释可以查阅API文档，如下。

public class ProxyUtil {public static Star createProxy(BigStar bigStar){/* newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)参数1：用于指定一个类加载器参数2：指定生成的代理长什么样子，也就是有哪些方法参数3：用来指定生成的代理对象要干什么事情*/// Star starProxy = ProxyUtil.createProxy(s);// starProxy.sing("好日子") starProxy.dance()Star starProxy = (Star) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),new Class[]{Star.class}, new InvocationHandler() {@Override // 回调方法public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 代理对象要做的事情，会在这里写代码if(method.getName().equals("sing")){System.out.println("准备话筒，收钱20万");}else if(method.getName().equals("dance")){System.out.println("准备场地，收钱1000万");}return method.invoke(bigStar, args); // sing这个方法有返回值，不能不管}});return starProxy;}
}

invoke简化前的代码：

@Override // 回调方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 代理对象要做的事情，会在这里写代码if(method.getName().equals("sing")){System.out.println("准备话筒，收钱20万");return method.invoke(bigStar, args); // sing这个方法有返回值，不能不管}else if(method.getName().equals("dance")){System.out.println("准备场地，收钱1000万");return method.invoke(bigStar, args);} else { // 调用的方法既不是sing方法也不是dance方法，其他方法不需要代理，直接去找杨超越来执行这个方法即可return method.invoke(bigStar, args);}
}

因为Proxy.newProxyInstance返回的对象是Object类型，所以这里要强转下 (Star)

InvocationHandler是一个接口，接口不能直接创建对象，所以这里一般是直接new一个InvocationHandler的匿名内部类

invoke回调方法。假设代理写好后，我们在主程序中会写Star starProxy = ProxyUtil.createProxy(s);得到代理对象，然后starProxy.sing(“好日子”) starProxy.dance()让代理跑起来，这里调用sing和dance方法它们会去调用这里的invoke方法（因为代理干什么事由invoke决定）。由于invoke需要三个参数，所以sing或者dance在调用invoke的时候当然也会传入这三个参数。第一个参数：java会把当前代理对象当作一个Object，也就是starProxy。第二个参数：会把当前调用的方法当作Method传入，比如如果是sing调用invoke就代表sing方法。第三个参数：会把方法的参数通过Object数组给传进来

调用我们写好的ProxyUtil工具类，为BigStar对象生成代理对象

public class Test {public static void main(String[] args) {BigStar s = new BigStar("杨超越");Star starProxy = ProxyUtil.createProxy(s);String rs = starProxy.sing("好日子");System.out.println(rs);starProxy.dance();}
}

运行测试类，结果如下图所示

4.3 动态代理应用

现有如下代码

/***  用户业务接口*/
public interface UserService {// 登录功能void login(String loginName,String passWord) throws Exception;// 删除用户void deleteUsers() throws Exception;// 查询用户，返回数组的形式。String[] selectUsers() throws Exception;
}

下面有一个UserService接口的实现类，下面每一个方法中都有计算方法运行时间的代码。

/*** 用户业务实现类（面向接口编程）*/
public class UserServiceImpl implements UserService{@Overridepublic void login(String loginName, String passWord) throws Exception {long time1 = System.currentTimeMillis();if("admin".equals(loginName) && "123456".equals(passWord)){System.out.println("您登录成功，欢迎光临本系统~");}else {System.out.println("您登录失败，用户名或密码错误~");}Thread.sleep(1000);long time2 = System.currentTimeMillis();System.out.println("login方法耗时："+(time2-time1));}@Overridepublic void deleteUsers() throws Exception{long time1 = System.currentTimeMillis();System.out.println("成功删除了1万个用户~");Thread.sleep(1500);long time2 = System.currentTimeMillis();System.out.println("deleteUsers方法耗时："+(time2-time1));}@Overridepublic String[] selectUsers() throws Exception{long time1 = System.currentTimeMillis();System.out.println("查询出了3个用户");String[] names = {"张全蛋", "李二狗", "牛爱花"};Thread.sleep(500);long time2 = System.currentTimeMillis();System.out.println("selectUsers方法耗时："+(time2-time1));return names;}
}

观察上面代码发现有什么问题吗？

我们会发现每一个方法中计算耗时的代码都是重复的，我们可是学习了动态代理的高级程序员，怎么能忍受在每个方法中写重复代码呢！况且这些重复的代码并不属于UserSerivce的主要业务代码。

所以接下来我们打算，把计算每一个方法的耗时操作，交给代理对象来做。

先在UserService类中把计算耗时的代码删除，代码如下

/*** 用户业务实现类（面向接口编程）*/
public class UserServiceImpl implements UserService{@Overridepublic void login(String loginName, String passWord) throws Exception {if("admin".equals(loginName) && "123456".equals(passWord)){System.out.println("您登录成功，欢迎光临本系统~");}else {System.out.println("您登录失败，用户名或密码错误~");}Thread.sleep(1000);}@Overridepublic void deleteUsers() throws Exception{System.out.println("成功删除了1万个用户~");Thread.sleep(1500);}@Overridepublic String[] selectUsers() throws Exception{System.out.println("查询出了3个用户");String[] names = {"张全蛋", "李二狗", "牛爱花"};Thread.sleep(500);return names;}
}

然后为UserService生成一个动态代理对象，在动态代理中调用目标方法，在调用目标方法之前和之后记录毫秒值，并计算方法运行的时间。代码如下

public class ProxyUtil {public static UserService createProxy(UserService userService){UserService userServiceProxy = (UserService) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),new Class[]{UserService.class}, new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                     if(method.getName().equals("login") || method.getName().equals("deleteUsers") ||method.getName().equals("selectUsers")){//方法运行前记录毫秒值         long startTime = System.currentTimeMillis();//执行方法Object rs = method.invoke(userService, args);//执行方法后记录毫秒值long endTime = System.currentTimeMillis();System.out.println(method.getName() + "方法执行耗时：" + (endTime - startTime)/ 1000.0 + "s");return rs;} else {Object rs = method.invoke(userService, args);return rs;                                                                }}                                                                 });//返回代理对象return userServiceProxy;}
}

在测试类中为UserService创建代理对象

public class Test {public static void main(String[] args) throws Exception{// 1、创建用户业务对象。UserService userService = ProxyUtil.createProxy(new UserServiceImpl());// 2、调用用户业务的功能。userService.login("admin", "123456");System.out.println("----------------------------------");userService.deleteUsers();System.out.println("----------------------------------");String[] names = userService.selectUsers();System.out.println("查询到的用户是：" + Arrays.toString(names));System.out.println("----------------------------------");}
}

每次用代理对象调用方法时，都会执行InvocationHandler中的invoke方法。