java注解(Annotation)和反射(Reflection)

你的名字 2024-03-30 12:35 64阅读 0赞

#### 文章目录 ####

*  重要的点
 *  一 注解 ( A n n o t a t i o n ) (Annotation) (Annotation)
 *   *  1.1 注解初识
     *  1.2 内置注解
     *  1.3 内置注解代码演示
     *  1.4 元注解 ( m e t a − a n n o t a t i o n ) (meta-annotation) (meta−annotation)
     *  1.5 元注解代码演示
     *  1.6 自定义注解
     *  1.7 自定义注解代码演示
 *  二 反射 ( R e f l e c t i o n ) (Reflection) (Reflection)
 *   *  2.0 关于动态语言和静态语言的补充
     *  2.1 Java反射机制概述
     *   *  2.1.1 Java反射机制提供的功能
         *  2.1.2 Java反射的优点和缺点
         *  2.1.3 Java反射相关的主要API
         *  2.1.4 java反射演示
     *  2.2 理解class类并获取class实例
     *   *  2.2.1 Class类
         *  2.2.2 Class类的常用方法
         *  2.2.3 获取Class类的实例
         *  2.2.4 获取Class类代码演示
         *  2.2.5 拥有Class对象的类型
         *  2.2.6 内置数据类型、注解、void的Class类代码演示
     *  2.3 Java内存分析
     *  2.4 类的加载与ClassLoader
     *   *  2.4.1 代码演示
         *  2.4.2 初始化时间
         *  2.4.3 初始化代码演示
         *  2.4.4 类加载器的作用
         *  2.4.5 类加载器代码演示
     *  2.5 调用运行时类的指定结构
     *   *  2.5.1 通过反射获取运行时类的完整结构
         *  2.5.2 代码演示
         *  2.5.4 调用指定的方法
         *  2.5.5 反射检测性能分析代码演示
         *  2.5.6 反射操作泛型
         *  2.5.7 反射操作泛型代码演示
         *  2.5.8 反射操作注解
         *  2.5.9 ORM练习代码
     *  2.6 创建运行时类的对象
     *   *  2.6.1 创建运行时对象
         *  2.6.2 创建运行时对象代码演示

## 重要的点 ##

*  ***感谢狂神说对java教学的奉献。感谢有你！***
 *  ***通过反射机制编程实现对这些元数据的访问。***
 *  ***概念理论看不懂可以结合代码演示认真体会***
 *  ***文末，有彩蛋哟！***

## 一 注解 ( A n n o t a t i o n ) (Annotation) (Annotation) ##

### 1.1 注解初识 ###

*  Annotation是从JDK5.0开始引入新技术
 *  Annotation的作用：
    
     *  ***可以对程序作出解释，类似于注释（comment）***
     *  ***可以被其他程序（此如：编译器等）读取***
 *  Annotation的格式：
    
     *  ***注解是以"@注释名"在代码中存在的，同时还可以添加一些参数值。***

@SuppressWarnings(value="unchecked”）

*  注解的使用范围：package，class，method，field等上面，相当于给他们添加了额外的辅助信息。

### 1.2 内置注解 ###

<table> 
 <thead> 
  <tr> 
   <th>注解名称</th> 
   <th>详解</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Override</td> 
   <td>定义在<span><span><span> j a v a . l a n g . O v e r r i d e java.lang.Override </span><span><span><span style="height: 0.8889em; vertical-align: -0.1944em;"></span><span>ja</span><span style="margin-right: 0.0359em;">v</span><span>a</span><span>.</span><span style="margin-right: 0.0197em;">l</span><span>an</span><span style="margin-right: 0.0359em;">g</span><span>.</span><span style="margin-right: 0.0278em;">O</span><span style="margin-right: 0.0359em;">v</span><span style="margin-right: 0.0278em;">err</span><span>i</span><span>d</span><span>e</span></span></span></span></span>中，此注释只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明</td> 
  </tr> 
  <tr> 
   <td>@Deprecated</td> 
   <td>定义在<span><span><span> j a v a . l a n g . D e p r e c a t e d java.lang.Deprecated </span><span><span><span style="height: 0.8889em; vertical-align: -0.1944em;"></span><span>ja</span><span style="margin-right: 0.0359em;">v</span><span>a</span><span>.</span><span style="margin-right: 0.0197em;">l</span><span>an</span><span style="margin-right: 0.0359em;">g</span><span>.</span><span>De</span><span>p</span><span>rec</span><span>a</span><span>t</span><span>e</span><span>d</span></span></span></span></span>中，此注释可以用于修辞方法，属性，类，不鼓励程序员使用这样的元素</td> 
  </tr> 
  <tr> 
   <td>@SuppressWarnings<span><span><span> 定义在 定义在 </span><span><span><span style="height: 0.6833em;"></span><span>定义在</span></span></span></span></span>java.lang.SuppressWarnings$中，用来抑制编译时的警告信息需要添加一个已经定义好的参数才能正确使用</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

@SuppressWarnings("all")
    @SuppressWarnings("unchecked")
    @SuppressWarnings(value={
        "unchecked","deprecation"})

### 1.3 内置注解代码演示 ###

/**
     * @author 缘友一世
     * date 2022/12/26-11:28
     */
    //内置注释的了解和演示
    public class AnnotationTest {
        
        public static void main(String[] args) {
        
            Man man = new Man();
            //使用@Deprecated注释的方法或者类时，会出现横线的提示
            man.test();
        }
    
    }
    //所有类默认继承Object类
    class Man extends Object {
        
        public String name;
    
        //@Override 重写注释
        @Override
        public String toString() {
        
            return "man{" +
                    "name='" + name + '\'' +
                    '}';
        }
    
        //Deprecated 不推荐使用注释，但是可以使用，或者存在更好的方式
        @Deprecated
        public void test() {
        
            System.out.println("Deprecated");
        }
    
        @SuppressWarnings("all")
        //未调用此方法时，方法名会变为灰色，可使用@SuppressWarnings("all")镇压警号
        //一般情况下，不建议使用，可以帮我们避免一些错误
        public void test02() {
        
            System.out.println("test01");
        }
    }

### 1.4 元注解 ( m e t a − a n n o t a t i o n ) (meta-annotation) (meta−annotation) ###

*  ***元注解的作用就是负责注解其他注解。***
 *  ***Java定义了4个标准的元注解类型，他们被用来、提供对其他注解类型作说明***
 *  这些类型和它们所支持的类在 j a v a . l a n g . a n n o t a t i o n java.lang.annotation java.lang.annotation包中可以找到.**（@Target，@Retention，@Documented，@Inherited）**

<table> 
 <thead> 
  <tr> 
   <th>元注解</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@Target</td> 
   <td>用于描述注解的使用范围</td> 
  </tr> 
  <tr> 
   <td>@Retention</td> 
   <td>表示保存该注释信息的级别，用于描述注解的生命周期（SOURCE&gt;CLASS&gt;RUNTIME)</td> 
  </tr> 
  <tr> 
   <td>@Document</td> 
   <td>说明该注解将被包含在javadoc中</td> 
  </tr> 
  <tr> 
   <td>@Inherited</td> 
   <td>说明子类可以继承父类中的该注解</td> 
  </tr> 
 </tbody> 
</table>

### 1.5 元注解代码演示 ###

/**
     * @author 缘友一世
     * date 2022/12/26-11:43
     */
    //元注释的认识和使用
    public class MetaAnnotationTest {
        
        @MyAnnotation
        public static void main(String[] args) {
        
    
        }
    
    }
    //@Retention 标注注解的有效范围 SOURCE<CLASS<RUNTIME
    //@Retention(value=RetentionPolicy.RUNTIME)
    //当注解的参数只有一个时，就可以省略简写，如下形式
    @Retention(RetentionPolicy.RUNTIME)
    //Target 标记注解的使用范围 方法、类、变量、包... 其参数类型时字符串数组
    //@Target(value = {ElementType.METHOD,ElementType.TYPE})
    @Target(value = {
        ElementType.METHOD,ElementType.TYPE})
    @Inherited  //@Inherited 子类可继承父类的注解
    @Documented //@Documented 将注解生成在JAVADoc中
    //@interface 定义一个注释
    @interface MyAnnotation {
        
    
    }

### 1.6 自定义注解 ###

*   @ i n t e r f a c e @interface @interface自定义注解，自动继承了 j a v a . l a n g . a n n o t a t i o n . A n n o t a t i o n java.lang.annotation.Annotation java.lang.annotation.Annotation接口

1.   @ i n t e r f a c e @interface @interface用来声明一个注解，格式： p u b l i c @ i n t e r f a c e 注解名（定义内容） public@interface注解名（定义内容） public@interface注解名（定义内容）
2.  ***其中的每一个方法实际上是声明了一个配置参数***
3.  ***方法的名称就是参数的名称***
4.  ***返回值类型就是参数的类型（返回值只能是基本类型，Class，String，enum）***.
5.  可以通过 d e f a u l t default default来声明参数的默认值
6.  ***如果只有一个参数成员，一般参数名为value***
7.  ***注解元素必须要有值，在定义注解元素时，经常使用空字符串，0作为默认值***

//自定义注解
    public class CustomizedAnnotationTest {
        
        //没有默认初始化的参数必须——显式定义；否则，报错
        @MyAnnotation2(name = "tom",numbers = {
        "0001","002"})
        public void test01(){
        
    
        }
        @MyAnnotation3("Cat")
        public void test02() {
        
    
        }
    }

### 1.7 自定义注解代码演示 ###

import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * @author 缘友一世
     * date 2022/12/26-11:57
     */
    //自定义注解
    public class CustomizedAnnotationTest {
        
        //没有默认初始化的参数必须——显式定义；否则，报错
        @MyAnnotation2(name = "tom",numbers = {
        "0001","002"})
        public void test01(){
        
    
        }
        @MyAnnotation3("Cat")
        public void test02() {
        
    
        }
    }
    @Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation2{
        
        //注解的参数： 参数类型+参数名()
        //没有默认初始化的参数必须——显式定义；否则，报错
        //已经默认初始化的参数，不显式定义，也不会报错，也可以显式定义。
        String name();//自定义参数变量的后面要有（）
        String[] numbers();
        int age() default 0;//默认参数值
        int score() default -1;//默认值-1，代表不存在
    }
    
    //只有一个参数时，建议定义参数名为value
    @Target({
        ElementType.TYPE,ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation3{
        
        String value();
    }

## 二 反射 ( R e f l e c t i o n ) (Reflection) (Reflection) ##

### 2.0 关于动态语言和静态语言的补充 ###

*  动态语言
    
     *  ***一类在运行时可以改变其结构的语言***：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说：***在运行时代码可以根据某些条件改变自身结构。***
     *  主要动态语言：**Object-C、C\#、JavaScript、PHP、Python……**
 *  静态语言
    
     *  ***运行时结构不可变的语言就是静态语言，如Java、c、C++。***
     *  ***Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性我们可以利用反射机制获得类似动态语言的特性。***

### 2.1 Java反射机制概述 ###

*  反射是Java被视为动态语言的关键，反射机制允许程序在执行期借助于反射API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

Class class=Class.forName("java.lang.String")

*  **java虚拟机加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有这个对象就包含了完整的类的结构信息个Class对象）**
 *  **通过这个对象可以看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以形象的称之为：反射。**

![在这里插入图片描述][89cd805a7c474573b3f1532b3f7eb4cd.png]

#### 2.1.1 Java反射机制提供的功能 ####

*  在运行时判断任意一个对象所属的类
 *  在运行时构造任意一个类的对象
 *  在运行时判断任意一个类所具有的成员变量和方法
 *  在运行时获取泛型信息
 *  在运行时调用任意一个对象的成员变量和方法
 *  在运行时处理注解
 *  生成动态代理

#### 2.1.2 Java反射的优点和缺点 ####

<table> 
 <thead> 
  <tr> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>可以实现动态创建对象和编译，体现出很大的灵活性</td> 
   <td>对性能有影响。<br>使用反射基本上是一种解释操作，这类操作总是慢于直接执行相同的操作。</td> 
  </tr> 
 </tbody> 
</table>

#### 2.1.3 Java反射相关的主要API ####

<table> 
 <thead> 
  <tr> 
   <th>API</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>java.lang.Class</td> 
   <td>代表一个类</td> 
  </tr> 
  <tr> 
   <td>java.lang.reflect.Method</td> 
   <td>代表类的方法</td> 
  </tr> 
  <tr> 
   <td>java.lang.reflect.Field</td> 
   <td>代表类的成员变量</td> 
  </tr> 
  <tr> 
   <td>java.lang.reflect.Constructor</td> 
   <td>代表类的构造器</td> 
  </tr> 
 </tbody> 
</table>

#### 2.1.4 java反射演示 ####

/**
     * @author 缘友一世
     * date 2022/12/26-21:53
     */
    //认识反射
    public class demo02 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
            //通过反射获取类的Class对象
            Class<?> c1 = Class.forName("Reflection.User02");
            Class<?> c2 = Class.forName("Reflection.User02");
            System.out.println(c1);
            //一个类在内存中只有一个Class对象
            //一个类被加载后，类的整个结构都会被封装在Class对象中
            System.out.println("c1的hashCode值"+c1.hashCode());
            System.out.println("c2的hashCode值"+c2.hashCode());
    
        }
    }
    class User02 {
        
        private String name;
        private int id;
        private int age;
    
        public User02() {
        
        }
    
        public User02(String name, int id, int age) {
        
            this.name = name;
            this.id = id;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "user02{" +
                    "name='" + name + '\'' +
                    ", id=" + id +
                    ", age=" + age +
                    '}';
        }
    }

![在这里插入图片描述][36fd31c031dc4561985d7c66cc252d48.png]

### 2.2 理解class类并获取class实例 ###

*  在Object类中定义了以下的方法，`getClass()`被所有子类继承.
 *  返回值的类型是一个Class此类是Java反射的源头类。
 *  反射从程序的运行结果来看，即：可以通过对象反射求出类的名称。对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类实现了哪些接口。

public final Class getClass(）

![在这里插入图片描述][488e773672b54ef4aff2cea2af1953b2.png]

#### 2.2.1 Class类 ####

*  对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构的有关信息。
 *  Class本身也是一个类
 *  Class对象只能由系统建立对象
 *  一个加载的类在JVM中只会有一个Class实例
 *  一个Class对象对应的是一个加载到JVM中的一个.class文件
 *  每个类的实例都会记录是由哪个Class实例所生成
 *  通过Class可以完整地得到一个类中的所有被加载的结构
 *  Class类是反射的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

#### 2.2.2 Class类的常用方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>功能说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>static ClassforName(String name)</td> 
   <td>返回指定类名name的Class对象</td> 
  </tr> 
  <tr> 
   <td>Object newlnstance()</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>getName(）</td> 
   <td>返回此Class对象所表示的实体（类，接口，数组类或void）的名称</td> 
  </tr> 
  <tr> 
   <td>Class getSuperClass()</td> 
   <td>返回当前Class对象的父类的Class对象</td> 
  </tr> 
  <tr> 
   <td>Class[] getinterfaces()</td> 
   <td>获取当前Class对象的接口</td> 
  </tr> 
  <tr> 
   <td>ClassLoader getClassLoader()</td> 
   <td>返回该类的类加载器</td> 
  </tr> 
  <tr> 
   <td>ConstructorflgetConstructors()</td> 
   <td>返回一个包含某些Constructor对象的数组</td> 
  </tr> 
  <tr> 
   <td>Method getMothed（Stringname,Class…T）</td> 
   <td>返回一个Method对象，此对象的形参类型为paramType</td> 
  </tr> 
  <tr> 
   <td>Field[] getDeclaredFields()</td> 
   <td>返回Field对象的一个数组</td> 
  </tr> 
 </tbody> 
</table>

#### 2.2.3 获取Class类的实例 ####

1.  若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高

Class class=Person.class;

1.  已知某个类的实例，调用该实例的getclass()方法法获取Class对象

Class class=person.getClass();

1.  已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取可能抛出ClassNotFoundException

Class class=Class.forName(demo01.Student”);

1.  内置基本数据类型可以直接用`类名.Type`

Class<Integer> c4 = Integer.TYPE;

1.  利用ClassLoader

在这里插入代码片

#### 2.2.4 获取Class类代码演示 ####

/**
     * @author 缘友一世
     * date 2022/12/26-22:00
     */
    public class demo03 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
            Person03 person = new Student03();
            System.out.println(person.name);
    
            //方式一：通过对象获得
            Class c1 = person.getClass();
            System.out.println(c1);
            System.out.println("c1的hashCode值:"+c1.hashCode());
    
            //方式二：通过forName获得
            Class<?> c2 = Class.forName("Reflection.Student03");
            System.out.println(c2);
            System.out.println("c2的hashCode值:"+c2.hashCode());
    
            //方式三：通过类名.class获得
            Class<Student03> c3 = Student03.class;
            System.out.println(c3);
            System.out.println("c3的hashCode值:"+c3.hashCode());
    
            //方式四：基本内置类型的包装类都有一个Type属性
            Class<Integer> c4 = Integer.TYPE;
            System.out.println(c4);
    
            //获取父类类型
            Class c5 = c1.getSuperclass();
            System.out.println(c5);
    
        }
    }
    class Person03 {
        
        public String name;
        public Person03() {
        
    
        }
    
        public Person03(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "Person03{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    class Student03 extends Person03 {
        
        public Student03() {
        
            this.name="student";
        }
    }
    class Teacher03 extends Person03 {
        
        public Teacher03() {
        
            this.name="teacher";
        }
    }

![在这里插入图片描述][5fd66beb67dd40678028d6f80602cd44.png]

#### 2.2.5 拥有Class对象的类型 ####

*  class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
 *  interface：接口
 *  \[\]：数组
 *  enum：枚举
 *  annotation：注解@interface
 *  primitivetype：基本数据类型
 *  void

#### 2.2.6 内置数据类型、注解、void的Class类代码演示 ####

/**
     * @author 缘友一世
     * date 2022/12/26-22:17
     */
    //所有类型的Class
    public class demo04 {
        
        public static void main(String[] args) {
        
            Class c1 = Object.class;   //类
            Class c2=Comparable.class; //接口
            Class c3=String[].class;   //一维数组
            Class c4=char[][].class;   //二维数组
            Class c5= Override.class;  //注解
            Class c6= Element.class;   //枚举
            Class c7=Integer.class;    //基本类型
            Class c8=void.class;       //void
            Class c9=Class.class;      //Class
            System.out.println(c1);
            System.out.println(c2);
            System.out.println(c3);
            System.out.println(c4);
            System.out.println(c5);
            System.out.println(c6);
            System.out.println(c7);
            System.out.println(c8);
            System.out.println(c9);
    
            //不同的同类对象具有相同的Class类
            int[] arr1=new int[10];
            int[] arr2=new int[100];
            System.out.println(arr1.getClass().hashCode());
            System.out.println(arr2.getClass().hashCode());
        }
    }

![在这里插入图片描述][f578052335e24241a1a5b77fb1d46174.png]

### 2.3 Java内存分析 ###

![在这里插入图片描述][c5a49b0a7c5a4cecbff02cabe00929d3.png]  
![在这里插入图片描述][302c72a86ebe4b809a2d650722eddeff.png]

### 2.4 类的加载与ClassLoader ###

*  加载：将class文件字节码内容加载到内存中，***并将这些静态数据转换成方法区的运行时数据结构***，然后生成一个代表这个类的 j a v a . l a n g . C l a s s java.lang.Class java.lang.Class对象
 *  链接：将Java类的二进制代码合并到VM的运行状态之中的过程
    
     *  验证：确保加载的类信息符合JVM规范，没有安全方面的问题
     *  准备：***正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。***
     *  解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
 *  初始化：
    
     *  执行类构造器`<clinit>()`方法的过程。类构造器`<clinit>()`方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
     *  ***当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化***
     *  虚拟机会保证一个类的`<clinit>()`方法在多线程环境中被正确加锁和同步。  
        ![在这里插入图片描述][f4e2206661534e92906dc07df85e167c.png]

#### 2.4.1 代码演示 ####

/**
     * @author 缘友一世
     * date 2022/12/26-22:24
     */
    //类的加载理解
    public class demo05 {
        
        public static void main(String[] args) {
        
            A a = new A();
            System.out.println(A.m);
        }
    }
    /*
    * 1. 加载到内存，产生一个类对应class对象
    * 2.链接，链接结束后m=0
    * 3.初始化
    *       <clinit>() {
    *              System.out.println("A类静态代码初始化");
    *              m=2;
    *              m=1;
    *       }
    * */
    class A {
        
        static {
        
            System.out.println("A类静态代码初始化");
            m=2;
        }
        static int m=1;
        public A() {
        
            System.out.println("A类的无参构造初始化");
        }
    }

![在这里插入图片描述][c7f7d8e84a8847659b8287cee74d35ac.png]

#### 2.4.2 初始化时间 ####

<table> 
 <thead> 
  <tr> 
   <th>类的主动引用（一定会发生类的初始化）</th> 
   <th>类的被动引用（不会发生类的初始化）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>当虚拟机启动，先初始化main方法所在的类<br>new一个类的对象<br>调用类的静态成员（除了final常量）和静态方法<br>使用java.lang.reflect包的方法对类进行反射调用<br>当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类</td> 
   <td>当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化<br>通过数组定义类引用，不会触发此类的初始化<br>引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）</td> 
  </tr> 
 </tbody> 
</table>

#### 2.4.3 初始化代码演示 ####

/**
     * @author 缘友一世
     * date 2022/12/26-22:33
     */
    //测试类何时初始化
    public class demo06 {
        
        static {
        
            System.out.println("Main类被加载");
        }
        public static void main(String[] args) throws ClassNotFoundException {
        
            demo06 dm = new demo06();
            dm.test01();
            /*
                Main类被加载
                Father类被加载
                Son类被加载
             */
            //dm.test02();
            /*
                Main类被加载
                Father类被加载
                1
             */
            //dm.test03();// Main类被加载
            dm.test04();
            /*
             Main类被加载
             666
            */
        }
        public void test01() throws ClassNotFoundException {
        
            //1. 主动引用
            Son son = new Son();
    
            //反射也会产生主动引用
            Class<?> c1 = Class.forName("Reflection.Son");
        }
        public void test02() {
        
            //不会产生类的引用的方法 子类调用父类的静态变量
            System.out.println(Son.x1);
        }
        public void test03() {
        
            //只是申请空间和变量名，虚拟机启动，先初始化Main所在的类，所以只有Main被加载
            Son[] sons = new Son[5];
        }
        public void test04() {
        
            //类中的常量并不会导致子类和父类的初始化
            System.out.println(Son.m);
        }
    }
    class Father{
        
        static int x1=1;
        static {
        
            System.out.println("Father类被加载");
        }
    }
    class Son extends Father{
        
        static {
        
            System.out.println("Son类被加载");
            x=10;
        }
        static int x=100;
        static final int m=666;
    }

#### 2.4.4 类加载器的作用 ####

*  类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
 *  类缓存：标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象  
    ![在这里插入图片描述][3559314659b540139b12cac6dfe335b9.png]
 *  类加载器的作用就是把类(class)装载进内存。JVM规范定义了如下类型的加载器。
 *  引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取
 *  扩展类加载器：负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库
 *  系统类加载器：负责java-classpath或-D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器  
    ![在这里插入图片描述][b3166c2c46ee432eb89b7447d6803c2e.png]

#### 2.4.5 类加载器代码演示 ####

package Reflection;
    
    /**
     * @author 缘友一世
     * date 2022/12/26-22:56
     */
    public class demo07 {
        
        public static void main(String[] args) throws ClassNotFoundException {
        
            //获取系统类的加载器
            ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
            System.out.println(systemClassLoader);
            //获取系统类加载器的父类加载器-->拓展类加载器
            ClassLoader parent = systemClassLoader.getParent();
            System.out.println(parent);
            //获取拓展类加载器的父类加载器-->根加载器(c/c++编写)
            //引导类加载器，用来装载核心类库，加载器无法直接获取，所以返回为null
            ClassLoader parent1 = parent.getParent();
            System.out.println(parent1);
    
            //测试当前类是哪个加载器加载的
            ClassLoader classLoader = Class.forName("Reflection.demo07").getClassLoader();
            System.out.println(classLoader);
    
            //测试JDK内置的类是哪个加载器加载的-->根加载器
            ClassLoader classLoader1 = Class.forName("java.lang.Object").getClassLoader();
            System.out.println(classLoader1);//null
    
            //获取系统类加载器可以加载的路径
            System.out.println(System.getProperty("java.class.path"));
            //双亲委派机制
            /*
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\charsets.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\deploy.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\access-bridge-64.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\cldrdata.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\dnsns.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jaccess.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\jfxrt.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\localedata.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\nashorn.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunec.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunjce_provider.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunmscapi.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\sunpkcs11.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\ext\zipfs.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\javaws.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\jce.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfr.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\jfxswt.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\jsse.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\management-agent.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\plugin.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\resources.jar;
            C:\Program Files\Java\jdk1.8.0_131\jre\lib\rt.jar; 重要的类库
            C:\Users\HP\Desktop\program\java basic grammar\out\production\basic grammar;
            C:\Users\HP\Desktop\program\java basic grammar\basic grammar\src\IO流\libs\commons-io-2.11.0.jar;
            C:\Users\HP\Desktop\program\java basic grammar\basic grammar\src\多线程\lib\commons-io-2.11.0.jar;
            C:\Program Files\JetBrains\IntelliJ IDEA 2022.2.1\lib\idea_rt.jar;
            C:\Users\HP\AppData\Local\JetBrains\IntelliJIdea2022.2\captureAgent\debugger-agent.jar
             */
        }
    }

![在这里插入图片描述][12b940bc8a894f91828de6877298840e.png]

### 2.5 调用运行时类的指定结构 ###

#### 2.5.1 通过反射获取运行时类的完整结构 ####

*  实现的全部接口(Interface)
 *  所继承的父类(Superclass)
 *  全部的构造器( Constructor)
 *  全部的方法(Method)
 *  全部的字段(Field)
 *  注解(Annotation)

#### 2.5.2 代码演示 ####

import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    
    /**
     * @author 缘友一世
     * date 2022/12/26-23:12
     */
    //获得类的信息
    public class demo08 {
        
        public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        
            Class<?> c1 = Class.forName("Reflection.User08");
    
            //获取类的名字
            System.out.println("获取类的名字");
            System.out.println(c1.getName());//包名+类名
            System.out.println(c1.getSimpleName());//类名
    
            //获取类的属性
            System.out.println("-----------");
            //获取public属性
            System.out.println("获取类的public属性");
            Field[] fields = c1.getFields();
            for (Field field : fields) {
        
                System.out.println(field);
            }
            System.out.println("-----------");
            System.out.println("获取所有的属性");
            //获取所有的属性
            Field[] fields1 = c1.getDeclaredFields();
            for (Field field : fields1) {
        
                System.out.println(field);
            }
    
            System.out.println("-----------");
            System.out.println("获取指定属性的值");
            //获取指定属性的值[public&private访问权限]
            Field name = c1.getDeclaredField("phone");
            Field name2 = c1.getDeclaredField("name");
            System.out.println("public属性的"+name);
            System.out.println("private属性的"+name2);
    
            System.out.println("-----------");
            //获取类的方法[包含父类的方法]
            //public访问权限的方法
            System.out.println("获取public访问权限的方法");
            Method[] methods = c1.getMethods();
            for(Method method:methods) {
        
                System.out.println("public:"+method);
            }
            //类的所有方法
            System.out.println("获取类的所有方法");
            Method[] declaredMethods = c1.getDeclaredMethods();
            for (Method declaredMethod : declaredMethods) {
        
                System.out.println("getDeclaredMethods:"+declaredMethod);
            }
    
            System.out.println("-----------");
            //获取指定方法
            System.out.println("获取类的指定方法");
            Method getName = c1.getMethod("getName", null);
            Method setName = c1.getMethod("setName", String.class);
            System.out.println(getName);
            System.out.println(setName);
    
            System.out.println("-----------");
            //获取类的构造器
            System.out.println("获取类public构造器");
            Constructor<?>[] constructors = c1.getConstructors();
            for (Constructor<?> constructor : constructors) {
        
                System.out.println("public Constructor:"+constructor);
            }
            System.out.println("获取类所有的构造器");
            Constructor<?>[] declaredConstructors = c1.getDeclaredConstructors();
            for (Constructor<?> declaredConstructor : declaredConstructors) {
        
                System.out.println("declaredConstructor:"+declaredConstructor);
            }
    
            System.out.println("-----------");
            //获取指定的构造器
            Constructor<?> declaredConstructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
            System.out.println("获取指定的构造器：");
            System.out.println(declaredConstructor);
    
        }
    }
    class User08 {
        
        private String name;
        private int id;
        private int age;
        public String phone;
    
        public User08() {
        
        }
    
        public User08(String name, int id, int age) {
        
            this.name = name;
            this.id = id;
            this.age = age;
        }
    
        private User08(String name,int id) {
        
            this.name = name;
            this.id = id;
        }
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "User08{" +
                    "name='" + name + '\'' +
                    ", id=" + id +
                    ", age=" + age +
                    '}';
        }
    }

![在这里插入图片描述][34a1935783b04def89f5053ccc29b537.png]  
![在这里插入图片描述][6e00b909e8f8434ebb0d6d870cdfe441.png]  
![在这里插入图片描述][95fce40508514c68a64d7a561ace906f.png]  
![在这里插入图片描述][b20a8fa40de241c6b9cbc2cc86fb23d3.png]

#### 2.5.4 调用指定的方法 ####

![在这里插入图片描述][7e0563023a344e0f862c8e243e743c2e.png]

//获取Class对象
    Class<?> c1 = Class.forName("Reflection.User09");
    //通过反射调用普通方法
    User09 user3 = (User09)c1.newInstance();
    //通过反射获取一个方法
    Method setName = c1.getDeclaredMethod("setName", String.class);
    setName.invoke(user3,"小倩");//invoke 激活 (对象,"方法的值")
    System.out.println(user3.getName());

*  通过反射，调用类中的方法，通过Method类完成
    
    1.  通过Class类的`getMethod(String name,Class...parameterTypes)`方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
    
        //获取Class对象
        Class<?> c1 = Class.forName("Reflection.User09");
        //通过反射获取一个方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
    
    1.  之后使用`Object invoke(Object obj，Object[] args)`进行调用，并向方法中传递要设置的obj对象的参数信息
        
         *  `Object invoke(Object obj,Object...args)`
            
             *  > Object对应原方法的返回值，若原方法无返回值，此时返回null
             *  > 若原方法若为静态方法，此时形参Objectobj可为null
             *  > 若原方法形参列表为空，则Objectf\]args为null
             *  > 若原方法声明为private，则需要在调用此`invoke()`方法前，显式调用方法对象的`setAccessible(true)`方法，将可访问`private`的方法。
             *  Method和Field、Constructor对象都有setAccessible()方法
                
                 *  > setAccessible作用是启动和禁用访问安全检查的开关
                 *  > 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
                    
                     *  > 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。使得原本无法访问的私有成员也可以访问。
                 *  > 参数值为false则指示反射的对象应该实施Java语言访问检查

#### 2.5.5 反射检测性能分析代码演示 ####

import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    /**
     * @author 缘友一世
     * date 2022/12/27-9:54
     */
    //分析性能问题
    public class demo10 {
        
    
        //普通方法调用
        private static void test01() {
        
            User10 user = new User10("小静",100,8);
            long startTime=System.currentTimeMillis();
            for (int i = 0; i < 100000000; i++) {
        
                user.getName();
            }
            long endTime=System.currentTimeMillis();
            System.out.println("普通方法执行1亿次耗时："+(endTime-startTime)+"ms");
        }
        //反射方法调用
        private static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        
            User10 user = new User10("小静",100,8);
            Class<? extends User10> c1 = user.getClass();
            Method getName = c1.getDeclaredMethod("getName", null);
            long startTime=System.currentTimeMillis();
            for (int i = 0; i < 100000000; i++) {
        
                getName.invoke(user,null);
            }
            long endTime=System.currentTimeMillis();
            System.out.println("反射方法[未关闭检测]执行1亿次耗时："+(endTime-startTime)+"ms");
        }
        //反射方法调用关闭检测
        private static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        
            User10 user = new User10("小静",100,8);
            Class<? extends User10> c1 = user.getClass();
            Method getName = c1.getDeclaredMethod("getName", null);
            getName.setAccessible(true);
            long startTime=System.currentTimeMillis();
            for (int i = 0; i < 100000000; i++) {
        
                getName.invoke(user,null);
            }
            long endTime=System.currentTimeMillis();
            System.out.println("反射方法[关闭检测]执行1亿次耗时："+(endTime-startTime)+"ms");
        }
        public static void main(String[] args) throws InvocationTargetException, NoSuchMethodException, IllegalAccessException {
        
            test01();
            test02();
            test03();
        }
    }
    class User10 {
        
        private String name;
        private int id;
        private int age;
        public String phone;
    
        public User10() {
        
        }
    
        public User10(String name, int id, int age) {
        
            this.name = name;
            this.id = id;
            this.age = age;
        }
    
        private User10(String name,int id) {
        
            this.name = name;
            this.id = id;
        }
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "User10{" +
                    "name='" + name + '\'' +
                    ", id=" + id +
                    ", age=" + age +
                    '}';
        }
    }

![在这里插入图片描述][bfa99a6e74fb440f8018b737177d8f49.png]

#### 2.5.6 反射操作泛型 ####

*  Java采用泛型擦除的机制来引入泛型，Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
 *  为了通过反射操作这些类型，Java中ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型

<table> 
 <thead> 
  <tr> 
   <th>泛型类</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ParameterizedType</td> 
   <td>表示一种参数化类型，比如<code>Collection&lt;String&gt;</code></td> 
  </tr> 
  <tr> 
   <td>GenericArrayType</td> 
   <td>表示一种元素类型是参数化类型或者类型变量的数组类型</td> 
  </tr> 
  <tr> 
   <td>TypeVariable</td> 
   <td>各种类型变量的公共父接口</td> 
  </tr> 
  <tr> 
   <td>WildcardType</td> 
   <td>代表一种通配符类型表达式</td> 
  </tr> 
 </tbody> 
</table>

#### 2.5.7 反射操作泛型代码演示 ####

import java.lang.reflect.Method;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.List;
    import java.util.Map;
    
    /**
     * @author 缘友一世
     * date 2022/12/27-10:06
     */
    //反射操作泛型
    public class demo11 {
        
        public static void test01(Map<String,User11> map, List<User11> list) {
        
            System.out.println("test01");
        }
        public static  Map<String,User11> test02() {
        
            System.out.println("test02");
            return null;
        }
        public static void main(String[] args) throws NoSuchMethodException {
        
            Method method = demo11.class.getMethod("test01", Map.class, List.class);
            //获得方法的泛型参数类型
            Type[] genericExceptionTypes = method.getGenericParameterTypes();
            for (Type genericExceptionType : genericExceptionTypes) {
        
                System.out.println(">>"+genericExceptionType);
                //获取泛型的信息 泛型参数类型属于参数化类型
                if(genericExceptionType instanceof ParameterizedType) {
        
                    //强制转化 获得真实的参数信息
                    Type[] actualTypeArguments = ((ParameterizedType) genericExceptionType).getActualTypeArguments();
                    for (Type actualTypeArgument : actualTypeArguments) {
        
                        System.out.println(actualTypeArgument);
                    }
                }
            }
    
            System.out.println(">>>>>>>>>>>>>>>>");
            Method method1 = demo11.class.getMethod("test02", null);
            //获取泛型的返回值类型
            Type genericReturnType = method1.getGenericReturnType();
            if(genericReturnType instanceof ParameterizedType) {
        
                Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
        
                    System.out.println(actualTypeArgument);
                }
            }
        }
    }
    class User11 {
        
        private String name;
        private int id;
        private int age;
        public String phone;
    
        public User11() {
        
        }
    
        public User11(String name, int id, int age) {
        
            this.name = name;
            this.id = id;
            this.age = age;
        }
    
        private User11(String name,int id) {
        
            this.name = name;
            this.id = id;
        }
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "User11{" +
                    "name='" + name + '\'' +
                    ", id=" + id +
                    ", age=" + age +
                    '}';
        }
    }

![在这里插入图片描述][10015a1a4a4048f69ec01de21864b8d1.png]

#### 2.5.8 反射操作注解 ####

<table> 
 <thead> 
  <tr> 
   <th>Modifier and Type</th> 
   <th>Method and Description</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>&lt;A extends Annotation&gt;</code></td> 
   <td><code>getAnnotation(类&lt;A&gt; annotationClass) </code><br>返回该元素的，如果这样的注释 ，否则返回null指定类型的注释。</td> 
  </tr> 
  <tr> 
   <td><code>Annotation[] getAnnotations() </code></td> 
   <td>返回此元素上 存在的注释。</td> 
  </tr> 
 </tbody> 
</table>

#### 2.5.9 ORM练习代码 ####

*  ORM练习：
    
     *  **ORM：Object relationship Mapping ==>对象关系映射**
     *  **类和表结构对应**
     *  **属性和字段对应**
     *  **对象和字段对应**
 *  要求：利用注解和反射完成类和表结构的映射关系

package Reflection;
    
    import java.lang.annotation.*;
    import java.lang.reflect.Field;
    
    /**
     * @author 缘友一世
     * date 2022/12/27-10:36
     */
    //反射操作注解
    /*
        ORM练习：
            ORM：Object relationship Mapping ==>对象关系映射
            类和表结构对应
            属性和字段对应
            对象和字段对应
        利用注解和反射完成类和表结构的映射关系
     */
    public class demo12 {
        
        public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
        
            Class<?> c1 = Class.forName("Reflection.student12");
            //通过反射获取注解
            Annotation[] annotations = c1.getAnnotations();
            for (Annotation annotation : annotations) {
        
                System.out.println(annotation);
            }
    
            //获得注解的value的值
            table tb = c1.getAnnotation(table.class);
            String value = tb.value();
            System.out.println(value);
    
            //获得类指定的注解
            Field f = c1.getDeclaredField("name");
            filed annotation = f.getAnnotation(filed.class);
            System.out.println(annotation.columnName());
            System.out.println(annotation.type());
            System.out.println(annotation.length());
        }
    }
    //类名的注解
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @interface table{
        
        String value();
    }
    
    //属性注解
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @interface filed{
        
        String columnName();
        String type();
        int length();
    }
    @table("db_student")
    class student12 {
        
        @filed(columnName = "db_id",type = "int",length = 5)
        private int id;
        @filed(columnName = "db_age",type = "int",length = 10)
        private int age;
        @filed(columnName = "db_name",type = "int",length = 8)
        private String name;
    
        public student12() {
        
        }
    
        public student12(int id, int age, String name) {
        
            this.id = id;
            this.age = age;
            this.name = name;
        }
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "student12{" +
                    "id=" + id +
                    ", age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

![在这里插入图片描述][eee6b9d5f6dd4ab5a9d17dce76e06120.png]

### 2.6 创建运行时类的对象 ###

#### 2.6.1 创建运行时对象 ####

使用Class对象之后，可以完成的操作

*  创建类的对象：调用Class对象的newlnstance()方法
    
    1.  类必须有一个无参数的构造器。
    2.  类的构造器的访问权限需要足够
 *  思考
    
     *  难道没有无参的构造器就不能创建对象了吗？
     *  只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作
 *  步骤如下：
    
    1.  通过Class类的getDeclaredconstructor(class…parameterTypes）取得本类的指定形参类型的构造器
    2.  向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数
    3.  通过Constructor实例化对象

//获取Class对象
            Class<?> c1 = Class.forName("Reflection.User09");
            //构造一个对象
            //本质是调用类的无参构造器 如果类中没有无参构造器，会报错
            User09 user = (User09)c1.newInstance();
            System.out.println(user);
    
            System.out.println("---------");
            //通过构造器创建对象
            Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
            User09 user2 = (User09) constructor.newInstance("小茜", 101, 22);
            System.out.println(user2);

#### 2.6.2 创建运行时对象代码演示 ####

import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    /**
     * @author 缘友一世
     * date 2022/12/27-9:37
     */
    //动态的创建对象，通过反射
    public class demo09 {
        
        public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        
            //获取Class对象
            Class<?> c1 = Class.forName("Reflection.User09");
            //构造一个对象
            //本质是调用类的无参构造器 如果类中没有无参构造器，会报错
            User09 user = (User09)c1.newInstance();
            System.out.println(user);
    
            System.out.println("---------");
            //通过构造器创建对象
            Constructor<?> constructor = c1.getDeclaredConstructor(String.class, int.class, int.class);
            User09 user2 = (User09) constructor.newInstance("小茜", 101, 22);
            System.out.println(user2);
    		//通过反射调用普通方法
            User09 user3 = (User09)c1.newInstance();
            //通过反射获取一个方法
            Method setName = c1.getMethod("setName", String.class);
            setName.invoke(user3,"小倩");//invoke 激活 (对象,"方法的值")
            System.out.println(user3.getName());
    
            System.out.println("---------");
            //通过反射操作属性
            User09 user4 = (User09) c1.newInstance();
            Field name = c1.getDeclaredField("name");
            //不能直接获得属性，需要关闭程序的安全检测 属性或者方法的setAccessible(true)
            name.setAccessible(true);
            name.set(user4,"小瑶");
            System.out.println(user4.getName());
        }
    }
    class User09 {
        
        private String name;
        private int id;
        private int age;
        public String phone;
    
        public User09() {
        
        }
    
        public User09(String name, int id, int age) {
        
            this.name = name;
            this.id = id;
            this.age = age;
        }
    
        private User09(String name,int id) {
        
            this.name = name;
            this.id = id;
        }
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getId() {
        
            return id;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "User09{" +
                    "name='" + name + '\'' +
                    ", id=" + id +
                    ", age=" + age +
                    '}';
        }
    }

![在这里插入图片描述][0e4363fc37b04145b35c5e5c6a715930.png]

\*\*\*感谢阅读！\*\*\*养眼时刻  
![在这里插入图片描述][ba78eb03fbbe4e0bb5b6ee8cb24ae774.jpeg_pic_center]

[89cd805a7c474573b3f1532b3f7eb4cd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9034bd1b5e08468080376d317ff6ded7.png
[36fd31c031dc4561985d7c66cc252d48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/09ca3e28178243c388f102868243d2da.png
[488e773672b54ef4aff2cea2af1953b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/11ca8df1c44c4c44908a5e45f680a340.png
[5fd66beb67dd40678028d6f80602cd44.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/00a9d2e5a77b4c0aa96a332b8f154fea.png
[f578052335e24241a1a5b77fb1d46174.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/96b0e6fcd502441d950162e24512a294.png
[c5a49b0a7c5a4cecbff02cabe00929d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ed84e2a342324f57bd6d410be48889eb.png
[302c72a86ebe4b809a2d650722eddeff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/72409e77f5f74445a466932fa249f127.png
[f4e2206661534e92906dc07df85e167c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/914ab65e6d3c4628a85865f409857326.png
[c7f7d8e84a8847659b8287cee74d35ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ef571844a28b4640b35a71ed01f6efa8.png
[3559314659b540139b12cac6dfe335b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/bee5f023df424f0287d9a91906dd1939.png
[b3166c2c46ee432eb89b7447d6803c2e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/03ab6a6755384466940649afa60b3270.png
[12b940bc8a894f91828de6877298840e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2371e429fa9b4adf892f938302382843.png
[34a1935783b04def89f5053ccc29b537.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9b47a46737fe4732ab97e5fd60c5e878.png
[6e00b909e8f8434ebb0d6d870cdfe441.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/35ea77b7de574c5fa25862aa5cba0d21.png
[95fce40508514c68a64d7a561ace906f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7b19ba8d9add43cb8466fb565f48f89f.png
[b20a8fa40de241c6b9cbc2cc86fb23d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/0c089b31edc44c008a2e04be5b90cfc3.png
[7e0563023a344e0f862c8e243e743c2e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/402b388304d34669bb73d4e0f30981f6.png
[bfa99a6e74fb440f8018b737177d8f49.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c5de4e794daf4f4582c4b370ef049a9a.png
[10015a1a4a4048f69ec01de21864b8d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/758661881e10410ba12aae81748929d0.png
[eee6b9d5f6dd4ab5a9d17dce76e06120.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3ca99dc098c143c4b9437b7cbf83388c.png
[0e4363fc37b04145b35c5e5c6a715930.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/6ede9a2f21404d329084ed3f73c422d4.png
[ba78eb03fbbe4e0bb5b6ee8cb24ae774.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4e12199f5299410198cd016503254ae3.jpeg