day11--java高级编程：反射
4 Day18–反射
本章专题与脉络
1. 反射(Reflection)的概念
1.1 反射的出现背景
Java程序中，所有的对象都有两种类型：编译时类型和运行时类型，而很多时候对象的编译时类型和运行时类型不一致（多态）。
Object obj = new String(“hello”);
obj.getClass()
例如：某些变量或形参的声明类型是Object类型，但是程序却需要调用该对象运行时类型的方法，该方法不是Object中的方法，那么如何解决呢？（编译看左边，运行看右边）
解决这个问题，有两种方案：
方案1：在编译和运行时都完全知道类型的具体信息，在这种情况下，我们可以直接先使用instanceof运算符进行判断，再利用强制类型转换符将其转换成运行时类型的变量即可。
方案2：编译时根本无法预知该对象和类的真实信息，程序只能依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射。
1.2 反射概述
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在运行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
从内存加载上看反射：
1.3 Java反射机制研究及应用
Java反射机制提供的功能：
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
1.4 反射相关的主要API
java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器
… …
1.5 反射的优缺点
优点：
-
提高了Java程序的灵活性和扩展性，
降低了耦合性，提高自适应能力 -
允许程序创建和控制任何类的对象，无需提前
硬编码目标类
缺点：
-
反射的
性能较低。- 反射机制主要应用在对灵活性和扩展性要求很高的系统框架上
-
反射会
模糊程序内部逻辑，可读性较差。
1.6 通过使用反射前后的例子的对比
通过使用反射前后的例子的对比，回答：
1 . 面向对象中创建对象，调用指定结构（属性、方法）等功能，可以不使用反射，也可以使用反射。请问有什么区别？
不使用反射，我们需要考虑封装性。比如：出了Person类之后，就不能调用Person类中私有的结构
使用反射，我们可以调用运行时类中任意的构造器、属性、方法。包括了私有的属性、方法、构造器。
2 . 以前创建对象并调用方法的方式，与现在通过反射创建对象并调用方法的方式对比的话，哪种用的多？场景是什么？
从我们作为程序员开发者的角度来讲，我们开发中主要是完成业务代码，对于相关的对象、方法的调用都是确定的。 所以，我们使用非反射的方式多一些。
因为反射体现了动态性（可以在运行时动态的获取对象所属的类，动态的调用相关的方法），所以我们在设计框架的时候，会大量的使用反射。意味着，如果大家需要学习框架源码，那么就需要学习反射。
框架 = 注解 + 反射 + 设计模式
3 . 单例模式的饿汉式和懒汉式中，私有化类的构造器了！ 此时通过反射，可以创建单例模式中类的多个对象吗？
是的！
4 . 通过反射，可以调用类中私有的结构，是否与面向对象的封装性有冲突？是不是Java语言设计存在Bug？
不存在bug!
封装性：体现的是是否建议我们调用内部api的问题。比如，private声明的结构，意味着不建议调用。
反射：体现的是我们能否调用的问题。因为类的完整结构都加载到了内存中，所有我们就有能力进行调用。
测试代码：
Person类
package com.atguigu01.example;
public class Person {
//属性
private String name;
public int age;
//构造器
public Person(){
System.out.println("Person()...");
}
public Person(int age){
this.age = age;
}
private Person(String name, int age){
this.name = name;
this.age = age;
}
//方法
public void show(){
System.out.println("你好，我是一个Person");
}
private String showNation(String nation){
return "我的国籍是：" + nation;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类：
package com.atguigu01.example;
import org.testng.annotations.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionTest {
/*
* 使用反射之前可以执行的操作
* */
@Test
public void test1(){
//1.创建Person类的实例
// public Person() 无参构造
Person p1 = new Person();//Person()... 调用构造器
System.out.println(p1);//Person{name='null', age=0}
//2.调用属性
//public int age;
p1.age = 10;
System.out.println(p1.age);//10
//3.调用方法
//public void show()
p1.show();//你好，我是一个Person
}
/*
* 使用反射完成上述的操作
* */
@Test
public void test2() throws Exception{
//1.创建Person类的实例
// public Person()
Class<Person> clazz = Person.class;
//此方法会跑会抛异常，8还能用，9之后开始过时了
Person p1 = clazz.newInstance();//Person()... 调用构造器
System.out.println(p1);//Person{name='null', age=0}
//2.调用属性
//public int age;
Field ageField = clazz.getField("age");
ageField.set(p1,10);
System.out.println(ageField.get(p1));//10
//3.调用方法
//public void show()
Method showMethod = clazz.getMethod("show");
showMethod.invoke(p1);//你好，我是一个Person 进行调用
}
/*
* 出了Person类之后，就不能直接调用Person类中声明的private权限修饰的结构（属性、方法、构造器）
* 但是，我们可以通过反射的方式，调用Person类中私有的结构 ---> 暴力反射
*
* */
@Test
public void test3() throws Exception {
//1. 调用私有的构造器，创建Person的实例
//private Person(String name, int age)
Class clazz = Person.class;
Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
cons.setAccessible(true);
Person p1 = (Person) cons.newInstance("Tom",12);
System.out.println(p1);//Person{name='Tom', age=12}
//2. 调用私有的属性
//private String name;
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(p1,"Jerry");
System.out.println(nameField.get(p1));//Jerry
//3. 调用私有的方法
//private String showNation(String nation)
Method showNationMethod = clazz.getDeclaredMethod("showNation",String.class);
showNationMethod.setAccessible(true);
String info = (String) showNationMethod.invoke(p1,"CHN");
System.out.println(info);//我的国籍是：CHN
}
}
2. 理解Class类并获取Class实例
要想解剖一个类，必须先要获取到该类的Class对象。而剖析一个类或用反射解决具体的问题就是使用相关API:
- java.lang.Class
- java.lang.reflect.*
所以，Class对象是反射的根源。
2.1 理解Class
如下以Java类的加载为例说明：
针对于编写好的.java源文件进行编译(使用javac.exe)，会生成一个或多个.class字节码文件。接着，我们使用
java.exe命令对指定的.class文件进行解释运行。这个解释运行的过程中，我们需要将.class字节码文件加载(使用类的加载器)
到内存中(存放在方法区)。加载到内存中的.class文件对应的结构即为Class的一个实例。
比如：加载到内存中的Person类或String类或User类，都作为Class的一个一个的实例
Class clazz1 = Person.class; //运行时类
Class clazz2 = String.class;
Class clazz3 = User.class;
Class clazz4 = Comparable.class;
说明：运行时类在内存中会缓存起来，在整个执行期间，只会加载一次。
2.1.1 理论上
在Object类中定义了以下的方法，此方法将被所有子类继承：
public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。
对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。
- Class本身也是一个类
- Class 对象只能由系统建立对象
一个加载的类在 JVM 中只会有一个Class实例- 一个Class对象对应的是一个加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个 Class 实例所生成
- 通过Class可以完整地得到一个类中的所有被加载的结构
- Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
2.1.2 内存结构上
说明：上图中字符串常量池在JDK6中存储在方法区；JDK7及以后，存储在堆空间。
2.2 获取Class类的实例(四种方法)
方式1：要求编译期间已知类型
前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
实例：
Class clazz = String.class;
方式2：获取对象的运行时类型
前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
实例：
Class clazz = "www.atguigu.com".getClass();
方式3：可以获取编译期间未知的类型
前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
实例：
Class clazz = Class.forName("java.lang.String");
方式4：其他方式(不做要求)
前提：可以用系统类加载对象或自定义加载器对象加载指定路径下的类型
实例：
ClassLoader cl = this.getClass().getClassLoader();
Class clazz4 = cl.loadClass("类的全类名");
再举例：
user类：
package com.atguigu01.example;
public class User {
private String name;
public int age;
public User(){
// System.out.println("User()...");
}
public User(int age){
this.age = age;
}
public User(String name, int age){
this.name = name;
this.age = age;
}
public void show(){
System.out.println("你好，我是一个User");
}
private String showNation(String nation){
return "我的国籍是：" + nation;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类：
package com.atguigu01.example;
import org.testng.annotations.Test;
import java.lang.annotation.ElementType;
public class ClassTest {
/*
* 获取Class实例的几种方式(掌握前三种)
* */
@Test
public void test1() throws ClassNotFoundException {
//方式1：调用运行时类的静态属性：class
Class clazz1 = User.class;
System.out.println(clazz1); //class com.atguigu01.example.User
//方式2：调用运行时类的对象的getClass()
User u1 = new User();
Class clazz2 = u1.getClass();
//方式3：调用Class的静态方法forName(String className)
String className = "com.atguigu01.example.User"; //全类名
Class clazz3 = Class.forName(className); //会报一个异常
System.out.println(clazz1 == clazz2);//true 说明：运行时类在内存中会缓存起来，在整个执行期间，只会加载一次。
System.out.println(clazz1 == clazz3);//true
//方式4：使用类的加载器的方式 (了解)
Class clazz4 = ClassLoader.getSystemClassLoader().loadClass("com.atguigu01.example.User");
System.out.println(clazz1 == clazz4);//true
}
}
2.3 哪些类型可以有Class对象
简言之，所有Java类型！
（1）class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
（2）interface：接口
（3）[]：数组
（4）enum：枚举
（5）annotation：注解@interface
（6）primitive type：基本数据类型
（7）void
举例：
@Test
public void test2(){
Class c1 = Object.class;
Class c2 = Comparable.class;
Class c3 = String[].class;
Class c4 = int[][].class;//二维数组
Class c5 = ElementType.class;//枚举类
Class c6 = Override.class;//注解
Class c7 = int.class;
Class c8 = void.class;
Class c9 = Class.class; //Class本身也是一个类
int[] a = new int[10];
int[] b = new int[100];
Class c10 = a.getClass();
Class c11 = b.getClass();
// 只要元素类型与维度一样，就是同一个Class
System.out.println(c10 == c11); //true（都是一维数组，都是int类型）
}
2.4 Class类的常用方法
| 方法名 | 功能说明 |
|---|---|
| static Class forName(String name) | 返回指定类名 name 的 Class 对象 |
| Object newInstance() | 调用缺省构造函数，返回该Class对象的一个实例 |
| getName() | 返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称 |
| Class getSuperClass() | 返回当前Class对象的父类的Class对象 |
| Class [] getInterfaces() | 获取当前Class对象的接口 |
| ClassLoader getClassLoader() | 返回该类的类加载器 |
| Class getSuperclass() | 返回表示此Class所表示的实体的超类的Class |
| Constructor[] getConstructors() | 返回一个包含某些Constructor对象的数组 |
| Field[] getDeclaredFields() | 返回Field对象的一个数组 |
| Method getMethod(String name,Class … paramTypes) | 返回一个Method对象，此对象的形参类型为paramType |
举例：
String str = "test4.Person";
Class clazz = Class.forName(str);
Object obj = clazz.newInstance();
Field field = clazz.getField("name");
field.set(obj, "Peter");
Object name = field.get(obj);
System.out.println(name);
//注：test4.Person是test4包下的Person类
3. 类的加载与ClassLoader的理解
3.1 类的生命周期
类在内存中完整的生命周期：加载–>使用–>卸载。其中加载过程又分为：装载、链接、初始化三个阶段。
3.2 类的加载过程
当程序主动使用某个类时，如果该类还未被加载到内存中，系统会通过加载、链接、初始化三个步骤来对该类进行初始化。如果没有意外，JVM将会连续完成这三个步骤，所以有时也把这三个步骤统称为类加载。
类的加载又分为三个阶段：
（1）装载（Loading）
将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成
（2）链接（Linking）
①验证Verify：确保加载的类信息符合JVM规范，例如：以cafebabe开头，没有安全方面的问题。
②准备Prepare：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
③解析Resolve：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
（3）初始化（Initialization）
-
执行
类构造器的过程。()方法 类构造器是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。()方法 -
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
-
虚拟机会保证一个
类的在多线程环境中被正确加锁和同步。()方法
3.3 类加载器（classloader)
3.3.1 类加载器的作用
将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
3.3.2 类加载器的分类(JDK8为例)
分类（分为两种）：JVM支持两种类型的类加载器，分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）。
-
BootstrapClassLoader:引导类加载器、启动类加载器
- 使用C/C++语言编写的，不能通过Java代码获取其实例
- 负责加载Java的核心库（JAVA_HOME/jre/lib/rt.jar或sun.boot.class.path路径下的内容）
-
继承于ClassLoader的类加载器
- ExtensionClassLoader:扩展类加载器
- 负责加载从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录下加载类库
- SystemClassLoader/ApplicationClassLoader:系统类加载器、应用程序类加载器
我们自定义的类，默认使用的类的加载器。
- 用户自定义类的加载器
- 实现应用的隔离（同一个类在一个应用程序中可以加载多份）；数据的加密。
- ExtensionClassLoader:扩展类加载器
从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是Java虚拟机规范却没有这么定义，而是将所有派生于抽象类ClassLoader的类加载器都划分为自定义类加载器。无论类加载器的类型如何划分，在程序中我们最常见的类加载器结构主要是如下情况：
问题：以上的类的加载器是否存在继承关系？ No!
双亲委托机制
class ClassLoader{
ClassLoader parent;
public ClassLoader(ClassLoader parent){
this.parent = parent;
}
}
//测试代码：
ClassLoader loader0 = new ClassLoader();
ClassLoader loader1 = new ClassLoader(loader0);
我们就把loader0叫做loader1的父类加载器。
（1）启动类加载器（引导类加载器，Bootstrap ClassLoader）
- 这个类加载使用
C/C++语言实现的，嵌套在JVM内部。获取它的对象时往往返回null - 它用来加载Java的核心库（JAVA_HOME/jre/lib/rt.jar或sun.boot.class.path路径下的内容）。用于提供JVM自身需要的类。
- 并不继承自java.lang.ClassLoader，没有父加载器。
- 出于安全考虑，Bootstrap启动类加载器只加载包名为java、javax、sun等开头的类
- 加载扩展类和应用程序类加载器，并指定为他们的父类加载器。
（2）扩展类加载器（Extension ClassLoader）
- Java语言编写，由sun.misc.Launcher$ExtClassLoader实现。
- 继承于ClassLoader类
- 父类加载器为启动类加载器
- 从java.ext.dirs系统属性所指定的目录中加载类库，或从JDK的安装目录的jre/lib/ext子目录下加载类库。如果用户创建的JAR放在此目录下，也会自动由扩展类加载器加载。
（3）应用程序类加载器（系统类加载器，AppClassLoader）
- java语言编写，由sun.misc.Launcher$AppClassLoader实现
- 继承于ClassLoader类
- 父类加载器为扩展类加载器
- 它负责加载环境变量classpath或系统属性 java.class.path 指定路径下的类库
应用程序中的类加载器默认是系统类加载器。- 它是用户自定义类加载器的默认父加载器
- 通过ClassLoader的getSystemClassLoader()方法可以获取到该类加载器
（4）用户自定义类加载器（了解）
- 在Java的日常应用程序开发中，类的加载几乎是由上述3种类加载器相互配合执行的。在必要时，我们还可以自定义类加载器，来定制类的加载方式。
- 体现Java语言强大生命力和巨大魅力的关键因素之一便是，Java开发者可以自定义类加载器来实现类库的动态加载，加载源可以是本地的JAR包，也可以是网络上的远程资源。
- 同时，自定义加载器能够实现
应用隔离，例如 Tomcat，Spring等中间件和组件框架都在内部实现了自定义的加载器，并通过自定义加载器隔离不同的组件模块。这种机制比C/C++程序要好太多，想不修改C/C++程序就能为其新增功能，几乎是不可能的，仅仅一个兼容性便能阻挡住所有美好的设想。 - 自定义类加载器通常需要继承于ClassLoader。
3.3.3 查看某个类的类加载器对象
（1）获取默认的系统类加载器
ClassLoader classloader = ClassLoader.getSystemClassLoader();
（2）查看某个类是哪个类加载器加载的
ClassLoader classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();
//如果是根加载器加载的类，则会得到null
ClassLoader classloader1 = Class.forName("java.lang.Object").getClassLoader();
（3）获取某个类加载器的父加载器
ClassLoader parentClassloader = classloader.getParent();
示例代码：
package com.atguigu01.example;
import org.testng.annotations.Test;
public class ClassLoaderTest {
/*
* 在jdk8中执行如下的代码：
* */
@Test
public void test1(){
//获取系统类加载器
ClassLoader classLoader1 = ClassLoader.getSystemClassLoader();
System.out.println(classLoader1);//sun.misc.Launcher$AppClassLoader@18b4aac2
//获取扩展类加载器（也就是系统加载器的上层）
ClassLoader classLoader2 = classLoader1.getParent();
System.out.println(classLoader2);//sun.misc.Launcher$ExtClassLoader@28a418fc
//获取引导类加载器:失败 （因为引导类加载器是c++编写的，不能通过java代码获取）
ClassLoader classLoader3 = classLoader2.getParent();
System.out.println(classLoader3);//null
}
@Test
public void test2() throws ClassNotFoundException {
//用户自定义的类使用的是系统类加载器加载的。
Class clazz1 = User.class;
ClassLoader classLoader = clazz1.getClassLoader();
System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
//对于Java的核心api使用引导类加载器加载
Class clazz2 = Class.forName("java.lang.String");
ClassLoader classLoader1 = clazz2.getClassLoader();
System.out.println(classLoader1);//null
}
}
package com.atguigu01.example;
public class User {
private String name;
public int age;
public User(){
// System.out.println("User()...");
}
public User(int age){
this.age = age;
}
public User(String name, int age){
this.name = name;
this.age = age;
}
public void show(){
System.out.println("你好，我是一个User");
}
private String showNation(String nation){
return "我的国籍是：" + nation;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
3.3.4 使用ClassLoader获取流
关于类加载器的一个主要方法：getResourceAsStream(String str):获取类路径下的指定文件的输入流
InputStream in = null;
in = this.getClass().getClassLoader().getResourceAsStream("exer2\\test.properties");
System.out.println(in);
举例：
package com.atguigu01.example;
import org.testng.annotations.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
/**
* ClassName: ClassLoaderTest
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 16:47
* @Version 1.0
*/
public class ClassLoaderTest {
/*
* 需求：通过ClassLoader加载指定的配置文件 方式二：现在通过类加载器同样可以读取配置文件
* */
@Test
public void test3() throws IOException {
Properties pros = new Properties();
//通过类的加载器读取的文件的默认的路径为：当前module下的src下
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("info1.properties");
pros.load(is);
String name = pros.getProperty("name");
String pwd = pros.getProperty("password");
System.out.println(name + ":" +pwd);//fjkl:356
}
//Properties:处理属性文件 方式一：之前学习io流的时候读取配置文件的方式
@Test
public void test4() throws IOException {
Properties pros = new Properties();
//读取的文件的默认路径为：当前的module (在测试方法中从module开始读取)
FileInputStream is = new FileInputStream(new File("info.properties"));
// FileInputStream is = new FileInputStream(new File("src/info1.properties"));
pros.load(is);
String name = pros.getProperty("name");
String pwd = pros.getProperty("password");
System.out.println(name + ":" +pwd); //abc:123
}
}
配置文件：
info.properties
name=abc
password=123
info1.properties
name=fjkl
password=356
4. 反射的基本应用
有了Class对象，能做什么？
4.1 应用1：创建运行时类的对象
这是反射机制应用最多的地方。创建运行时类的对象有两种方式：
4.1.1 方式1：直接调用Class对象的newInstance()方法
要 求： 1）类必须有一个无参数的构造器。2）类的构造器的访问权限需要足够。
步骤：1）获取该类型的Class对象 2）调用Class对象的newInstance()方法创建对象
回忆：JavaBean中要求给当前类提供一个公共的空参的构造器。有什么用？
- 场景1：子类对象在实例化时，子类的构造器的首行默认调用父类空参的构造器。
- 场景2：在反射中，经常用来创建运行时类的对象。那么我们要求各个运行时类都提供一个空参的构造器，便于我们编写通用的创建运行时类对象的代码。
注意：在jdk9中标识为过时，替换成什么结构？
- 通过Constructor类调用newInstance(…)，详情查看方式2。
测试：
public class NewInstanceTest {
@Test
public void test1() throws InstantiationException, IllegalAccessException {
//获取一个Class的实例
Class clazz = Person.class;
//创建Person类的实例 返回的是object类型 此方法会抛异常 jdk9开始过时了，因为想要创建成功必须满足以下2个条件，比较麻烦
/* 要想创建对象成功，需要满足
条件1：要求运行时类Person中必须提供一个空参的构造器 (没有空参构造器会报InstantiationException异常)
条件2：要求Person提供的空参的构造器的权限要足够。 (如果空参构造器的访问权限是private会报IllegalAccessException异常)
*/
Person per = (Person) clazz.newInstance();//Person()... 会调用Person类的无参构造器
System.out.println(per); //Person{name='null', age=1}
}
}
4.1.2 方式2：通过获取构造器对象来进行实例化
步骤：
1）通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
3）通过Constructor实例化对象。
如果构造器的权限修饰符修饰的范围不可见，也可以调用setAccessible(true)
示例代码：
package com.atguigu03.reflectapply.apply1;
import com.atguigu03.reflectapply.data.Person;
import org.testng.annotations.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* ClassName: ReflectTest
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 10:04
* @Version 1.0
*/
public class ReflectTest {
//********************如下是调用指定的构造器************************
/*
* 反射的应用3-3：调用指定的构造器
*
* */
//private Person(String name, int age) 私有 有参构造器
@Test
public void test6() throws Exception {
Class clazz = Person.class;
//1.通过Class的实例调用getDeclaredConstructor(Class ... args)，获取指定参数类型的构造器
Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class);
//2.setAccessible(true)：确保此构造器是可以访问的
constructor.setAccessible(true);
//3.通过Constructor实例调用newInstance(Object ... objs),返回一个运行时类的实例。
Person per = (Person) constructor.newInstance("Tom", 12);
System.out.println(per); //Person{name='Tom', age=12}
}
//public Person() 公有 无参构造器
@Test
public void test7() throws Exception {
Class clazz = Person.class;
//1.通过Class的实例调用getDeclaredConstructor(Class ... args)，获取指定参数类型的构造器
Constructor constructor = clazz.getDeclaredConstructor();
//2.setAccessible(true)：确保此构造器是可以访问的
constructor.setAccessible(true);
//3.通过Constructor实例调用newInstance(Object ... objs),返回一个运行时类的实例。
Person per = (Person) constructor.newInstance();
System.out.println(per); //Person{name='null', age=1}
}
}
package com.atguigu03.reflectapply.data;
/**
* @author 尚硅谷-宋红康
* @create 9:35
*/
@MyAnnotation("t_persons")
public class Person extends Creature<String> implements Comparable<Person>,MyInterface{
private String name;
public int age = 1;
@MyAnnotation("info")
private static String info;
public Person(){
System.out.println("Person()...");
}
protected Person(int age){
this.age = age;
}
private Person(String name, int age){
this.name = name;
this.age = age;
}
public void show() throws RuntimeException,ClassNotFoundException{
System.out.println("你好，我是一个Person");
}
@MyAnnotation(value="show_nation")
private String showNation(String nation,int age){
System.out.println("showNation...");
return "我的国籍是：" + nation + "，生活了" + age + "年";
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Person o) {
return 0;
}
@Override
public void method() {
}
public static void showInfo(){
System.out.println("我是一个人");
}
}
4.2 应用2：获取运行时类的完整结构
可以获取：包、修饰符、类型名、父类（包括泛型父类）、父接口（包括泛型父接口）、成员（属性、构造器、方法）、注解（类上的、方法上的、属性上的）。
- （了解）获取运行时类的内部结构1：所有属性、所有方法、所有构造器（包含私有的）
- （熟悉）获取运行时类的内部结构2：父类、接口们、包、带泛型的父类、父类的泛型等
4.2.1 相关API
//1.实现的全部接口
public Class<?>[] getInterfaces()
//确定此对象所表示的类或接口实现的接口。
//2.所继承的父类
public Class<? Super T> getSuperclass()
//返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。
//3.全部的构造器
public Constructor<T>[] getConstructors()
//返回此 Class 对象所表示的类的所有public构造方法。
public Constructor<T>[] getDeclaredConstructors()
//返回此 Class 对象表示的类声明的所有构造方法。
//Constructor类中：
//取得修饰符:
public int getModifiers();
//取得方法名称:
public String getName();
//取得参数的类型：
public Class<?>[] getParameterTypes();
//4.全部的方法
public Method[] getDeclaredMethods()
//返回此Class对象所表示的类或接口的全部方法
public Method[] getMethods()
//返回此Class对象所表示的类或接口的public的方法
//Method类中：
public Class<?> getReturnType()
//取得全部的返回值
public Class<?>[] getParameterTypes()
//取得全部的参数
public int getModifiers()
//取得修饰符
public Class<?>[] getExceptionTypes()
//取得异常信息
//5.全部的Field
public Field[] getFields()
//返回此Class对象所表示的类或接口的public的Field。
public Field[] getDeclaredFields()
//返回此Class对象所表示的类或接口的全部Field。
//Field方法中：
public int getModifiers()
//以整数形式返回此Field的修饰符
public Class<?> getType()
//得到Field的属性类型
public String getName()
//返回Field的名称。
//6. Annotation相关
get Annotation(Class<T> annotationClass)
getDeclaredAnnotations()
//7.泛型相关
//获取父类泛型类型：
Type getGenericSuperclass()
//泛型类型：ParameterizedType
//获取实际的泛型类型参数数组：
getActualTypeArguments()
//8.类所在的包
Package getPackage()
4.2.2 获取所有的属性及相关细节
package com.atguigu03.reflectapply.apply1;
import com.atguigu03.reflectapply.data.Person;
import org.testng.annotations.Test;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
/**
* @author shkstart
* @create 14:28
*/
public class FieldsTest {
//获取属性的全部信息
@Test
public void test1() {
Class clazz = Person.class;
//getFields():获取到运行时类本身及其所有的父类中声明为public权限的属性
// Field[] fields = clazz.getFields();
// for (Field f : fields) {
// System.out.println(f);
// }
//getDeclaredFields():获取当前运行时类中声明的所有属性
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
System.out.println(f);
}
}
//获取属性的具体信息，更加细粒度的
//权限修饰符 变量类型 变量名
@Test
public void test2() {
Class clazz = Person.class;
Field[] declaredFields = clazz.getDeclaredFields();
for (Field f : declaredFields) {
//1.权限修饰符
/*
* 0x是十六进制
* PUBLIC = 0x00000001; 1 1
* PRIVATE = 0x00000002; 2 10
* PROTECTED = 0x00000004; 4 100
* STATIC = 0x00000008; 8 1000
* FINAL = 0x00000010; 16 10000
* ...
*/
int modifier = f.getModifiers();
System.out.print(modifier + ":" + Modifier.toString(modifier) + "\t");
//2.数据类型
Class type = f.getType();
System.out.print(type.getName() + "\t");
//
// //3.变量名
String fName = f.getName();
System.out.print(fName);
System.out.println();
}
}
}
本类：
父类：
4.2.3 获取所有的方法及相关细节
package com.atguigu03.reflectapply.apply1;
import com.atguigu03.reflectapply.data.Person;
import org.testng.annotations.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
/**
* @author shkstart
* @create 14:36
*/
public class MethodsTest {
//获取方法的全部信息
@Test
public void test1() {
Class clazz = Person.class;
// getMethods():获取到运行时类本身及其所有的父类中声明为public权限的方法
// Method[] methods = clazz.getMethods();
// for (Method m : methods) {
// System.out.println(m);
// }
// getDeclaredMethods():获取当前运行时类中声明的所有方法
Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method m : declaredMethods) {
System.out.println(m);
}
}
//获取方法中的具体信息，更加细粒度
// 注解信息
// 权限修饰符 返回值类型 方法名(形参类型1 参数1,形参类型2 参数2,...) throws 异常类型1,...{}
@Test
public void test2() {
Class clazz = Person.class;
Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method m : declaredMethods) {
// 1.获取方法声明的注解
Annotation[] annos = m.getAnnotations();
for (Annotation a : annos) {
System.out.println(a);
}
// 2.权限修饰符
System.out.print(Modifier.toString(m.getModifiers()) + "\t");
// 3.返回值类型
System.out.print(m.getReturnType().getName() + "\t");
//
// // 4.方法名
System.out.print(m.getName());
System.out.print("(");
// // 5.形参列表
Class[] parameterTypes = m.getParameterTypes();
if (!(parameterTypes == null && parameterTypes.length == 0)) {
for (int i = 0; i < parameterTypes.length; i++) {
if (i == parameterTypes.length - 1) {
System.out.print(parameterTypes[i].getName() + " args_" + i);
break;
}
System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
}
}
//
System.out.print(")");
//
// // 6.抛出的异常
Class[] exceptionTypes = m.getExceptionTypes();
if (exceptionTypes.length > 0) {
System.out.print("throws ");
for (int i = 0; i < exceptionTypes.length; i++) {
if (i == exceptionTypes.length - 1) {
System.out.print(exceptionTypes[i].getName());
break;
}
System.out.print(exceptionTypes[i].getName() + ",");
}
}
System.out.println();
}
}
}
4.2.4 获取其他结构(构造器、父类、接口、包、注解等)
package com.atguigu03.reflectapply.apply1;
import com.atguigu03.reflectapply.data.Person;
import org.testng.annotations.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
/**
* @author shkstart
* @create 14:45
*/
public class OtherTest {
//（熟悉）获取运行时类的内部结构2：父类、接口们、包、带泛型的父类、父类的泛型等
//1.获取当前类中的所有的构造器
@Test
public void test1(){
Class clazz = Person.class;
Constructor[] cons = clazz.getDeclaredConstructors();
for(Constructor c :cons){
System.out.println(c);
}
}
//2. 获取运行时类的父类
@Test
public void test2() throws ClassNotFoundException {
Class clazz = Class.forName("com.atguigu03.reflectapply.data.Person");
Class superClass = clazz.getSuperclass();
System.out.println(superClass);
}
//3. 获取运行时类实现的接口
@Test
public void test3() throws ClassNotFoundException {
Class clazz = Class.forName("com.atguigu03.reflectapply.data.Person");
Class[] interfaces = clazz.getInterfaces();
for(Class c : interfaces){
System.out.println(c);
}
}
//4. 获取运行时类所在的包
@Test
public void test4() throws ClassNotFoundException {
Class clazz = Class.forName("com.atguigu03.reflectapply.data.Person");
Package pack = clazz.getPackage();
System.out.println(pack);
}
//5. 获取运行时类的带泛型的父类
@Test
public void test5() throws ClassNotFoundException {
Class clazz = Class.forName("com.atguigu03.reflectapply.data.Person");
Type superclass = clazz.getGenericSuperclass();
System.out.println(superclass);
}
//6. 获取运行时类的父类的泛型 (难)
/*
* 平时写的代码：
* 类型1：业务逻辑代码 （多关注）
* 类型2：算法逻辑代码 （多积累）
*
* */
@Test
public void test6() throws ClassNotFoundException {
Class clazz = Class.forName("com.atguigu03.reflectapply.data.Person");
//获取带泛型的父类（Type是一个接口，Class实现了此接口
Type superclass = clazz.getGenericSuperclass();
//如果父类是带泛型的，则可以强转为ParameterizedType
ParameterizedType paramType = (ParameterizedType) superclass;
//调用getActualTypeArguments()获取泛型的参数，结果是一个数组，因为可能有多个泛型参数。
Type[] arguments = paramType.getActualTypeArguments();
//获取泛型参数的名称
System.out.println(((Class)arguments[0]).getName());
}
}
4.2.5 获取泛型父类信息（选讲）
示例代码获取泛型父类信息：
/* Type：
* （1）Class
* （2）ParameterizedType
* 例如：Father
* ArrayList
* （3）TypeVariable
* 例如：T，U,E,K,V
* （4）WildcardType
* 例如：
* ArrayList
* ArrayList
* ArrayList
* （5）GenericArrayType
* 例如：T[]
*
*/
public class TestGeneric {
public static void main(String[] args) {
//需求：在运行时，获取Son类型的泛型父类的泛型实参属于ParameterizedType
ParameterizedType pt = (ParameterizedType) type;
//（3）获取泛型父类的泛型实参列表
Type[] typeArray = pt.getActualTypeArguments();
for (Type type2 : typeArray) {
System.out.println(type2);
}
}
}
//泛型形参：4.2.6 获取内部类或外部类信息（选讲）
public Class[] getClasses()：返回所有公共内部类和内部接口。包括从超类继承的公共类和接口成员以及该类声明的公共类和接口成员。
public Class[] getDeclaredClasses()：返回 Class 对象的一个数组，这些对象反映声明为此 Class 对象所表示的类的成员的所有类和接口。包括该类所声明的公共、保护、默认（包）访问及私有类和接口，但不包括继承的类和接口。
public Class getDeclaringClass()：如果此 Class 对象所表示的类或接口是一个内部类或内部接口，则返回它的外部类或外部接口，否则返回null。
Class getEnclosingClass() ：返回某个内部类的外部类
@Test
public void test5(){
Class<?> clazz = Map.class;
Class<?>[] inners = clazz.getDeclaredClasses();
for (Class<?> inner : inners) {
System.out.println(inner);
}
Class<?> ec = Map.Entry.class;
Class<?> outer = ec.getDeclaringClass();
System.out.println(outer);
}
4.2.7 小 结
-
在实际的操作中，取得类的信息的操作代码，并不会经常开发。
-
一定要熟悉java.lang.reflect包的作用，反射机制。
4.3 应用3：调用运行时类的指定结构（重点）
项目结构：用到的资源data
4.3.1 调用指定的属性
在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作。
（1）获取该类型的Class对象
Class clazz = Class.forName(“包.类名”);
（2）获取属性对象
Field field = clazz.getDeclaredField(“属性名”);
（3）如果属性的权限修饰符不是public，那么需要设置属性可访问
field.setAccessible(true);
（4）创建实例对象：如果操作的是非静态属性，需要创建实例对象
Object obj = clazz.newInstance(); //有公共的无参构造
Object obj = 构造器对象.newInstance(实参…);//通过特定构造器对象创建实例对象
（4）设置指定对象obj上此Field的属性内容
field.set(obj,“属性值”);
如果操作静态变量，那么实例对象可以省略，用null表示
（5）取得指定对象obj上此Field的属性内容
Object value = field.get(obj);
如果操作静态变量，那么实例对象可以省略，用null表示
示例代码：
package com.atguigu03.reflectapply.data;
/**
* @author 尚硅谷-宋红康
* @create 9:35
*/
@MyAnnotation("t_persons")
public class Person extends Creature<String> implements Comparable<Person>,MyInterface{
private String name;
public int age = 1;
@MyAnnotation("info")
private static String info;
public Person(){
System.out.println("Person()...");
}
protected Person(int age){
this.age = age;
}
private Person(String name, int age){
this.name = name;
this.age = age;
}
public void show() throws RuntimeException,ClassNotFoundException{
System.out.println("你好，我是一个Person");
}
@MyAnnotation(value="show_nation")
private String showNation(String nation,int age){
System.out.println("showNation...");
return "我的国籍是：" + nation + "，生活了" + age + "年";
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Person o) {
return 0;
}
@Override
public void method() {
}
public static void showInfo(){
System.out.println("我是一个人");
}
}
package com.atguigu03.reflectapply.apply1;
import com.atguigu03.reflectapply.data.Person;
import org.testng.annotations.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* ClassName: ReflectTest
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 10:04
* @Version 1.0
*/
public class ReflectTest {
//********************如下是调用指定的属性************************
/*
* 反射的应用3-1：调用指定的属性
*
* */
//public int age = 1; 公共的
@Test
public void test1() throws Exception {
Class clazz = Person.class;
Person per = (Person) clazz.newInstance();//Person()...调用构造方法
//1. 获取运行时类指定名的属性
Field ageField = clazz.getField("age");
//2. 获取或设置此属性的值
ageField.set(per,2); //设置
System.out.println(ageField.get(per));//2 获取
}
//private String name; 私有的（以下这种既可以获取私有的也可以获取公有的）
@Test
public void test2() throws Exception {
Class clazz = Person.class;
Person per = (Person) clazz.newInstance();
//1.通过Class实例调用getDeclaredField(String fieldName)，获取运行时类指定名的属性
Field nameField = clazz.getDeclaredField("name");
//2. setAccessible(true)：确保此属性是可以访问的
nameField.setAccessible(true);
//3. 通过Filed类的实例调用get(Object obj) （获取的操作）
// 或 set(Object obj,Object value) （设置的操作）进行操作。
nameField.set(per,"Tom");
System.out.println(nameField.get(per));//Tom
}
//private static String info; 静态的
@Test
public void test3() throws Exception {
Class clazz = Person.class;
//1.通过Class实例调用getDeclaredField(String fieldName)，获取运行时类指定名的属性
Field infoField = clazz.getDeclaredField("info");
//2. setAccessible(true)：确保此属性是可以访问的
infoField.setAccessible(true);
//3. 通过Filed类的实例调用get(Object obj) （获取的操作）
// 或 set(Object obj,Object value) （设置的操作）进行操作。
// infoField.set(Person.class,"我是一个人"); 方式一
// System.out.println(infoField.get(Person.class));
//或 （仅限于类变量可以如下的方式调用） 方式二
infoField.set(null,"我是一个人");
System.out.println(infoField.get(null)); //我是一个人
}
//********************如下是调用指定的方法************************
/*
* 反射的应用3-2：调用指定的方法
*
* */
//private String showNation(String nation,int age)
@Test
public void test4() throws Exception {
Class clazz = Person.class;
Person per = (Person) clazz.newInstance();
//1.通过Class的实例调用getDeclaredMethod(String methodName,Class ... args),获取指定的方法
Method showNationMethod = clazz.getDeclaredMethod("showNation",String.class,int.class);
//2. setAccessible(true)：确保此方法是可访问的
showNationMethod.setAccessible(true);
//3.通过Method实例调用invoke(Object obj,Object ... objs),即为对Method对应的方法的调用。
//invoke()的返回值即为Method对应的方法的返回值
//特别的：如果Method对应的方法的返回值类型为void，则invoke()返回值为null
Object returnValue = showNationMethod.invoke(per,"CHN",10);
System.out.println(returnValue);
}
//public static void showInfo()
@Test
public void test5() throws Exception {
Class clazz = Person.class;
//1.通过Class的实例调用getDeclaredMethod(String methodName,Class ... args),获取指定的方法
Method showInfoMethod = clazz.getDeclaredMethod("showInfo");
//2. setAccessible(true)：确保此方法是可访问的
showInfoMethod.setAccessible(true);
//3.通过Method实例调用invoke(Object obj,Object ... objs),即为对Method对应的方法的调用。
//invoke()的返回值即为Method对应的方法的返回值
//特别的：如果Method对应的方法的返回值类型为void，则invoke()返回值为null
Object returnValue = showInfoMethod.invoke(null);
System.out.println(returnValue);
}
}
关于setAccessible方法的使用：
- Method和Field、Constructor对象都有setAccessible()方法。
- setAccessible启动和禁用访问安全检查的开关。
- 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
- 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。
- 使得原本无法访问的私有成员也可以访问
- 参数值为false则指示反射的对象应该实施Java语言访问检查。
4.3.2 调用指定的方法
（1）获取该类型的Class对象
Class clazz = Class.forName(“包.类名”);
（2）获取方法对象
Method method = clazz.getDeclaredMethod(“方法名”,方法的形参类型列表);
（3）创建实例对象
Object obj = clazz.newInstance();
（4）调用方法
Object result = method.invoke(obj, 方法的实参值列表);
如果方法的权限修饰符修饰的范围不可见，也可以调用setAccessible(true)
如果方法是静态方法，实例对象也可以省略，用null代替
示例代码：
package com.atguigu03.reflectapply.data;
/**
* @author 尚硅谷-宋红康
* @create 9:35
*/
@MyAnnotation("t_persons")
public class Person extends Creature<String> implements Comparable<Person>,MyInterface{
private String name;
public int age = 1;
@MyAnnotation("info")
private static String info;
public Person(){
System.out.println("Person()...");
}
protected Person(int age){
this.age = age;
}
private Person(String name, int age){
this.name = name;
this.age = age;
}
public void show() throws RuntimeException,ClassNotFoundException{
System.out.println("你好，我是一个Person");
}
@MyAnnotation(value="show_nation")
private String showNation(String nation,int age){
System.out.println("showNation...");
return "我的国籍是：" + nation + "，生活了" + age + "年";
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Person o) {
return 0;
}
@Override
public void method() {
}
public static void showInfo(){
System.out.println("我是一个人");
}
}
package com.atguigu03.reflectapply.apply1;
import com.atguigu03.reflectapply.data.Person;
import org.testng.annotations.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* ClassName: ReflectTest
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 10:04
* @Version 1.0
*/
public class ReflectTest {
//********************如下是调用指定的方法************************
/*
* 反射的应用3-2：调用指定的方法
*
* */
//private String showNation(String nation,int age) 直接使用这种无关权限的方式调用测试了
@Test
public void test4() throws Exception {
Class clazz = Person.class;
Person per = (Person) clazz.newInstance();
//1.通过Class的实例调用getDeclaredMethod(String methodName,Class ... args),获取指定的方法
Method showNationMethod = clazz.getDeclaredMethod("showNation",String.class,int.class);
//2. setAccessible(true)：确保此方法是可访问的
showNationMethod.setAccessible(true);
//3.通过Method实例调用invoke(Object obj,Object ... objs),即为对Method对应的方法的调用。
//invoke()的返回值即为Method对应的方法的返回值
//特别的：如果Method对应的方法的返回值类型为void，则invoke()返回值为null
Object returnValue = showNationMethod.invoke(per,"CHN",10); //showNation...
System.out.println(returnValue); //我的国籍是：CHN，生活了10年
}
//public static void showInfo() 静态的
@Test
public void test5() throws Exception {
Class clazz = Person.class;
//1.通过Class的实例调用getDeclaredMethod(String methodName,Class ... args),获取指定的方法
Method showInfoMethod = clazz.getDeclaredMethod("showInfo");
//2. setAccessible(true)：确保此方法是可访问的
showInfoMethod.setAccessible(true);
//3.通过Method实例调用invoke(Object obj,Object ... objs),即为对Method对应的方法的调用。
//invoke()的返回值即为Method对应的方法的返回值
//特别的：如果Method对应的方法的返回值类型为void，则invoke()返回值为null
Object returnValue = showInfoMethod.invoke(null); //我是一个人
System.out.println(returnValue); //null
}
}
4.3.3 练习
读取user.properties文件中的数据，通过反射完成User类对象的创建及对应方法的调用。
配置文件：user.properties
className:com.atguigu.bean.User
methodName:show
User.java文件：
package com.atguigu.bean;
/**
* @author 尚硅谷-宋红康
* @create 18:41
*/
public class User {
private String name;
public User() {
}
public User(String name) {
this.name = name;
}
public void show(){
System.out.println("我是一个脉脉平台的用户");
}
}
ReflectTest.java文件：
package com.atguigu.java4;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* @author 尚硅谷-宋红康
* @create 18:43
*/
public class ReflectTest {
@Test
public void test() throws Exception {
//1.创建Properties对象
Properties pro = new Properties();
//2.加载配置文件，转换为一个集合
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
InputStream is = classLoader.getResourceAsStream("user.properties");
pro.load(is);
//3.获取配置文件中定义的数据
String className = pro.getProperty("className");
String methodName = pro.getProperty("methodName");
//4.加载该类进内存
Class clazz = Class.forName(className);
//5.创建对象
Object instance = clazz.newInstance();
//6.获取方法对象
Method showMethod = clazz.getMethod(methodName);
//7.执行方法
showMethod.invoke(instance);
}
}
5. 应用4：读取注解信息
一个完整的注解应该包含三个部分：
（1）声明
（2）使用
（3）读取
5.1 声明自定义注解
package com.atguigu03.reflectapply.apply2;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
/**
* ClassName: Table
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 10:42
* @Version 1.0
*/
@Target({TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
String value() default "abc";
}
package com.atguigu03.reflectapply.apply2;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
/**
* ClassName: Column
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 10:45
* @Version 1.0
*/
@Target({FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
String columnName();
String columnType();
}
- 自定义注解可以通过四个元注解@Retention,@Target，@Inherited,@Documented，分别说明它的声明周期，使用位置，是否被继承，是否被生成到API文档中。
- Annotation 的成员在 Annotation 定义中以无参数有返回值的抽象方法的形式来声明，我们又称为配置参数。返回值类型只能是八种基本数据类型、String类型、Class类型、enum类型、Annotation类型、以上所有类型的数组
- 可以使用 default 关键字为抽象方法指定默认返回值
- 如果定义的注解含有抽象方法，那么使用时必须指定返回值，除非它有默认值。格式是“方法名 = 返回值”，如果只有一个抽象方法需要赋值，且方法名为value，可以省略“value=”，所以如果注解只有一个抽象方法成员，建议使用方法名value。
5.2 使用自定义注解
package com.atguigu03.reflectapply.apply2;
/**
* @author shkstart
* @create 9:35
*/
@Table(value="t_customer")
public class Customer {
@Column(columnName = "cust_name",columnType = "varchar(15)")
private String name;
@Column(columnName = "cust_age",columnType = "int")
public int age;
public Customer(){
// System.out.println("Customer()...");
}
public Customer(int age){
this.age = age;
}
private Customer(String name, int age){
this.name = name;
this.age = age;
}
public void show(){
System.out.println("你好，我是一个Customer");
}
private String showNation(String nation){
return "我的国籍是：" + nation;
}
@Override
public String toString() {
return "Customer{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
5.3 读取和处理自定义注解
自定义注解必须配上注解的信息处理流程才有意义。
我们自己定义的注解，只能使用反射的代码读取。所以自定义注解的声明周期必须是RetentionPolicy.RUNTIME。
package com.atguigu03.reflectapply.apply2;
import org.testng.annotations.Test;
import java.lang.reflect.Field;
/**
* ClassName: AnnotationTest
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 10:48
* @Version 1.0
*/
public class AnnotationTest {
//获取类声明上的注解
@Test
public void test1(){
Class clazz = Customer.class;
Table annotation = (Table) clazz.getDeclaredAnnotation(Table.class);
System.out.println(annotation.value());//t_customer
}
//获取属性声明的注解
@Test
public void test2() throws Exception {
Class clazz = Customer.class;
Field nameField = clazz.getDeclaredField("name");
//获取属性声明上的注解
Column nameColumn = nameField.getDeclaredAnnotation(Column.class);
System.out.println(nameColumn.columnName());//cust_name
System.out.println(nameColumn.columnType()); //varchar(15)
}
}
6. 体会反射的动态性
体会1：
package com.atguigu03.reflectapply.dynamic;
/**
* @author 尚硅谷-宋红康
* @create 9:35
*/
public class Person {
//属性
private String name;
public int age;
//构造器
public Person(){
System.out.println("Person()...");
}
public Person(int age){
this.age = age;
}
private Person(String name, int age){
this.name = name;
this.age = age;
}
//方法
public void show(){
System.out.println("你好，我是一个Person");
}
private String showNation(String nation){
return "我的国籍是：" + nation;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package com.atguigu03.reflectapply.dynamic;
import org.testng.annotations.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Date;
/**
* ClassName: ReflectTest
* Description:
* 体会反射的动态性
* @Author 尚硅谷-宋红康
* @Create 11:31
* @Version 1.0
*/
public class ReflectTest {
//体会：静态性 编译和运行的时候明确对象的类型是Person
public Person getInstance(){
return new Person();
}
//体会：反射的动态性 根据传入的对象来确定返回的是什么类型的对象
//举例1：通过对象体现动态性
public <T> T getInstance(String className) throws Exception {//泛型方法
Class clazz = Class.forName(className);
Constructor con = clazz.getDeclaredConstructor();
con.setAccessible(true);
return (T) con.newInstance();
}
@Test
public void test1() throws Exception {
Person p1 = getInstance();
System.out.println(p1); //调用无参方法，返回的是固定类型的对象，静态 Person{name='null', age=0}
String className = "com.atguigu03.reflectapply.dynamic.Person";
Person per1 = getInstance(className);
System.out.println(per1); //根据传入参数的不同，返回对应的类型对象，体现了动态性 Person{name='null', age=0}
String className1 = "java.util.Date";
Date date1 = getInstance(className1);
System.out.println(date1); //Sat Dec 30 00:44:35 CST 2023
}
//体会：反射的动态性
//举例2：通过方法体现动态性
public Object invoke(String className,String methodName) throws Exception {
//1. 创建全类名对应的运行时类的对象
Class clazz = Class.forName(className);
Constructor con = clazz.getDeclaredConstructor();
con.setAccessible(true);
Object obj = con.newInstance();
//2. 获取运行时类中指定的方法，并调用
Method method = clazz.getDeclaredMethod(methodName);
method.setAccessible(true);
return method.invoke(obj);
}
@Test
public void test2() throws Exception {
String className = "com.atguigu03.reflectapply.dynamic.Person";
String methodName = "show";
Object returnValue = invoke(className,methodName); //你好，我是一个Person
System.out.println(returnValue); //方法的返回值为void,所以这里调用输出null
}
}
体会2：
案例：榨汁机榨水果汁，水果分别有苹果(Apple)、香蕉(Banana)、桔子(Orange)等。
效果如图。
提示：
1、声明(Fruit)水果接口，包含榨汁抽象方法：void squeeze(); /skwiːz/
2、声明各种水果类，实现水果接口，并重写squeeze();
3、声明榨汁机(Juicer)，包含运行方法：public void run(Fruit f)，方法体中，调用f的榨汁方法squeeze()
4、在src下，建立配置文件：config.properties，并在配置文件中配上fruitName=xxx（其中xx为某种水果的全类名）
5、在FruitTest测试类中，
（1）读取配置文件，获取水果类名，并用反射创建水果对象，
（2）创建榨汁机对象，并调用run()方法
测试：
水果接口
package com.atguigu03.reflectapply.exer;
/**
* ClassName: Fruit
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 11:48
* @Version 1.0
*/
public interface Fruit {
//榨汁儿的方法
void squeeze();
}
各种水果类
package com.atguigu03.reflectapply.exer;
/**
* ClassName: Apple
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 11:49
* @Version 1.0
*/
public class Apple implements Fruit{
@Override
public void squeeze() {
System.out.println("榨一杯苹果汁儿");
}
}
package com.atguigu03.reflectapply.exer;
/**
* ClassName: Banana
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 11:49
* @Version 1.0
*/
public class Banana implements Fruit{
@Override
public void squeeze() {
System.out.println("榨一杯香蕉汁儿");
}
}
package com.atguigu03.reflectapply.exer;
/**
* ClassName: Orange
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 11:50
* @Version 1.0
*/
public class Orange implements Fruit{
@Override
public void squeeze() {
System.out.println("榨一杯桔子汁儿");
}
}
榨汁机：调用水果接口的榨汁方法squeeze()
package com.atguigu03.reflectapply.exer;
/**
* ClassName: Juicer
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 11:50
* @Version 1.0
*/
public class Juicer {
public void run(Fruit f){
f.squeeze();
}
}
其中，配置文件【config.properties】存放在当前Module的src下
fruitName=com.atguigu03.reflectapply.exer.Banana
FruitTest测试类
package com.atguigu03.reflectapply.exer;
import org.testng.annotations.Test;
import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.util.Properties;
/**
* ClassName: FruitTest
* Description:
*
* @Author 尚硅谷-宋红康
* @Create 11:51
* @Version 1.0
*/
public class FruitTest {
@Test
public void test1() throws Exception {
//1. 读取配置文件中的信息，获取全类名
Properties pros = new Properties();
File file = new File("src/config.properties"); //默认在module下，如果是类加载器默认在src目录下
FileInputStream fis = new FileInputStream(file);
pros.load(fis);
String fruitName = pros.getProperty("fruitName");
//2. 通过反射，创建指定全类名对应的类的实例
Class clazz = Class.forName(fruitName);
Constructor con = clazz.getDeclaredConstructor();
con.setAccessible(true);
Fruit fruit = (Fruit) con.newInstance();
//3. 通过榨汁机的对象调用run()
Juicer juicer = new Juicer();
juicer.run(fruit); //榨一杯香蕉汁儿
}
}
