java开发工程师入门第一阶段(04-java基础)

五.高级API

3.进程与线程

1.序：数据与指令的集合，而且程序是静态的
2. 进程：运行中的程序，给程序加入了时间的概念，不同时间进程有不同的状态，进程是动态的，代表OS中正在运行的程序
进程有独立性，动态性，并发性
3. 并行：相对来说资源比较充足，多个CPU同时并发处理多个不同的进程
4. 串行：相对来说资源不太充足，多个资源同时抢占公共资源，比如CPU
5. 线程：线程是OS能够进行运算调度的最小单位
一个进程可以拥有多个线程，当然，也可以只拥有一个线程，只有一个线程的进程称作单线程程序
注意：每个线程也有自己独立的内存空间，当然也有一部分共享区域用来保存共享的数据
6. 线程的几种状态以及线程状态之间的切换
1）新建状态：创建线程对象，申请PCB,对应的是new线程对象
2）就绪状态/可运行状态：万事俱备，只欠CPU,刚刚创建好的线程对象所有资源已经准备好，并且加入到了就绪队列之中
唯有等待操作系统的调度，只要分配了CPU,也就是时间片，当前线程可立即执行，对应的是start()
注意：调用start()并不会立即执行线程对象，这个是由OS的调度规则决定的。我们控制不了
3）执行/运行状态：就绪队列中的线程对象被OS选中，分配了时间片，正在执行
注意：只有就绪状态才能变成运行状态
4）阻塞状态：线程在执行过程中遇到了问题，比如锁阻塞、休眠阻塞、等待阻塞…
注意：我们的阻塞状态，等问题解决了以后/获取了临界资源【要抢占的公共资源】后
是加入到就绪队列中的，转为就绪状态，而不是转为运行状态直接执行
5）终止状态：线程成功执行完毕，释放资源，归还PCB
6）线程的挂起：正在运行中的线程，由于CPU分配的时间片已经用完，所以需要冻结当前线程运行的状态与各项信息
把它插入到就绪队列中，直到下次这个线程被调度执行时，重新恢复现场，继续执行

7.多线程编程实现方案一：extends Thread继承方式
1）自定义一个多线程类用来继承Thread类
2）重写run()里的业务【这个业务是自定义的】
3）创建线程对象【子类对象】
4）通过刚刚创建好的自定义线程类对象调用start()
注意1：不能调用run(),因为这样调用只会把run()看作一个普通的方法，并不会以多线程的方式启动程序
而且调用start()时，底层JVM会自动调用run()，执行我们自定义的业务
注意2：我们除了可以调用默认的父类无参构造以外，还可以调用Thread(String name),给自定义的线程对象起名字，相当于super(name);

package cn.tedu.thread;
//本类用于多线程编程实现方案2:实现Runnable接口来完成
public class TestThread2 {
    //4.创建自定义的对象--目标业务类对象
    public static void main(String[] args) {
        MyRunnable target = new MyRunnable();
        //5.创建多个线程对象
        /*如何以多线程的方式启动线程?需要调用start()
        * 自己没有,需要与Thread类建立联系:Thread (Runnable target)
        * 但是由于Runnable是接口,无法实例化,我们可以把接口实现类对象
        * 也就是我们的自定义类的对象作为构造函数的参数传入,与Thread类建立关系*/
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
//1.自定义多线程类
class MyRunnable implements Runnable{
    //2.添加接口中未实现的抽象方法,用于完成业务
    @Override
    public void run() {
        //写业务:打印10次当前正在执行的线程
        for (int i = 0; i < 10; i++) {
            /*3.问题:自定义类与父类接口Runnable中都没有获取线程名字的方法
            * 所以还需要从Thread类中找
            * currentThread():静态方法,获取当前正在执行的线程对象
            * getName():非静态方法,由刚刚获取的线程对象调用,返回当前线程对象的名字*/
            System.out.println(i+"="+Thread.currentThread().getName());
        }
    }
}

8.多线程编程实现方案二：implements Runnable 实现方式
1）自定义一个类实现接口Runnable
2) 实现接口中唯一一个抽象方法run()
3) 创建接口实现类的对象，这个对象是作为我们的目标业务对象【因为这个自定义类中包含了我们的业务】
4）创建Thread类线程对象，调用的构造函数是Thread(Runnable target)
5）通过创建好的Thread类线程对象调用start(),以多线程的方式启动同一个业务target
注意1：由于Runnable是一个接口，无法创建对象，所以我们传入的目标业务类，也就是接口实现类的对象
注意2：只有调用start()才能把线程对象加入到就绪队列中，以多线程的方式启动，但是：
接口实现类与接口都没有这个start(),所以我们需要创建Thread类的对象来调用start(),并把接口实现类对象交给Thread(target);
大家可以理解成“抱大腿”，创建的是Thread类的线程对象，我们只需要把业务告诉Thread类的对象就好啦
使用方式二的优势：
1）耦合性不强，没有继承，后续仍然可以继承别的类
2）采用的是实现接口的方式，后续仍然可以实现别的接口
3）可以给所有的线程对象统一业务，业务是保持一致的
4）面向接口编程，有利于我们写出更加优雅的代码

package cn.tedu.thread;
//本类用于多线程编程实现方案2:实现Runnable接口来完成
public class TestThread2 {
    //4.创建自定义的对象--目标业务类对象
    public static void main(String[] args) {
        MyRunnable target = new MyRunnable();
        //5.创建多个线程对象
        /*如何以多线程的方式启动线程?需要调用start()
        * 自己没有,需要与Thread类建立联系:Thread (Runnable target)
        * 但是由于Runnable是接口,无法实例化,我们可以把接口实现类对象
        * 也就是我们的自定义类的对象作为构造函数的参数传入,与Thread类建立关系*/
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        Thread t3 = new Thread(target);
        Thread t4 = new Thread(target);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
//1.自定义多线程类
class MyRunnable implements Runnable{
    //2.添加接口中未实现的抽象方法,用于完成业务
    @Override
    public void run() {
        //写业务:打印10次当前正在执行的线程
        for (int i = 0; i < 10; i++) {
            /*3.问题:自定义类与父类接口Runnable中都没有获取线程名字的方法
            * 所以还需要从Thread类中找
            * currentThread():静态方法,获取当前正在执行的线程对象
            * getName():非静态方法,由刚刚获取的线程对象调用,返回当前线程对象的名字*/
            System.out.println(i+"="+Thread.currentThread().getName());
        }
    }
}

4.同步锁

4.1synchronized同步关键字

synchronized (锁对象){undefined
需要同步的代码(也就是可能出现问题的操作共享数据的多条语句);}

4.2同步效果的使用有两个前提:

• 前提1：同步需要两个或者两个以上的线程(单线程无需考虑多线程安全问题)
• 前提2：多个线程间必须使用同一个锁(我上锁后其他人也能看到这个锁,不然我的锁锁不住其他人,就没有了上锁的效果)

4.3特点

1.synchronized同步关键字可以用来修饰代码块,称为同步代码块,使用的锁对象类型任意，但注意：必须唯一！
2. synchronized同步关键字可以用来修饰方法,称为同步方法
3. 同步的缺点是会降低程序的执行效率，但我们为了保证线程的安全,有些性能是必须要牺牲的
4. 但是为了性能,加锁的范围需要控制好,比如我们不需要给整个商场加锁,试衣间加锁就可以了

4.4案例

package cn.tedu.tickets;

/*本类用于改造多线程售票案例，解决数据安全问题*/
public class TestThreadV2 {
    public static void main(String[] args) {
        //5.创建多个线程对象并以多线程的方式运行
        TickectT2 t1 = new TickectT2();
        TickectT2 t2 = new TickectT2();
        TickectT2 t3 = new TickectT2();
        TickectT2 t4 = new TickectT2();
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//1.自定义多线程类
class TickectT2 extends Thread {
    //3.新增成员变量用来保存票数
    static int tickets = 100;
    //static Object o = new Object();

    //2.添加重写的run()来完成业务
    @Override
    public void run() {
        //3.创建循环结构用来卖票
        while (true) {
            //Ctrl+Alt+L调整代码缩进
            //7.添加同步代码块，解决数据安全问题
            //synchronized (new Object()) {
            /*static的Object的对象o这种写法也可以*/
            //synchronized (o) {
            /*我们每通过class关键字创建一个类，就会在工作空间中生成一个唯一对应的类名.class字节码文件
            * 这个类名.class对应的对象我们称之为这个类的字节码对象
            * 字节码对象极其重要，是反射技术的基石，字节码对象中包含了当前类所有的关键信息
            * 所以，用这样一个唯一且明确的对象作为同步代码块的锁对象，再合适不过了*/
            synchronized (TickectT2.class) {/*比较标准的写法*/
                if(tickets > 0){
                    //6.添加线程休眠，暴露问题
                    try {
                        Thread.sleep(10);//让线程休眠，增加线程状态切换的频率
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //4.1打印当前正在售票的线程名与票数-1
                    System.out.println(getName() + "=" + tickets--);
                }
                //4.2给程序设置一个出口，没有票的时候就停止卖票
                if (tickets <= 0) break;
            }
        }
    }
}

5.设计模式

5.1单例设计模式

单例模式可以说是大多数开发人员在实际中使用最多的，常见的Spring默认创建的bean就是单例模式的。
单例模式有很多好处，比如可节约系统内存空间，控制资源的使用。
其中单例模式最重要的是确保对象只有一个。
简单来说，保证一个类在内存中的对象就一个。
RunTime就是典型的单例设计，我们通过对RunTime类的分析，一窥究竟。

5.2单例设计模式1-饿汉式实现方式

package cn.tedu.design;
/*本类用于实现单例设计模式实现方案1:饿汉式*/
public class Singleton1 {
    public static void main(String[] args) {
        //5.在main()中，不通过对象，直接通过类名，调用静态方法
        MySingle single1 = MySingle.getSingle();
        MySingle single2 = MySingle.getSingle();
        //6.用==检验是否是同一个对象
        System.out.println(single1 == single2);//true
        System.out.println(single1);
        System.out.println(single2);
    }
}
//0.创建自己的单例程序
class MySingle{
    //1.提供构造方法，并将构造方法私有化
    /*1.构造方法私有化的目的:为了防止外界随意创建本类对象*/
    private MySingle(){ }

    //2.创建本类对象，并将对象也私有化
    //4.2由于静态资源只能调用静态资源，所以single对象也需要设置成静态
    private static MySingle single = new MySingle();

    //3.提供公共的访问方式，返回创建好的对象
    //4.1为了不通过对象，直接调用本方法，需要将本方法设置为静态
    public static MySingle getSingle(){
        return single;
    }
}

5.3单例设计模式2-懒汉式实现方式

package cn.tedu.design;
/*本类用于实现单例设计模式优化实现方案2:懒汉式
* 关于单例设计模式的两种实现方式：
* 1.饿汉式：不管你用不用这个类的对象，都会直接先创建一个
* 2.懒汉式：先不给创建这个类的对象，等你需要的时候再创建--延迟加载的思想
* 延迟加载的思想：是指不会在第一时间就把对象创建好占用内存
*               而是什么时候用到，什么时候再去创建对象
* 3.线程安全问题：由于我们存在唯一的对象single2,并且多条语句都操作了这个变量
*   如果将程序放到多线程的环境下，就容易出现数据安全的问题，所以解决方案：
*   1) 将3条语句都使用同步代码块包裹，保证同步排队的效果
*   2) 由于getSingle2()只有这3条语句，所以也可以将本方法设置为同步方法*/
public class Singleton2 {
    public static void main(String[] args) {
        //5.调用方法查看结果
        MySingle2 single1 = MySingle2.getSingle2();
        MySingle2 single2 = MySingle2.getSingle2();
        System.out.println(single1 == single2);
        System.out.println(single1);
        System.out.println(single2);
    }
}
//0.创建自己的单例程序
class MySingle2{
    //6.2创建一个静态的唯一的锁对象
    static Object o = new Object();
    //1.私有化本类的构造方法
    private MySingle2(){ }
    //2.创建的是本类对象的引用类型变量，用来保存对象的地址值，默认值是null
    private static MySingle2 single2 ;
    //3.提供公共的get方法
    synchronized public static MySingle2 getSingle2(){
        //4.判断之前是否创建过对象，之前创建过就直接走return
        //之前如果没有创建过，才走if，创建对象并将对象返回
        //6.有共享数据+多条语句操作数据，所以尽量提前处理，避免多线程数据安全隐患
        //6.1 解决方案1：加同步代码块
        //6.2 解决方案2：将本方法getSingle2()设置为同步方法
        //因为这个方法里所有的语句都需要同步
        synchronized (o) {//静态方法中使用的锁对象也得是静态的
            if (single2 == null) {//single2还是默认值，说明之前没有创建过对象
                single2 = new MySingle2();//没创建过才创建，并赋值给single2
            }
            return single2;
        }
    }
}

6.注解

6.1概述

注解很厉害，它可以增强我们的java代码，同时利用反射技术可以扩充实现很多功能。它们被广泛应用于三大框架底层。
传统我们通过xml文本文件声明方式(如下图,但是XML比较繁琐且不易检查)，而现在最主流的开发都是基于注解方式，代码量少，框架可以根据注解去自动生成很多代码，从而减少代码量，程序更易读。例如最火爆的SpringBoot就完全基于注解技术实现。

6.2分类

• JDK自带注解
• 元注解
• 自定义注解

6.3JDK注解

JDK注解的注解，就5个：
@Override :用来标识重写方法
@Deprecated标记就表明这个方法已经过时了，但我就要用，别提示我过期
@SuppressWarnings(“deprecation”) 忽略警告
@SafeVarargs jdk1.7出现，堆污染，不常用
@FunctionallInterface jdk1.8出现，配合函数式编程拉姆达表达式，不常用

6.4元注解

用来描述注解的注解，就5个：
@Target 注解用在哪里：类上、方法上、属性上等等
@Retention 注解的生命周期：源文件中、字节码文件中、运行中
@Inherited 允许子注解继承
@Documented 生成javadoc时会包含注解，不常用
@Repeatable注解为可重复类型注解，可以在同一个地方多次使用，不常用

6.5@Target ElementType…

ElementType.TYPE 应用于类的元素
ElementType.METHOD 应用于方法级
ElementType.FIELD 应用于字段或属性(成员变量)
ElementType.ANNOTATION_TYPE 应用于注解类型
ElementType.CONSTRUCTOR 应用于构造函数
ElementType.LOCAL_VARIABLE 应用于局部变量
ElementType.PACKAGE 应用于包声明
ElementType.PARAMETER 应用于方法的参数

6.6自定义注解

package cn.tedu.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/*本类用于完成自定义注解*/
public class TestAnnotation {
}
//2.通过@Target注解标记自定义注解的使用位置
/*3.通过元注解@Target规定自定义注解可以使用的位置
* 我们使用"ElementType.静态常量"的方式来指定自定义注解具体可以加在什么位置
* 而且，值可以写多个，格式:@Target({ElementType.XXX,ElementType.XXX}*/
@Target({ElementType.METHOD,ElementType.TYPE})//可以加在方法&类上
//3.通过@Retention注解标记自定义注解的生命周期
/*4.通过元注解@Retention规则自定义注解的生命周期
* 我们使用"RetentionPolicy.静态常量"的方式来指定自定义注解的生命周期
* 注意：值只能写一个：SOURCE CLASS RUNTIME 3选1 */
@Retention(RetentionPolicy.RUNTIME)//到运行时都有效
//1.定义自定义注解
/*1.首先注意：注解定义的语法与Java不同
* 2.定义自定义注解的格式：@interface 注解名*/
@interface Rice{
    //5.我们可以给注解进行功能增强--添加注解的属性
    /*5.注意：int age();不是方法的定义，而是给自定义注解添加了一个age属性*/
    //int age();//给自定义注解添加一个普通属性age,类型是int
    int age() default 0;//给自定义注解的普通属性赋予默认值0
    /*6.注解中还可以添加特殊属性value
    * 特殊属性的定义方式与普通属性一样，主要是使用方式不同
    * 注意：特殊属性的名字必须叫value,但是类型不做限制
    * 特殊属性也可以赋予默认值，格式与普通属性一样，不能简写
    * */
    //String value();//定义一个特殊属性value,类型是String
    String value() default "Lemon";//定义特殊属性并给特殊属性赋予默认值
}

//4.定义一个类用来测试自定义注解
//@Rice
class TestAnno{
    /*测试1：分别给TestAnno类 name属性 eat方法都添加Rice注解
    * 结论：属性上的注解报错了，说明自定义注解可以加在什么位置，由@Target决定*/
    //@Rice//报错了
    String name;
    /*测试2：当我们给Rice注解添加了一个age属性以后，@Rice注解使用时直接报错
    * 结论：当注解没有定义属性时，可以直接使用
    *      当注解定义了属性以后，必须给属性赋值，格式：@Rice(age = 10)*/
    /*测试3：给age属性赋予默认值以后，可以直接使用@Rice注解
    * 不需要给age属性赋值，因为age属性已经有默认值0了*/
    /*测试4：给Rice注解添加了特殊属性value以后，必须给属性赋值
    * 只不过特殊属性赋值时可以简写成 @Rice("Apple")
    * 测试5：如果特殊属性也赋予了默认值，那么可以直接使用这个注解
    * 如果要给注解的所有属性赋值，每条赋值都不能简写*/
    @Rice(age=10,value="orange")
    //@Rice("Apple")
    //@Rice(age = 10)
    //@Rice(10)//报错，不可以简写，普通属性没有这种格式
    public void eat(){
        System.out.println("干饭不积极，思想有问题");
    }
}

7.反射

7.1概述

Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，也有称作“自省”。
反射非常强大，它甚至能直接操作程序的私有属性。我们前面学习都有一个概念，被private封装的资源只能类内部访问，外部是不行的，但这个规定被反射赤裸裸的打破了。
反射就像一面镜子，它可以在运行时获取一个类的所有信息，可以获取到任何定义的信息（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。

7.2为什么要反射

如果想创建对象,我们直接new User(); 不是很方便嘛，为什么要去通过反射创建对象呢？

那我要先问你个问题了，你为什么要去餐馆吃饭呢？
例如：我们要吃个牛排大餐，如果我们自己创建，就什么都得管理。
好处是，每一步做什么我都很清晰，坏处是什么都得自己实现，那不是累死了。牛接生你管，吃什么你管，屠宰你管，运输你管，冷藏你管，烹饪你管，上桌你管。就拿做菜来说，你能有特级厨师做的好？
那怎么办呢？有句话说的好，专业的事情交给专业的人做，饲养交给农场主，屠宰交给刽子手，烹饪交给特级厨师。那我们干嘛呢？
我们翘起二郎腿直接拿过来吃就好了。
再者，饭店把东西做好，不能扔到地上，我们去捡着吃吧，那不是都成原始人了。那怎么办呢？很简单，把做好的东西放在一个容器中吧，如把牛排放在盘子里。

我们在后面的学习中,会学习框架,有一个框架Spring就是一个非常专业且功能强大的产品，它可以帮我们创建对象，管理对象。以后我无需手动new对象，直接从Spring提供的容器中的Beans获取即可。Beans底层其实就是一个Map<String,Object>，最终通过getBean(“user”)来获取。而这其中最核心的实现就是利用反射技术。

总结一句，类不是你创建的，是你同事或者直接是第三方公司，此时你要或得这个类的底层功能调用，就需要反射技术实现。有点抽象，别着急，我们做个案例，你就立马清晰。

7.3反射需要用到的API

7.3.1 获取字节码对象

Class.forName(“类的全路径”);
类名.class
对象.getClass();

7.3.2 常用方法

获取包名 类名
clazz.getPackage().getName()//包名
clazz.getSimpleName()//类名
clazz.getName()//完整类名

获取成员变量定义信息
getFields()//获取所有公开的成员变量,包括继承变量
getDeclaredFields()//获取本类定义的成员变量,包括私有,但不包括继承的变量
getField(变量名)
getDeclaredField(变量名)

获取构造方法定义信息
getConstructor(参数类型列表)//获取公开的构造方法
getConstructors()//获取所有的公开的构造方法
getDeclaredConstructors()//获取所有的构造方法,包括私有
getDeclaredConstructor(int.class,String.class)

获取方法定义信息
getMethods()//获取所有可见的方法,包括继承的方法
getMethod(方法名,参数类型列表)
getDeclaredMethods()//获取本类定义的的方法,包括私有,不包括继承的方法
getDeclaredMethod(方法名,int.class,String.class)

反射新建实例
clazz.newInstance();//执行无参构造创建对象
clazz.newInstance(666,”海绵宝宝”);//执行含参构造创建对象
clazz.getConstructor(int.class,String.class)//获取构造方法

反射调用成员变量
clazz.getDeclaredField(变量名);//获取变量
clazz.setAccessible(true);//使私有成员允许访问
f.set(实例,值);//为指定实例的变量赋值,静态变量,第一参数给null
f.get(实例);//访问指定实例变量的值,静态变量,第一参数给null

反射调用成员方法
Method m = Clazz.getDeclaredMethod(方法名,参数类型列表);
m.setAccessible(true);//使私有方法允许被调用
m.invoke(实例,参数数据);//让指定实例来执行该方法

7.4反射的应用

7.4.1 创建 : 测试物料类

package cn.tedu.review;
/*本类用于复习反射的物料类*/
public class Student {
    //1.定义成员变量
    private String name;
    public int age;

    //2.给被封装属性提供get与set方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    //3.生成本类的无参构造与全参构造
    public Student(){}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //4.提供本类的普通方法
    public void play(){
        System.out.println("今天大结局，放学后我要写1W行代码玩玩~");
    }
    public void sunDay(int n){
        System.out.println("国庆一共放"+n+"天");
    }
    //5.为了查看学生对象的具体属性与属性值，重写toString()
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

7.4.2 练习 : 获取类对象

package cn.tedu.reflection;

import org.junit.Test;
import java.lang.reflect.Method;
import java.util.Arrays;

/*本类用于反射的测试*/
public class TestReflect {
    //1.创建程序的入口函数main()--不用
    /*单元测试方法：是Java中最小的测试单位，使用灵活，推荐指数：5颗星
    * 语法要求：@Test + public + void + 没有参数
    * 注意：使用时需要导包：Add JUnit 4 library to the build path
    * 导包后的效果：import org.junit.Test
    * 执行方式：选中方法名前绿色的小三角，成功运行会有绿色的小对勾
    * */
    //2.通过单元测试方法，获取目标类Student对应的字节码对象
    @Test
    public void getClazz() throws ClassNotFoundException {
        //练习获取字节码对象的3种方式
        Class<?> clazz1 = Class.forName("cn.tedu.review.Student");
        Class<?> clazz2 = Student.class;
        Class<?> clazz3 = new Student().getClass();

        //打印的是Student类对应的字节码对象
        System.out.println(clazz1);//class cn.tedu.reflection.Student
        //获取当前字节码对象clazz1的名字
        System.out.println(clazz1.getName());//cn.tedu.reflection.Student
        //通过字节码对象，获取Student类的类名
        System.out.println(clazz2.getSimpleName());
        //通过字节码对象，获取Student类对应的包对象
        System.out.println(clazz3.getPackage());
        //通过字节码对象，先获取Student类对应的包对象，再获取这个包对象的名字
        System.out.println(clazz3.getPackage().getName());
    }

7.4.3 练习 : 获取成员变量

package cn.tedu.reflection;

import java.lang.reflect.Field;
import org.junit.Test;

/**本类用来测试反射*/
public class TestReflect {
	//3.通过单元测试方法练习引用类型数组的定义与遍历
    @Test
    public void getStu() {
        //1.创建Student类的3个对象
        Student s1 = new Student("张三", 3);
        Student s2 = new Student("李四", 4);
        Student s3 = new Student("王五", 5);
        //2.创建数组将刚刚的3个对象存入数组中
        Student[] s = {s1, s2, s3};
        //3.直接打印数组，查看数组中的元素
        System.out.println(Arrays.toString(s));
        //4.遍历学生数组，拿到每一个学生对象，做进一步的操作
        for (Student stu : s) {
            //System.out.println(stu);
            stu.play();//通过遍历到的对象，执行play()
            System.out.println(stu.age);//通过遍历到的对象，打印age属性
        }
    }
	//4.通过单元测试方法，获取Student类中的成员变量
    @Test
    public void getFie() throws ClassNotFoundException {
        //1.获取字节码对象
        Class<?> clazz = Class.forName("cn.tedu.review.Student");
        //2.通过字节码对象获取成员变量们
        Field[] fs = clazz.getFields();
        //3.遍历数组，获取每个成员变量的具体信息
        /*注意！目前成员变量的修饰符必须是public的才能获取到，不然，像默认修饰符也是获取不到的*/
        for(Field f : fs){
            System.out.println(f.getName());//通过本轮循环到的字段对象获取字段名
            System.out.println(f.getType());//通过本轮循环到的字段对象获取字段的类型
        }
    }
}

7.4.4 练习 : 通过字节码对象获取类的成员方法

package cn.tedu.reflection;

import java.lang.reflect.Method;
import java.util.Arrays;
import org.junit.Test;

/**本类用来测试反射*/
public class TestReflect {
    //5.通过单元测试方法，获取Student类中的成员方法
    @Test
    public void getFunction() {
        //1.获取字节码对象
        Class<?> clazz = Student.class;
        //2.通过字节码对象获取目标类中的成员方法们
        Method[] ms = clazz.getMethods();
        //3.通过高效for循环遍历数组，拿到每一个方法对象
        for (Method m : ms) {
            System.out.println(m);//直接打印遍历到的方法对象
            System.out.println(m.getName());//通过方法对象获取方法名
            Class<?>[] pt = m.getParameterTypes();//通过方法对象获取方法所有参数的数组
            System.out.println(Arrays.toString(pt));//打印方法参数的数组
        }
    }

7.4.5 练习 : 通过字节码对象获取类的构造方法

package cn.tedu.reflection;

import java.lang.reflect.Constructor;
import java.util.Arrays;
import org.junit.Test;

/**本类用来测试反射*/
public class TestReflect {
    //6.通过单元测试方法，获取Student类中的构造方法
    @Test
    public void getCons() {
        //1.获取字节码对象
        Class<?> clazz = new Student().getClass();
        //2.通过字节码对象获取目标类Student的构造方法们
        Constructor<?>[] cs = clazz.getConstructors();
        //3.通过高效for循环遍历数组
        for(Constructor c : cs){
            System.out.println(c.getName());//打印本轮遍历到的构造方法的名字
            Class[] pt = c.getParameterTypes();//通过本轮遍历到的构造函数对象获取构造函数的参数类型
            System.out.println(Arrays.toString(pt));//打印参数类型
        }
    }

7.4.6 练习 : 创建对象

package cn.tedu.reflection;

import java.lang.reflect.Constructor;

import org.junit.Test;

/**本类用来测试反射*/
public class TestReflect {
//7.通过单元测试方法，创建Student目标类的对象
    @Test
    public void getObject() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Student.class;
        //2.通过反射技术创建目标类的对象,注意抛出异常
        /*反射创建对象方案1：通过触发目标类的无参构造创建对象*/
        Object o = clazz.newInstance();
        System.out.println(o);//这一步已经获取到了对象Student{name='null', age=0}

        /*反射创建对象方案2：通过触发目标类的全参构造创建对象
        * 思路：
        * 1.先获取指定的构造函数对象,注意需要指定构造函数的参数，传入的是.class字节码对象
        * 2.通过刚刚获取到的构造函数对象创建Student目标类的对象，并且给对象的属性赋值
        * */
        //3.获取目标类中指定的全参构造
        Constructor<?> c = clazz.getConstructor(String.class, int.class);
        //System.out.println(c);
        //4.通过获取到的构造函数：创建对象+给对象的属性赋值
        Object o2 = c.newInstance("赵六", 6);
        System.out.println(o2);
    }
}

7.5暴力反射

指可以将程序中的私有的属性或者方法通过反射技术，暴力的获取到资源。

7.5.1 创建 : 测试物料类

package cn.tedu.review;
/*本类用作暴力反射测试的物料类*/
public class Person {
    //1.提供私有属性
    private String name;
    private int age;

    //2.提供私有方法
    private void save(int n,String s){
        System.out.println("save()..."+n+s);
    }
    private void update(){
        System.out.println("update()...");
    }
}

7.5.2练习 : 创建测试类

package tedu.reflection;

import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/*本类用于测试暴力反射*/
public class TestReflect2 {
   /*1.通过暴力反射获取与操作属性*/
    @Test
    public void getFie2() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Person.class;
        //2.获取指定的私有属性，传入的是属性名，注意抛出异常
        Field field = clazz.getDeclaredField("name");
        //3.根据刚刚获取到的属性对象，查看属性的信息
        System.out.println(field);//直接打印获取到的字段对象
        System.out.println(field.getType().getName());//java.lang.String
        System.out.println(field.getType());//class java.lang.String

        //4.设置属性的值
        //4.1 需要指定到底是给哪个对象的name属性设置值，没有对象就创建对象
        Object obj = clazz.newInstance();//触发无参构造利用反射创建对象

        //4.2暴力反射，需要设置私有可见权限！！！
        field.setAccessible(true);

        //4.3通过字段对象给刚刚创建好的对象obj设置属性值为海绵宝宝
        //field就是我们刚刚获取的name属性
        //set(m,n)--m是给哪个对象的name属性设置值，n是设置的值是什么
        field.set(obj,"海绵宝宝");
        //4.4 打印查看刚刚设置的属性值
        //field.get(m)--field代表的就是Person类的name属性，m是查看哪个对象的这个属性值
        System.out.println(field.get(obj));
    }

    //2.定义单元测试方法，利用暴力反射操作Person类中的私有属性age【巩固练习】
    @Test
    public void getFie3() throws Exception {
        //1.获取字节码对象
        Class<?> clazz = Person.class;
        //2.获取指定的私有属性对象
        Field f = clazz.getDeclaredField("age");
        //3.根据获取到的属性对象，查看相关信息，比如属性的类型
        System.out.println(f.getType().getName());
        //4.操作：设置属性的值：一共需要三个元素：给哪个对象【1】的哪个属性【2】设置一个什么值【3】
        //4.1 需要先指定给哪个对象的这个age属性设置值
        Object obj = clazz.newInstance();
        //4.2 在给属性设置值之前，需要设置权限私有可见，否则报错！
        f.setAccessible(true);
        //4.3通过刚刚获取到的age属性对象，给obj对象设置值
        f.set(obj,17);
        //4.4打印查看刚刚的属性值是否设置成功
        System.out.println(f.get(obj));
    }
    /*3.单元测试2：暴力反射获取和设置私有方法*/
    @Test
    public void getFunction() throws Exception {
        //1.获取Class字节码对象
        Class<?> clazz = Person.class;
        //2.通过暴力反射获取私有方法
        /*getDeclaredMethod(m,x,y,z...)
        * m:要获取的方法名
        * x,y,z...可变参数，是这个方法的参数类型，但注意要加“.class”
        * */
        Method method = clazz.getDeclaredMethod("save",int.class,String.class);
        //3.1没有对象就通过反射的方式创建对象
        Object obj = clazz.newInstance();
        //3.2 想要执行私有方法，也需要先设置私有可见
        method.setAccessible(true);
        /*invoke(o,x,y,z...),表示通过反射技术执行方法
        * o :要执行的是哪个对象的方法
        * x,y,z...:执行这个方法【method对象代表的之前获取到的save()】时需要传入的参数
        * */
        //3.3 通过反射技术invoke()，执行目标对象obj的目标方法method【save()】
        //save()被调用时传入的参数是100,"海绵宝宝"
        method.invoke(obj,100,"海绵宝宝");
    }
}