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;}@Overridepublic 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 {/** 使用反射之前可以执行的操作* */@Testpublic 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}/** 使用反射完成上述的操作* */@Testpublic 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类中私有的结构  ---> 暴力反射** */@Testpublic 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;}@Overridepublic 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实例的几种方式(掌握前三种)* */@Testpublic void test1() throws ClassNotFoundException {//方式1：调用运行时类的静态属性：classClass 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

举例：

    @Testpublic 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();// 只要元素类型与维度一样，就是同一个ClassSystem.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）

  • 执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。

  • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

  • 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

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:系统类加载器、应用程序类加载器
      • 我们自定义的类，默认使用的类的加载器。
    • 用户自定义类的加载器
      • 实现应用的隔离（同一个类在一个应用程序中可以加载多份）；数据的加密。

从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是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中执行如下的代码：* */@Testpublic 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}@Testpublic 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;}@Overridepublic 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加载指定的配置文件  方式二：现在通过类加载器同样可以读取配置文件* */@Testpublic 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流的时候读取配置文件的方式@Testpublic 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 {@Testpublic 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) 私有 有参构造器@Testpublic 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() 公有 无参构造器@Testpublic 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 + "年";}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Person o) {return 0;}@Overridepublic 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 {//获取属性的全部信息@Testpublic 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);}}//获取属性的具体信息，更加细粒度的//权限修饰符  变量类型  变量名@Testpublic 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 {//获取方法的全部信息@Testpublic 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,...{}@Testpublic 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.获取当前类中的所有的构造器@Testpublic void test1(){Class clazz = Person.class;Constructor[] cons = clazz.getDeclaredConstructors();for(Constructor c :cons){System.out.println(c);}}//2. 获取运行时类的父类@Testpublic void test2() throws ClassNotFoundException {Class clazz = Class.forName("com.atguigu03.reflectapply.data.Person");Class superClass = clazz.getSuperclass();System.out.println(superClass);}//3. 获取运行时类实现的接口@Testpublic 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. 获取运行时类所在的包@Testpublic void test4() throws ClassNotFoundException {Class clazz = Class.forName("com.atguigu03.reflectapply.data.Person");Package pack = clazz.getPackage();System.out.println(pack);}//5. 获取运行时类的带泛型的父类@Testpublic void test5() throws ClassNotFoundException {Class clazz = Class.forName("com.atguigu03.reflectapply.data.Person");Type superclass = clazz.getGenericSuperclass();System.out.println(superclass);}//6. 获取运行时类的父类的泛型 (难)/** 平时写的代码：* 类型1：业务逻辑代码 （多关注）* 类型2：算法逻辑代码 （多积累）** */@Testpublic void test6() throws ClassNotFoundException {Class clazz = Class.forName("com.atguigu03.reflectapply.data.Person");//获取带泛型的父类（Type是一个接口，Class实现了此接口Type superclass = clazz.getGenericSuperclass();//如果父类是带泛型的，则可以强转为ParameterizedTypeParameterizedType paramType = (ParameterizedType) superclass;//调用getActualTypeArguments()获取泛型的参数，结果是一个数组，因为可能有多个泛型参数。Type[] arguments = paramType.getActualTypeArguments();//获取泛型参数的名称System.out.println(((Class)arguments[0]).getName());}}
4.2.5 获取泛型父类信息（选讲）

示例代码获取泛型父类信息：

/* Type：* （1）Class* （2）ParameterizedType   * 		例如：Father<String,Integer>* 			ArrayList<String>* （3）TypeVariable* 		例如：T，U,E,K,V* （4）WildcardType* 		例如：* 		ArrayList<?>* 		ArrayList<? super 下限>* 		ArrayList<? extends 上限>* （5）GenericArrayType* 		例如：T[]* 	*/
public class TestGeneric {public static void main(String[] args) {//需求：在运行时，获取Son类型的泛型父类的泛型实参<String,Integer>//（1）还是先获取Class对象Class clazz = Son.class;//四种形式任意一种都可以//（2）获取泛型父类
//		Class sc = clazz.getSuperclass();
//		System.out.println(sc);/** getSuperclass()只能得到父类名，无法得到父类的泛型实参列表*/Type type = clazz.getGenericSuperclass();// Father<String,Integer>属于ParameterizedTypeParameterizedType pt = (ParameterizedType) type;//（3）获取泛型父类的泛型实参列表Type[] typeArray = pt.getActualTypeArguments();for (Type type2 : typeArray) {System.out.println(type2);}}
}
//泛型形参：<T,U>
class Father<T,U>{}
//泛型实参：<String,Integer>
class Son extends Father<String,Integer>{}
4.2.6 获取内部类或外部类信息（选讲）

public Class<?>[] getClasses()：返回所有公共内部类和内部接口。包括从超类继承的公共类和接口成员以及该类声明的公共类和接口成员。

public Class<?>[] getDeclaredClasses()：返回 Class 对象的一个数组，这些对象反映声明为此 Class 对象所表示的类的成员的所有类和接口。包括该类所声明的公共、保护、默认（包）访问及私有类和接口，但不包括继承的类和接口。

public Class<?> getDeclaringClass()：如果此 Class 对象所表示的类或接口是一个内部类或内部接口，则返回它的外部类或外部接口，否则返回null。

Class<?> getEnclosingClass() ：返回某个内部类的外部类

	@Testpublic 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 小 结

  1. 在实际的操作中，取得类的信息的操作代码，并不会经常开发。

  2. 一定要熟悉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 + "年";}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Person o) {return 0;}@Overridepublic 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;  公共的@Testpublic 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;  私有的（以下这种既可以获取私有的也可以获取公有的）@Testpublic 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; 静态的@Testpublic 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)@Testpublic 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()返回值为nullObject returnValue = showNationMethod.invoke(per,"CHN",10);System.out.println(returnValue);}//public static void showInfo()@Testpublic 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()返回值为nullObject 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 + "年";}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Person o) {return 0;}@Overridepublic 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) 直接使用这种无关权限的方式调用测试了@Testpublic 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()返回值为nullObject returnValue = showNationMethod.invoke(per,"CHN",10); //showNation...System.out.println(returnValue); //我的国籍是：CHN，生活了10年}//public static void showInfo()  静态的@Testpublic 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()返回值为nullObject 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 {@Testpublic 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;}@Overridepublic 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 {//获取类声明上的注解@Testpublic void test1(){Class clazz = Customer.class;Table annotation = (Table) clazz.getDeclaredAnnotation(Table.class);System.out.println(annotation.value());//t_customer}//获取属性声明的注解@Testpublic 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_nameSystem.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;}@Overridepublic 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 {//体会：静态性  编译和运行的时候明确对象的类型是Personpublic 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();}@Testpublic 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);}@Testpublic void test2() throws Exception {String className = "com.atguigu03.reflectapply.dynamic.Person";String methodName = "show";Object returnValue = invoke(className,methodName); //你好，我是一个PersonSystem.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{@Overridepublic 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{@Overridepublic 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{@Overridepublic 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 {@Testpublic 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); //榨一杯香蕉汁儿}
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/586630.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【AIGC科技展望】预测AIGC2025年的机会与挑战

【AIGC科技展望】预测AIGC2025年的机会与挑战

2025年&#xff0c;AIGC的机会与挑战 在未来的五年里&#xff0c;AIGC&#xff08;AI Generated Content&#xff09;将会成为一个越来越重要的领域。但是&#xff0c;伴随着机会而来的是挑战。在这篇文章中&#xff0c;我们将一起探讨AIGC的机会与挑战&#xff0c;并预测2025…
阅读更多...
机器学习系列13：通过随机森林获取特征重要性

机器学习系列13：通过随机森林获取特征重要性

我们已经知道通过 L1 正则化和 SBS 算法可以用来做特征选择。 我们还可以通过随机森林从数据集中选择相关的特征。随机森林里面包含了多棵决策树&#xff0c;我们可以通过计算特征在每棵决策树决策过程中所产生的的信息增益平均值来衡量该特征的重要性。 你可能需要参考&…
阅读更多...
【Spring实战】12 Thymeleaf

【Spring实战】12 Thymeleaf

文章目录 1. 定义2. 设计目标3. 官网4. Spring 集成 Thymeleaf1&#xff09;添加依赖2&#xff09;创建模版3&#xff09;创建Controller4&#xff09;启动程序5&#xff09;执行验证 5. 代码详细总结 1. 定义 Thymeleaf 是一个用于在 Web 应用程序中进行服务器端 Java 模板渲…
阅读更多...
Git：远程仓库的使用

Git：远程仓库的使用

查看当前的远程库 要查看当前配置有哪些远程仓库&#xff0c;可以用git remote 命令&#xff0c;它会列出每个远程库的简短名字。在克隆完某个项目后&#xff0c;至少可以看到一个名为origin 的远程库&#xff0c;Git 默认使用这个名字来标识你所克隆的原始仓库&#xff1a; 也…
阅读更多...
UE4运用C++和框架开发坦克大战教程笔记（十三）（第40~42集）

UE4运用C++和框架开发坦克大战教程笔记（十三）（第40~42集）

UE4运用C和框架开发坦克大战教程笔记&#xff08;十三&#xff09;&#xff08;第40~42集&#xff09; 40. 多按键绑定41. 自动生成对象42. 资源模块数据结构测试自动生成对象按资源类型生成对象 40. 多按键绑定 上节课实现了按键绑定系统的 4 种基础绑定&#xff0c;这节课来…
阅读更多...
python+django高校教材共享管理系统PyCharm 项目

python+django高校教材共享管理系统PyCharm 项目

本中原工学院教材共享平台采用的数据库是mysql&#xff0c;使用nodejs技术开发。在设计过程中&#xff0c;充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。系统所要实现的功能分析&#xff0c;对于现在网络方便的管理&…
阅读更多...
Java：IO流——字节流和字符流

Java：IO流——字节流和字符流

目录 IO流的基本概念 IO流体系结构 FileOutputStream字节输出流 构造方法 成员方法 细节 关流 FileInputStream字节输入流 构造方法及成员方法 read不带参数代码示例 read带参数代码示例​编辑 将字节数组或字符数组转成字符串 FileReader 字符输入流 构造方法和…
阅读更多...
在macOS中搭建.NET MAUI开发环境

在macOS中搭建.NET MAUI开发环境

文章目录 准备安装扩展安装 .NET安装工作负载安装 Xcode 命令行工具调试安卓应用安装 JDK安装 Android SDK 安装 Android 模拟器安装模拟器安装镜像创建虚拟机 同意许可条款创建 MAUI 项目调试 MAUI 应用切换调试目标 参考资料 准备 一台 macOS Monterey 以上的电脑安装 XCode…
阅读更多...
分类模型评估方法

分类模型评估方法

1.数据集划分 1.1 为什么要划分数据集? 思考&#xff1a;我们有以下场景&#xff1a; 将所有的数据都作为训练数据&#xff0c;训练出一个模型直接上线预测 每当得到一个新的数据&#xff0c;则计算新数据到训练数据的距离&#xff0c;预测得到新数据的类别 存在问题&…
阅读更多...
番茄台式电脑装机日记

番茄台式电脑装机日记

番茄台式电脑装机日记 start 时至今日&#xff0c;终于圆了年少时的梦&#xff1a;拥有自己的一台台式电脑。就好像第一次学会系鞋带&#xff0c;第一次剥榴莲&#xff0c;亲手组装自己的第一台台式电脑&#xff0c;这个体验完全是此生少有且独特的完美体验。作者&#xff1a…
阅读更多...
Docker单点部署Seata(2.0.0) + Nacos(v2.3.0) + Mysql(5.7)

Docker单点部署Seata(2.0.0) + Nacos(v2.3.0) + Mysql(5.7)

文章目录 一、部署Nacos二、部署Mysql三、Seata准备工作1. 记住nacos、mysql、宿主机的ip2. 建立数据库3. Nacos远程配置文件 四、部署Seata五、初步检验Seata部署情况六、微服务使用Seata1.引入依赖2. application.yml配置 七、遇到的坑1. Nacos显示Seata服务的ip为容器内网ip…
阅读更多...
使用SpringBoot AOP记录操作日志和异常日志

使用SpringBoot AOP记录操作日志和异常日志

使用SpringBoot AOP记录操作日志和异常日志 平时我们在做项目时经常需要对一些重要功能操作记录日志&#xff0c;方便以后跟踪是谁在操作此功能&#xff1b;我们在操作某些功 能时也有可能会发生异常&#xff0c;但是每次发生异常要定位原因我们都要到服务器去查询日志才能找…
阅读更多...
第3课 获取并播放音频流

第3课 获取并播放音频流

本课对应源文件下载链接&#xff1a; https://download.csdn.net/download/XiBuQiuChong/88680079 FFmpeg作为一套庞大的音视频处理开源工具&#xff0c;其源码有太多值得研究的地方。但对于大多数初学者而言&#xff0c;如何快速利用相关的API写出自己想要的东西才是迫切需要…
阅读更多...
【机器学习】卷积神经网络（一）

【机器学习】卷积神经网络（一）

一、网络结构 典型CNN结构 卷积神经网络是一种能够从图像、声音或其他类型的数据中学习特征的人工智能模型。你可以把它想象成一个有很多层的过滤器&#xff0c;每一层都能够提取出数据中的一些有用的信息&#xff0c;比如边缘、形状、颜色、纹理等。这些信息可以帮助卷积神经网…
阅读更多...
【Matlab】ELM极限学习机时序预测算法

【Matlab】ELM极限学习机时序预测算法

资源下载&#xff1a; https://download.csdn.net/download/vvoennvv/88681649 一&#xff0c;概述 ELM&#xff08;Extreme Learning Machine&#xff09;是一种单层前馈神经网络结构&#xff0c;与传统神经网络不同的是&#xff0c;ELM的隐层神经元权重以及偏置都是随机产生的…
阅读更多...
【Android12】Android Framework系列---tombstone墓碑生成机制

【Android12】Android Framework系列---tombstone墓碑生成机制

tombstone墓碑生成机制 Android中程序在运行时会遇到各种各样的问题&#xff0c;相应的就会产生各种异常信号&#xff0c;比如常见的异常信号 Singal 11&#xff1a;Segmentation fault表示无效的地址进行了操作&#xff0c;比如内存越界、空指针调用等。 Android中在进程(主要…
阅读更多...
Apache-ActiveMQ 反序列化漏洞(CVE-2015-5254)复现

Apache-ActiveMQ 反序列化漏洞(CVE-2015-5254)复现

CVE-2016-3088 一、环境搭建 Java:jdk8 影响版本 Apache ActiveMQ < 5.13.0 二、用docker搭建漏洞环境 访问一下web界面 然后进入admin目录登录 账号:admin 密码:admin 三、工具准备 cd /opt wget https://github.com/matthiaskaiser/jmet/releases/download/0.1.0/jmet-0…
阅读更多...
QT上位机开发（第一个应用）

QT上位机开发（第一个应用）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 不管是软件&#xff0c;还是硬件&#xff0c;如果我们能够顺利启动第一个应用&#xff0c;点亮第一个电路的话&#xff0c;这对我们的信心来说会有…
阅读更多...
如何恢复 iPhone 上永久删除的照片？

如何恢复 iPhone 上永久删除的照片？

2007年&#xff0c;苹果公司推出了一款惊天动地的智能手机&#xff0c;也就是后来的iPhone。你会惊讶地发现&#xff0c;迄今为止&#xff0c;苹果公司已经售出了 7 亿部 iPhone 设备。根据最新一项调查数据&#xff0c;智能手机利润的 95% 都进了苹果公司的腰包。 如此受欢迎…
阅读更多...
【Vue2+3入门到实战】（16）VUEVue路由的重定向、404、编程式导航、path路径跳转传参 详细代码示例

【Vue2+3入门到实战】（16）VUEVue路由的重定向、404、编程式导航、path路径跳转传参 详细代码示例

目录 一、Vue路由-重定向1.问题2.解决方案3.语法4.代码演示 二、Vue路由-4041.作用2.位置3.语法4.代码示例 三、Vue路由-模式设置1.问题2.语法 四、编程式导航-两种路由跳转方式1.问题2.方案3.语法4.path路径跳转语法5.代码演示 path跳转方式6.name命名路由跳转7.代码演示通过n…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023