同学们，今天是我们基础阶段的最后一天，从后天开始，我们将进入WEB的新解决，做好总结，迎接新的挑战：
1.黑盒测试和白盒测试的区别？
2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
3.获取 Class对象有几种方式？他们的用途都在哪？
4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
5.注解在程序中都有哪些用途？
6.什么是元注解？
7.文件从编译到运行可以分为哪三个时期？
8.思考：想让一个类加载进内存，有几种方式？

1.黑盒测试和白盒测试的区别？
黑河测试：不需要写代码，输入数据，对得到的数据进行分析，对程序的运行的过程不可知；
白盒测试：需要写代码，对程序的执行过程、逻辑、性能等进行测试分析。

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
反射：将类的各个组成部分（成员变量、成员方法、构造方法等）封装成其他对象

3.获取 Class对象有几种方式？他们的用途都在哪？
（1）Class.forName("全类名")：将字节码文件加载进内存，返回Class对象。多用于配置文件，将类名定义在配置文件中。读取文件，加载类；
（2）类名.class：通过类名的属性class获取，多用于参数的传递；
（3）对象.getClass()：getClass()方法在Object类中定义着，多用于对象的获取字节码的方式。


4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
Class对象调用getDeclaredFields()和getDeclaredMethods()可以获取所有的成员变量和成员方法，包括私有的。

5.注解在程序中都有哪些用途？
（1）编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
（2）代码分析：通过代码里标识的注解对代码进行分析【使用反射】
（3）编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【如Override】

6.什么是元注解？
元注解：对注解的注解，常用的如：
@Target：描述注解能够作用的位置；
@Retention：描述注解被保留的阶段；
@Documented：描述注解是否被抽取到api文档中；
@Inherited：描述注解是否被子类继承。

7.文件从编译到运行可以分为哪三个时期？
Source源代码阶段，该阶段.java文件被编译成.class字节码文件，但是类信息还没有被加载进内存；
Class类对象阶段，该阶段类信息被加载进内存，类的各个组成部分被封装成其他对象；
Runtime运行时阶段，该阶段类已经被使用，或调用静态成员，或建立对象。

8.思考：想让一个类加载进内存，有几种方式？
（1）Class.forName("全类名")：将字节码文件加载进内存，返回Class对象；
（2）调用类的静态成员方法或者访问类的静态成员变量；
（3）建立对象。

1.黑盒测试就是通过程序运行结果来判断是否存在bug，不需要写代码进行测试，只是将运行结果和期望结果做比较；白盒测试需要编写代码，更注重程序的运行流程。
2.将类的组成部分封装成为对象就是反射；可以在程序运行过程中，操作这些对象。 可以解耦，提高程序的可扩展性。
3.获取class对象有三种方式：类名.class，类对象名.getclass()，Class.forName("全类名")；
        1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
                * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
        2. 类名.class：通过类名的属性class获取
                * 多用于参数的传递
        3. 对象.getClass()：getClass()方法在Object类中定义着。
                * 多用于对象的获取字节码的方式
4.使用setAccessible(true):暴力反射忽略访问权限修饰符的安全检查。
5.
编译检查：通过代码里的标识的注解让编译器能够实现基本的编译检查。
编写文档：通过代码里标识的注解生成文档。
代码分析：通过代码里标识的注解对代码进行分析。
6.元注解就是对注解的注解。
7.三个时期，首先是存在硬盘里的物理文件时期，.java文件通过javac命令编译成为.class文件存储在硬盘里称为源代码阶段，通过类加载器进入到内存时称为类对象阶段，创建类的对象实例时称为运行阶段。
8.三种方式，创建对象时，类会加载进内存，通过Class.forName("全类名")：将字节码文件加载进内存，通过类加载器loadClass()方法来加载，然后调用类的newInstance()方法实例化对象。

1.黑盒测试和白盒测试的区别？黑盒测试，不需要写代码，输入一个值，看得到的结果是不是期望值。
白盒测试需要写代码，关注程序具体的执行流程。
2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
将类的各个组成部分封装为其他对象。在不改变类的任何代码前提下，可以创造任意类的对象。
可以在程序运行过程中，操作这些对象。可以解耦，提高程序的可扩展性。
3.获取 Class对象有几种方式？他们的用途都在哪？
1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
                * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
        2. 类名.class：通过类名的属性class获取
                * 多用于参数的传递
        3. 对象.getClass()：getClass()方法在Object类中定义着。
                * 多用于对象的获取字节码的方式
4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
忽略访问权限修饰符的安全检查* setAccessible(true):暴力反射来获取成员变量对象。
Method[] getDeclaredMethods()获取成员方法对象。
5.注解在程序中都有哪些用途？
对元素进行说明，注释，是说明程序的给计算机看的。
6.什么是元注解？
是用于描述注解的注解。
7.文件从编译到运行可以分为哪三个时期？
第一步(编译): 创建完源文件之后，程序会先被编译为.class文件。 第二步（运行）：java类运行的过程大概可分为两个过程：1、类的加载  2、类的执行。
8.思考：想让一个类加载进内存，有几种方式？

new一个类的对象，调用类的静态成员和静态方法，使用java.lang.reflect包的方法进行发射调用。

1.黑盒测试和白盒测试的区别？

答：        ①：黑盒测试只看传入的参数和输出的结果（不需要写代码）。
        ②：白盒测试则是看程序编码执行过程（需要写代码）。

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？

答：        ①：反射 = 框架设计的灵魂！，主要作用：将类的各个组成部分（成员变量，成员方法，构造方法）封装为其他对象。
        ②：可以在程序运行过程中，操作这些对象。
            可以解耦合，提高程序的可扩展性。
3.获取 Class对象有几种方式？他们的用途都在哪？

答：获取Class对象有三种方式分别为：
①：Class.forName("全类名")：将字节码文件加载进内存，返回Class对象；多用于配置文件，将类名定义在配置文件中。读取文件和加载类。
②：类名.Class：通过类名的属性Class获取；多用于参数的传递。
③：对象.getClass():getClass()方法在object类中定义着。
        多用于对象的获取字节码的方式

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？

答：①：获取私有成员变量对象：
        Field[] getDeclaredFields()  可获得所有成员变量
        Field getDeclaredField(String name)获取指定的成员变量
    ②：获取私有成员方法对象：
        Method[] getDeclaredMethods()   获取所有的成员方法
        Method[] getDeclaredMethod(string name,类<?>...parameterTypes)   
5.注解在程序中都有哪些用途？

答：注解可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明。
6.什么是元注解？

答：负责注解其它注解。

7.文件从编译到运行可以分为哪三个时期？

答：        ①：Source源代码阶段；
        ②：Class类对象阶段；
        ③：Runtime运行时阶段。
8.思考：想让一个类加载进内存，有几种方式？
答:

林少伟

1.黑盒测试和白盒测试的区别？
答：1.黑盒测试只关注结果，不关注代码运行流程与逻辑。
       2.白盒测试关注代码运行流畅，理解代码逻辑，并且需要自己写代码测试代码。 前者《黑盒测试》只关心结果，后者<白盒测试>关注过程与结果
2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
答：1.反射是我们直接用类名.class调用类加载器机制把字节码文件加载进内存封装成其他对象
      2.反射在class字节码阶段使用
3.获取 Class对象有几种方式？他们的用途都在哪？
答：三种方式
    1.ClassName（全路径类名）将字节码文件加载进内场返回一个class对象，其实这里用的是类加载器：多用于配置文件方式
    2.类名.class通过类名的属性获取class对象：多用于传参
   3.创建该类的对象用对象名。getclass获取：多用于对象的获取字节码方式
4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
  答：1.选用方法中加了Declared的方法可以无视修饰符
5.注解在程序中都有哪些用途？
答：1.用于表示此方法的作用，让人知道此方法是干嘛的，如重写的注解  @Override 让人一看就知道这个方式是重写的父类的方法
       2.可以编写文档，通过代码里表示的注解生成doc帮助文档
       3.代码分析：通过代码里表示的注解对代码进行检测如：@Functional Interface 标注此接口是个函数式接口那此接口就只能定义一个抽象方法，若定义多个注解就会报错
6.什么是元注解？
答：在修饰符后面加上@interface的接口就叫元注解，是我们自定义的注解。用于描述注解的注解
7.文件从编译到运行可以分为哪三个时期？
1.源码阶段《编写阶段》-------->class类对象阶段《编译期》----------运行期阶段
8.思考：想让一个类加载进内存，有几种方式？
答：1.创建对象方式：A a= new A（）；
       2.反射方式：A.class  Class  cls = A.class
       3.类加载器：A.class.ClassName（类的全路径） 返回一个class对象

1.黑盒测试和白盒测试的区别？黑盒测试是只关注输入和输出，不关注中间的处理过程，无法对过程的代码进行控制。
白盒测试需要写代码，对代码程序的执行流程和执行效率进行检测。
比如要对游戏中的人物走一段路来检测检测，黑盒只能看是否达到结果，而不能控制完成的时间。如果中间的寻路算法出现问题，绕远，黑盒是不能进行纠正的。而白盒可以。

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
反射是将类的各个组成部分（属性成员方法构造方法）封装成数组对象。
通过配置文件来修改类名、方法名等，而不用修改源代码；
使用反射有两个好处：
解耦，提高程序的可拓展性
可以在程序运行过程中，操作这些对象。

3.获取 Class对象有几种方式？他们的用途都在哪？
（1）在源代码的阶段中，通过forName方法，传递类名，来创建；多用于配置文件，将类名定义在配置文件中，读取文件，加载类
（2）在class类阶段，通过类名.class来创建；多用于参数的传递
（3）在运行阶段，通过创建类对象，用对象名.getClass来创建。多用于对象断恶获取字节码的方式

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
使用暴力反射 setAccessible（true）

5.注解在程序中都有哪些用途？
注解有三种用途：编写文档，通过代码里标识的注解生成文档；代码分析，通过代码里标识的注解对代码进行分析；编译检查，通过代码里标识的注解让编译器能够实现基本的编译检查。

6.什么是元注解？
对注解的注解，写在注解上面的注解。有四个：Target，描述注解能够作用的位置；Retention，描述注解被保留的阶段，通常使用runtime；Documented，描述注解是否被抽取到api文档中；Inherited，描述注解是否被子类继承

7.文件从编译到运行可以分为哪三个时期？
三个时期：编写java文件的源文件阶段；使用加载器加载到内存的class类中；运行阶段

8.思考：想让一个类加载进内存，有几种方式？

（1）通过类的加载器 ，我们就是通过这种方式把配置文件加载进内存中。这是可以自己指定加载器，而不像其他两个是使用本类的加载器。
（2）通过创建class类对象，创建实例，或者是通过构造器方法对象去创建实例
（3）通过new创建对象。这属于静态加载，消耗的资源大。

1.黑盒测试和白盒测试的区别？
黑盒测试：不需要写代码，只需要给输入值，看程序输出结果是否能达到输出预期的效果
白盒测试：需要使用代码对程序的执行流程和执行效率进行检测，并分析，看程序输出结果是否能达到输出预期的效果

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
反射：将类的各个组成部分封装成其他对象
反射应用场景：反射运用到框架居多,因为通过反射我们在使用框架时可以不需要修改里面的代码只需要修改配置文件就可以创建任意对象和调用任意方法.并且在程序运行的时候去调用这些对象,提高程序的扩展性,实现代码解耦
反射好处：(1) 可以在程序运行过程中，操作这些对象
(2)可以解耦，提高程序的可扩展性

3.获取 Class对象有几种方式？他们的用途都在哪？
(1)Class.forName获取，多用于配置文件
(2) 类名.class获取，多用于参数的传递
(3)对象.getClass()获取，多用于对象的获取字节码的方式

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
(1) 可以用Class对象调用 Field[] getDeclaredFields() 方法获取所有的成员变量，不考虑修饰符或Field getDeclaredField(String name)  获取指定名称的成员变量，不考虑修饰符获取指定的成员变量。如果想对该成员变量进行设置操作，需要用成员变量对象调用setAccessible(true)方法，忽略访问权限修饰符的检查进行设置。
(2) 可以用Class对象调用Method[] getDeclaredMethods()  获取所有的成员方法，不考虑修饰符或Method getDeclaredMethod(String name, 类<?>... parameterTypes) 获取指定的成员方法，不考虑修饰符。如果想对该成员方法进行调用私有方法操作，需要用成员方法对象调用setAccessible(true)方法，忽略访问权限修饰符的检查进行设置。

5.注解在程序中都有哪些用途？
(1)编写文档：通过代码里标识的注解生成文档(生成文档doc文档)
(2)代码分析:通过代码里标注的注解对代码进行分析(使用反射).
(3)编译检查:被标注的代码会自动检查,如果不符合注解的要求则报错,例如:@Override,@FunctionalInterface

6.什么是元注解？
元注解：用于描述注解的注解
例如：
@Target：描述该注解可以标记在什么位置
Element.TYPE        标记在类上            
Element.METHOD        标记在方法上                 
Element.FIELD        标记在成员变量上
@Retention：描述该注解被保留的阶段                     
常使用RetentionPolicy.RUNTIME，表示该注解保留在.class文件中，可以被JVM读取
@Documented：描述注解是否被抽取到api文档中
@Inherited：描述注解是否被子类继承

7.文件从编译到运行可以分为哪三个时期？
(1)Source源代码时期
(2)Class类对象时期
(3)Runtime运行时时期

8.思考：想让一个类加载进内存，有几种方式？
(1)new 类名
(2)访问，操作静态成员属性或方法
(3)反射,Class.forName("全类名")
(4)类名.getClassLoader()加载

1.黑盒测试和白盒测试的区别？
答：黑盒测试：不用关注程序的执行流程，不用写代码，只是关注输入和输出的数据是否正确。
白盒测试：关注程序的执行流程和执行效率 ，需要自己写一下代码，或者改一些代码。

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
答：反射是将类的各个部分封装为其他的对象中，将.class字节码文件封装到class类中。
反射的应用场景：网站的运行，游戏等程序的更新，不用停服务器。直接修改对象。
反射的好处：1.在程序运行的过程中可以操作这些对象。（维护系统更加容易，不用停服务器）
                     2.解耦合，提高程序的扩展性（类和方法解耦）


3.获取 Class对象有几种方式？他们的用途都在哪？
答：三种。
【1】class.forName（“全类名”） 多用于配置文件，将类名定义在配置文件中。读取文件，加载类等。

【2】类名.class  多用于参数的传递

【3】对象.getClass()  多用于对象的获取字节码的方式

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
答: 可以通过忽略访问权限修饰符安全检查

       setAccessible(true):暴力反射

5.注解在程序中都有哪些用途？
【1】编写文档：通过代码的标识的注解生成文档（doc文档），通过编译javacdoc命令生成文档。
【2】代码分析：通过代码里标识的注解对代码进行分析（自定义注解）
【3】编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查（Override，FunctionIntrface）


6.什么是元注解？
答：用来描述注解的注释。

7.文件从编译到运行可以分为哪三个时期？
答：【1】.Java文件转换为.class后的Sourse源代码阶段。【2】.class文件加载到内存时的Class类对象阶段。【3】程序运行时的Runntime阶段

8.思考：想让一个类加载进内存，有几种方式
答：1. Class.forName("全类名") 2.类名.Class 3.主方法new对象的方式 4.调用类的其他静态方法。

1.黑盒测试和白盒测试的区别？

黑盒测试:不需要编写代码,只需要知道程序执行后的结果是否是期望值;
白盒测试:需要编写代码,需要关注程序执行的每一个步骤;

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？

将类的各个组成部分（成员方法Method，成员变量Field，构造方法Constructor）封装为其他对象，这就是反射机制;反射多用于框架;因为框架可以帮我们程序降低耦合度;我们可以在程序运行过程中，操作这些对象（字节码文件）;

3.获取 Class对象有几种方式？他们的用途都在哪？

3种,Class.forName( 全类名 )丶类的对象名.getClass ( )丶类名.class( );用途:一般用在反射中，可以通过class字节码对象进行get成员方法、构造器、成员变量

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？

Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
Method[] getDeclaredMethods()  获取所有的成员方法，不考虑修饰符
暴力反射;

5.注解在程序中都有哪些用途？

可以用来说明程序也可以用来作为注解的元注解

6.什么是元注解？

用来描述注解的;

7.文件从编译到运行可以分为哪三个时期？

源代码->编译->运行

8.思考：想让一个类加载进内存，有几种方式？

三种:反射，main方法里面new，类加载器

1.黑盒测试和白盒测试的区别？
黑盒测试：不需要写代码，只要给一个值输入，然后看程序运行完之后输出的值是否跟期望值相同。
白盒测试：需要些代码，需要关注具体的程序运行情况，遇到问题需要修改。
2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
反射就是将类的各个组成部分封装为其他对象，今天学成员变量封装成File数组，构造方法封装到constructor数组，成员方法封装到method数组中，这就是反射机制，反射是框架的灵魂，设计框架时会大量运用。反射的好处就是1、可以在程序运行过程中操作这些对象，2、解耦合，提高程序的扩张性。                                                            
3.获取 Class对象有几种方式？他们的用途都在哪？
有三种方法，1、在源代码阶段，需要用到Class类中的静态方法forName（）参数传递全类名的字符串形式来获取Class对象。2、在Class类对象阶段，可以用类名点class可以获取到Class对象。 3、在运行阶段，可以通过创建类对象然后用类对象点getClass方法来获取Class对象，当然这个阶段也可以使用前面两种方式获取Class对象，无论哪种获取的Class对象都是同一个。
4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
首先通过Class对象使用getDeclaredFile方法获得私有成员变量，用getDeclaredmethod获得私有成员方法对象。然后这两个对象再通过使用暴力放射方法setAccessible（）方法，参数传递true就可以忽略访问权限进行获取。
5.注解在程序中都有哪些用途？
1、编写文档：通过代码里标识的注解生成api文档。
2、代码分析：通过代码里标识的注解对代码进行分析，要使用反射。
3、编译检查：通过代码里标识的注解让编译期能够实现基本的编译检查，例如Override
6.什么是元注解？
元注解就是对注解描述的注解。
7.文件从编译到运行可以分为哪三个时期？
1、一开始是源代码时期。2、字节码文件加载进内存，产生Class类对象。3、能够创建类对象，运行程序的runtime时期。
8.思考：想让一个类加载进内存，有几种方式？
1.用类名.forName（全类名）加载该类进内存
2.通过类加载器loadClass()方法来加载，然后调用类的newInstance()方法实例化对象

1.黑盒测试和白盒测试的区别？
黑盒测试：不需要输入代码，输入一个值，测试程序能否给出一个期望值
白盒测试：需要输入代码，关注的是程序的执行流程

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
反射是框架设计的灵魂，将类的各个组成部分封装为其他对象，这就是反射机制
好处：
（1）在程序运行过程中，可以操作这些对象
（2）可以解耦合，提高程序扩展性

3.获取 Class对象有几种方式？他们的用途都在哪？
（1） Class.forName("全类名")；多用于配置文件，将类名定义在配置文件中。读取文件，加载类
（2） 类名.class；多用于参数的传递
（3） 对象.getClass()；多用于对象的获取字节码的方式

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
忽略访问权限修饰符的安全检查：setAccessible(true):暴力反射

5.注解在程序中都有哪些用途？
编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
代码分析：通过代码里标识的注解对代码进行分析【使用反射】
编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

6.什么是元注解？
用于描述注解的注解

7.文件从编译到运行可以分为哪三个时期？
Source源代码阶段；Class类对象阶段；Runtime运行时阶段

8.思考：想让一个类加载进内存，有几种方式？
(1)Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
(2)通过new关键字创建对象实例
(3)通过类加载器loadClass()方法来加载，然后调用类的newInstance()方法实例化对象

1.黑盒测试和白盒测试的区别？黑盒不需要写代码,只关注程序运行的结果,不关心程序具体的步骤
白盒需要写代码,关注程序中的代码运行状况
===========================================================
2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
反射：将类的各个组成部分封装为其他对象，这就是反射机制
好处：
1. 可以在程序运行过程中，操作这些对象。
2. 可以解耦，提高程序的可扩展性。

===========================================================
3.获取 Class对象有几种方式？他们的用途都在哪？
三种方式
1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
* 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
2. 类名.class：通过类名的属性class获取
* 多用于参数的传递
3. 对象.getClass()：getClass()方法在Object类中定义着。
* 多用于对象的获取字节码的方式
===========================================================
4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
Constructor<?>[] getDeclaredConstructors()  
===========================================================
5.注解在程序中都有哪些用途？
说明程序的。给计算机看的
作用分类：①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】②代码分析：通过代码里标识的注解对代码进行分析【使用反射】③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
===========================================================
6.什么是元注解？
元注解：用于描述注解的注解
@Target：描述注解能够作用的位置
ElementType取值：
TYPE：可以作用于类上
METHOD：可以作用于方法上
FIELD：可以作用于成员变量上
@Retention：描述注解被保留的阶段
@Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
@Documented：描述注解是否被抽取到api文档中
@Inherited：描述注解是否被子类继承

===========================================================
7.文件从编译到运行可以分为哪三个时期？
1编写一个类-------编写
2编译,将和这个Java类变为.class字节码文件-----编译
3.运行.Class 文件产生对象-------运行

===========================================================
8.思考：想让一个类加载进内存，有几种方式？

三种方式.

反射
在Main中new
类加载器

1.黑盒测试和白盒测试的区别？
黑盒测试：只关注程序的输入输出，不关注具体的实现流程，不写代码
白盒测试：需要写代码，对代码的程序执行流程和执行效率进行检测

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
反射是框架的设计灵魂，将类的各个组成部分封装为其他对象，反射可以在执行阶段动态的操作类中的信息，还可以解耦合

3.获取 Class对象有几种方式？他们的用途都在哪？
有三种方式
class.forname()此方法的参数需要全文件名，多用于配置文件
,类名.class，通过类名的属性class获取,多用于参数的传递.
创建类的对象，对象名.getclass用于对象字节码的获取

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
暴力反射：setAccessible(true)

5.注解在程序中都有哪些用途？
编写文档：通过代码里标识的注解生成文档
代码分析：通过代码里标识的注解对代码进行分析
编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查

6.什么是元注解？
元注解是JDK提供的用于描述注解的注解.可以用来注解我们自己写的注解

7.文件从编译到运行可以分为哪三个时期？
源代码阶段,类对象阶段,运行期

1.黑盒测试和白盒测试的区别？
答：黑盒一个是只看输入和输出！不关注现实流程，不写代码。
白盒测试：测试人员看的，关注代码的流程，对代码和程序进行检查
2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
答 ：反射：将类的各个组成部分封装为其他对象；
反射在程序中第一可以在程序运行中，操作这些对象。第二可以解耦，提高程序的可扩展性
3.获取 Class对象有几种方式？他们的用途都在哪？
答：1.class.forName（“全类名”）：将字节码文件加载进内存，返回Class对象
（多用于配置文件，将类名定义在配置文件中。读取文件，加载类）
2.类名.class：通过类名的属性class获取
（多用于参数的传递）
3.对象.getClass（）：getClass（）方法在Object类中定义着。
（多用于对象获取字节码的方式）
4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
答：需要忽略访问权限修饰符的安全检查 SetAccessible（true）：暴力反射
才能获取被私有的成员变量对象和成员方法对象。
5.注解在程序中都有哪些用途？
答：编写文档：通过代码里标识的注解生成文档

代码分析：通过代码里标识的注解对代码进行分析

编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查

6.什么是元注解？
答：描述注解的注解就是元注解
7.文件从编译到运行可以分为哪三个时期？
答：从Source源代码阶段-->Class类对象阶段--->Runtime运行时阶段。
8.思考：想让一个类加载进内存，有几种方式？
答：2种
1.通过new关键字来创建Test的实例对象。
2. 通过Class.forName()来加载类，然后调用类的newInstance()方法实例化对象。

1.黑盒测试和白盒测试的区别？

***黑盒测试只注重程序运行的结果，不关心程序内部是如何运行的。白盒测试关注的不仅是结果，还关注程序内部运行的方法，经常要用来优化程序内部代码的方法。

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？

***反射就是把一个类对象的各个组成部分封装成其他的对象，使用的时候可以对这个对象的各个部分灵活的调用，每次调用对象的地址值都会是同一个地址值，优化程序。

3.获取 Class对象有几种方式？他们的用途都在哪？

***有三种方式，1. 类名.class获取，多用来进行参数的传递。2.Class.forName("全类名")，多数用来进行文件的配置，将类名定义在配置文件中，读取文件，加载类。3.对象.getClass ( )，多数用来获取对象的字节码。

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？

***Class对象.getDeclaredFields( )可以获取所有的对象包括被私有的成员变量对象，其中( )中可以传递被私有的成员变量对象单独获取。Class对象.getDeclaredConstructorss( )可以获取所有的对象包括被私有的成员方法对象，其中( )中可以传递被私有的成员方法对象单独获取。

5.注解在程序中都有哪些用途？

***注解是类似于标签，是用来说明程序的，可以对代码进行编写的检查、代码的识别、以及生成文档文件等一系列操作，也可以自定义注解实现想要实现的其他操作。

6.什么是元注解？

***元注解就是作用在注解上的注解，用来对注解的一系列操作。

7.文件从编译到运行可以分为哪三个时期？

***1.编译时期。2.class文件转换为Class对象时期。3.运行时期。

8.思考：想让一个类加载进内存，有几种方式？

***3种，1.直接new 类对象，2.通过Class类生成 ，3.通过注解识别生成。


----------------黄成成

1.黑盒测试和白盒测试的区别？黑盒测试：给个值直接看结果不看过程
白盒测试：更关注测试过程，需要写代码
2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
将类的各个组成部分封装为其他对象；半成品软件，在框架的基础上进行软件开发，简化代码
3.获取 Class对象有几种方式？他们的用途都在哪？class.name多用于配置文件
类名.class多用于参数传递
对象.getclass多用于对象的字节码的方式
4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
setAccessible(true):暴力反射
5.注解在程序中都有哪些用途？
编写文档：通过代码里标识的注解生成文档，生成doc文档
代码分析：通过代码里标识的注解进行分析，使用反射
编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查，Override
6.什么是元注解？
用于描述注解的注解
7.文件从编译到运行可以分为哪三个时期？
源代码阶段，class类对象阶段，运行期
8.思考：想让一个类加载进内存，有几种方式？
new关键字。classloader类装载器。类名.forName（类全名）

1.黑盒测试和白盒测试的区别？

黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值；

白盒测试：需要写代码的。关注程序具体的执行流程



2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？

将类的各个组成部分封装为其他对象，这就是反射机制。

为什么要使用反射：

1. 可以在程序运行过程中，动态操作这些对象。
   1. 可以解耦，提高程序的可扩展性

3.获取 Class对象有几种方式？他们的用途都在哪？

①：类名.class：多用于参数传递；

②：class.forName（“全类名”）：多用于配置文件中；

③：对象.getclass多用于对象的获取字节码方式



4.如何获取Class对象中被私有的成员变量对象和成员方法对象？

Class对象调用Field[] getDeclaredFields()，就可以获取私有的成员变量对象；

Class对象调用Method[] getDeclaredMethods() ，就可以获取私有的成员方法对象。



5.注解在程序中都有哪些用途？

作用分类：

                ①编写文档：通过代码里标识的注解生成文档；

                ②代码分析：通过代码里标识的注解对代码进行分析；

                ③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查。



6.什么是元注解？

用于描述注解的注解

                 @Target：描述注解能够作用的位置

                 @Retention：描述注解被保留的阶段

                 @Documented：描述注解是否被抽取到api文档中

                 @Inherited：描述注解是否被子类继承

7.文件从编译到运行可以分为哪三个时期？

源代码阶段  类对象阶段  运行时阶段



8.思考：想让一个类加载进内存，有几种方式？

有四种方式：

调用类的静态方法或者访问类的静态成员变量；

类名.class；

class.forName（“全类名”）；

对象.getclass。

1.黑盒测试和白盒测试的区别？
黑盒测试：输入数据，查看返回值。不关心过程。
白盒测试：输入数据，查看返回值。关注执行过程，需要编写代码。

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
反射：将类的各个组成部分封装为其他对象。
好处：1.可以在程序运行过程中，操作这些对象。2.可以解耦，提高程序的可扩展性。

3.获取 Class对象有几种方式？他们的用途都在哪？
三种：  1.类名.class：多用于参数的传递。
        2.对象.getClass()：多用于对象的获取字节码的方式。
        3. Class.forName("全类名")：多用于配置文件。

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
使用暴力反射：setAccessible(true)

5.注解在程序中都有哪些用途？
编写文档：通过代码里标识的注解生成文档
代码分析：通过代码里标识的注解对代码进行分析
编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查


6.什么是元注解？
描述注解的注解

7.文件从编译到运行可以分为哪三个时期？
Source源代码阶段
Class类对象阶段
Runtime运行时阶段

8.思考：想让一个类加载进内存，有几种方式？
1.用类名.forName（全类名）加载该类进内存
2.通过new关键字创建对象实例。
3.通过类加载器loadClass()方法来加载，然后调用类的newInstance()方法实例化对象

1.黑盒测试和白盒测试的区别？
答：黑盒测试不需要写代码，只需要关注测试的输入，输出结果和预期结果是否一致，不需要关注测试过程中代码的实现流程。
白盒测试需要写代码，需要关注测试的输入，输出结果和预期结果是否一致，关注程序具体的实现流程。

2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
答：反射是把类中的各项信息封装到类对象中，并把对象封装到class类对象中。
反射的好处：1.在代码执行阶段，能够动态的操作类中的信息；2.解耦和，可以提高程序的可扩展性。

3.获取 Class对象有几种方式？他们的用途都在哪？
答：获取class对象的方式有3种。分别为Class调用静态方法forName，类名.class，对象调用方法getclass。
Class调用静态方法forName多用于配置文件，加载文件读取类；
类名.class多用于参数的传递；
对象.getclass多用于对象获取字节码

4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
答：首先要先获取class对象，获取被私有的成员变量的方法为：class对象调用方法——>getDeclareFields()获取所有的成员变量对象，getDeclaredFiled()获取指定的成员变量对象。
获取被私有的成员方法对象：class对象调用方法——>getDeclaredFields()获取所有的成员方法对象，getDeclaredField()获取特定成员方法对象。

5.注解在程序中都有哪些用途？
答：注解的用途有三种：编写文档（通过注解生成Java Doc文档），代码分析，编译检查

6.什么是元注解？
答：元注解就是用来解释注解的注解。

7.文件从编译到运行可以分为哪三个时期？
答：分为：source阶段，把.java的源代码编译成.class的字节码文件。
Class阶段，把.class文件转换为.class对象，并把.class文件中的信息封装进.class对象中。
RunTime阶段，通过.class对象创建对应类的对象。

8.思考：想让一个类加载进内存，有几种方式？
答：有4种方式。
第一种是通过创建这个类的对象，底层代码会把这个类加载进内存；
第二种是调用这个类的静态方法/静态变量，也会把类加载进内存；
第三种是通过创建这个类的class对象，通过Class.forName(“全类名")，也可以把类加载进内存；
第四种是通过类加载器classLoader，class对象调用classload方法也可以把类加载进内存。

1.黑盒测试和白盒测试的区别？
        黑盒只关注结果        不关注过程
        白盒注重代码细节
2.什么是反射？反射在程序中的应用场景，我们为什么要使用反射？
        反射reflect        
        
        将类的各个组成部分封装为其他对象
        
        使用反射:
        1.可以在 produce 中运行操作这些对象
        2.在程序中解耦和
        
3.获取 Class对象有几种方式？他们的用途都在哪？
        三种.
        1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
        * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
        全类名:        包名+类名
               
        2. 类名.class：通过类名的属性class获取
        * 多用于参数的传递
        
        3. 对象.getClass()：getClass()方法在Object类中定义着。
        * 多用于对象的获取字节码的方式
        
4.如何获取Class对象中被私有的成员变量对象和成员方法对象？
        Field getDeclaredField(String name)  获取指定成员变量，不考虑修饰符
        
        Method[] getMethods()  
        
5.注解在程序中都有哪些用途？
        说明程序的。给计算机看的
        
6.什么是元注解？
        元注解：用于描述注解的注解
7.文件从编译到运行可以分为哪三个时期？
        编译
        反射reflect
        运行
8.思考：想让一个类加载进内存，有几种方式？
        Class.forName("全类名")：将字节码文件加载进内存，返回Class对象多用于配置文件，将类名定义在配置文件中。读取文件，加载类
        Class.forName("全类名")
由 new 关键字创建一个类的实例
调用某个 ClassLoader 实例的 loadClass() 方法，通过该 ClassLoader 实例的 loadClass() 方法载入。应用程序可以通过继承 ClassLoader 实现自己的类装载器。