java的反射机制

已于 2022-08-19 15:54:56 修改
阅读量319 收藏 1
点赞数
分类专栏： Java # Java基础 文章标签： java 开发语言
于 2022-06-12 16:54:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47994845/article/details/124595261
版权

01、Java反射机制概述

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

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

在这里插入图片描述
1、动态语言

是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。\

2、静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。

  • Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！

java反射机制的研究及应用

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

反射相关的Api

  • java.lang.Class:代表一个类
  • java.lang.reflect.Method:代表类的方法
  • java.lang.reflect.Field:代表类的成员变量
  • java.lang.reflect.Constructor:代表类的构造器
  • …

1.1、使用反射

测试类

package hxut.java;

import org.junit.Test;

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

/**
 * @author weijiangquan
 * @date 2022/5/5 -19:17
 * @Description
 */
public class ReflectionTest{

    //反射之前对于Person的操作
    @Test
    public void test1(){

        //1.创建person类的对象
        Person p1= new Person("Tom",12);

        //2.通过对象调用内部的属性,方法
        p1.age = 10;
        System.out.println(p1);
        System.out.println(p1.toString());

        p1.show();

        //在Peron类的外部不能调用Person类的对象调用其内部的私有结构
        //比如:name,showNation以及私有的构造器
    }


    //反射之后(实现和上面同样的功能)
   @Test
   public void test2() throws Exception{
       Class clazz = Person.class;
       //1.通过反射,创建Person类的对象
       Constructor constructor = clazz.getConstructor(String.class, int.class);
       Object obj = constructor.newInstance("Tom", 12);
       Person p = (Person) obj;
       System.out.println(obj.toString());

       //2.通过反射调用对象指定的属性,方法
         //调用属性
       Field age = clazz.getDeclaredField("age");
       age.set(p,10);

       System.out.println(p.toString());

         //调用方法
       Method show = clazz.getDeclaredMethod("show");
       show.invoke(p);
   }
}

Person类

package hxut.java;

/**
 * @author weijiangquan
 * @date 2022/5/5 -19:17
 * @Description
 */
public class Person{

    private String name;
    public int age;


    /**
     * 构造器
     */
    //***********************start**************************************
    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private Person(String name) {
        this.name = name;
    }

    //*****************************end**********************************

    /**
     * set和get方法
     */
    //***********************start**************************************
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    //*****************************end**********************************
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public void show(){
        System.out.println("你好,我是一个人");
    }
    private String showNation(String nation){
        System.out.println("我的国籍是"+nation);
        return nation;
    }

}

为了配合反射的学习,故意将其中的部分成员属性和成员方法以及构造方法设置成了私有的

1.2、反射的强大：调用类的私有结构

  //反射之后
   @Test
   public void test2() throws Exception{
       Class clazz = Person.class;
       //1.通过反射,创建Person类的对象
       Constructor constructor = clazz.getConstructor(String.class, int.class);
       Object obj = constructor.newInstance("Tom", 12);
       Person p = (Person) obj;
       System.out.println(obj.toString());

       //2.通过反射调用对象指定的属性,方法
         //调用属性
       Field age = clazz.getDeclaredField("age");
       age.set(p,10);

       System.out.println(p.toString());

         //调用方法
       Method show = clazz.getDeclaredMethod("show");
       show.invoke(p);
    System.out.println("****************反射的强大：调用类的私有结构*********************");
       //通过反射可以调用Person类的私有结构.比如:私有的构造器,私有的方法,属性
       Constructor cons1 = clazz.getDeclaredConstructor(String.class);
       cons1.setAccessible(true); //为什么写这句呢,后面在讲
       Person p1 = (Person) cons1.newInstance("Jerry");
       System.out.println(p1); //run result=>Person{name='Jerry', age=0}

       //调用私有的属性
       Field name = clazz.getDeclaredField("name");
       name.setAccessible(true);
       name.set(p1,"WanWanMei");
       System.out.println(p1);

       //调用私有的方法
       Method showNation = clazz.getDeclaredMethod("showNation", String.class);
       showNation.setAccessible(true);
        String nation = (String) showNation.invoke(p1,"中国");  //相当于 p1.showNation("中国");
       System.out.println(nation); //输出方法的返回值
       
       
   }

1.3 反射-如何看待反射和封装性两个技术

我个人的理解:(在学完这么点微薄的知识的情景下)
可能是在某些情景下需要通过反射获取需要的东西,来达成我们的需求

 //疑问1:通过直接new的方式或反射的方式都可以调用公共的结构:开发中到底用哪一个 ?
           //建议:直接new的方式
           //什么时候会使用:反射的方式.反射的特征:动态性
      //疑问2:反射机制与面向对象中的封装性是不是矛盾的?如何看待两个技术 ?    
           //不矛盾
           封装性建议你怎么调用的问题

02、理解Class类并获取Class实例

2.1、Class类的理解

 关于java.lang.Class类的理解
            1.类的加载过程
            程序经过javac.exe命令以后,会生成一个或多个字节码文件(.class结尾),
            接着我们使用java.exe命令对某个字节码文件进行解释运行.相当于将某个字节码文件加载到内存中.
            此过程就称为类的加载.加载到内存中的类,我们就称为运行时的类,此时运行时类,就作为Class的一个实例.

            2.换句话说,Class的实例就对应着一个运行时类

Class类的常用方法
在这里插入图片描述

2.4、获取Class实例的4种方式

       /*
        关于java.lang.Class类的理解
            1.类的加载过程
            程序经过javac.exe命令以后,会生成一个或多个字节码文件(.class结尾),
            接着我们使用java.exe命令对某个字节码文件进行解释运行.相当于将某个字节码文件加载到内存中.
            此过程就称为类的加载.加载到内存中的类,我们就称为运行时的类,此时运行时类,就作为Class的一个实例.

            2.换句话说,Class的实例就对应着一个运行时类

            3.加载到内存中运行的类,会缓存一定的时间.在此时间之内,我们可以通过不同的方式
             来获取此运行时类.
         */

       //万事万物皆对象
   }

    /**
     *
     * 获取Class的实例方式(前三种方式需要掌握)
     *
     */
   @Test
   public void test3() throws ClassNotFoundException {
        //方式一 :调用运行时的属性 .class
       Class clazz1 = Person.class;  //这种方式如果在编译是没有这个类就会报错(体现不出动态性)
       System.out.println(clazz1); //run result=>class hxut.java.Person

       //方式二:通过运行时类的对象
       Person p1 = new Person();
       Class clazz2 =  p1.getClass();
       System.out.println(clazz2); //run result=>class hxut.java.Person

       // 方式三: 调用Class的静态方法: forName(String classPath) -- 用的最多
       Class clazz3 = Class.forName("hxut.java.Person");
       System.out.println(clazz3); //run result=>class hxut.java.Person

      /*   // 加载其它类也是可以的
       Class clazz4 = Class.forName("java.lang.String");
       System.out.println(clazz4); //run result=>class java.lang.String*/


       System.out.println(clazz1 == clazz2); //run result=>true
       System.out.println(clazz1 == clazz3); //run result=>true


       //方式四:使用类的加载器: ClassLoader(了解)
       ClassLoader classLoader = ReflectionTest.class.getClassLoader();
       Class clazz4 = classLoader.loadClass("hxut.java.Person");
       System.out.println(clazz4);

       System.out.println(clazz4 == clazz1); //run result=>true


   }

2.5、Class实例对应的结构的说明

1、哪些类型可以有Class对象？
在这里插入图片描述


    /**
     * Class实例可以是哪些结构的说明
     */
   @Test
   public void test4(){
       Class s1 = Object.class;
       Class s2 = Comparable.class;
       Class s3 = String[].class;
       Class s4 = int[][].class;
       Class s5 = ElementType.class;
       Class s6 = Override.class;
       Class s7 = int.class;
       Class s8 = void.class;
       Class s9 = Class.class;

       int[] a = new int[10];
       int[] b = new int[100];
       Class s10 = a.getClass();
       Class s11 = b.getClass();
       // 只要数组的元素类型与维度一样，就是同一个Class
       System.out.println(s10 == s11); //run result=>true
   }

03、类的加载与ClassLoader的理解

3.6、了解：类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化
在这里插入图片描述

说明

  • 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。

  • 链接：将Java类的二进制代码合并到JVM的运行状态之中的过程

    • 验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题
    • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
    • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

  • 初始化：

    • 执行类构造器<clinit>()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
    • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
    • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

在这里插入图片描述

3.7、了解：什么时候会发生类初始化？

在这里插入图片描述

3.8、ClassLoader的理解

在这里插入图片描述

  • 类加载器的作用：

    • 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
    • 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

  • 类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。

在这里插入图片描述

package hxut.java;

import org.junit.Test;

/**
 * @author weijiangquan
 * @date 2022/5/5 -22:38
 * @Description
 */
public class ClassLoaderTest {

    @Test
    public void test(){

        //对于自定类,使用系统类加载器加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader); //run result=>sun.misc.Launcher$AppClassLoader@18b4aac2系统类加载器


        //调用系统类加载器的getParent(): 获取扩展加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1); //run result=>sun.misc.Launcher$ExtClassLoader@279f2327 扩展类加载器


        //调用扩展类加载器getParent(): 无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库,无法加载自定义类的
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2); //run result=>null

        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println(classLoader3); //run result=>null

        

    }
}

3.9、使用ClassLoader加载配置文件(这个代码需要掌握,多练习一下)

在这里插入图片描述

import org.junit.Test;

import java.io.InputStream;
import java.util.Properties;

/**
 * 了解类的加载器
 */
public class ClassLoaderTest {

    /**
     * Properties：用来读取配置文件。
     * @throws Exception
     */
    @Test
    public void test2() throws Exception {
        Properties pros = new Properties();
        //此时的文件默认在当前的module下。
        //读取配置文件的方式一：
//        FileInputStream fis = new FileInputStream("jdbc.properties");
//        pros.load(fis);

        //读取配置文件的方式二：使用ClassLoader
        //配置文件默认识别为：当前module的src下
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user = " + user + ",password = " + password);
    }
}

04、通过反射，创建运行时类的对象

package hxut.java;

import org.junit.Test;

/**
 * @author weijiangquan
 * @date 2022/5/5 -23:10
 * @Description
 * 通过反射创建对应的运行时类的对象
 */

public class NewInstanceTest {

    @Test
    public void test() throws IllegalAccessException, InstantiationException {

        Class clazz = Person.class;

/*
        Object obj = clazz.newInstance();
        System.out.println(obj);//run result=>Person{name='null', age=0}package
*/

        /**
         * newInstance:调用此方法,创建对应的运行时类的对象,内部调用运行时类的空参构造器
         * 
         * 要想此方法正常的创建运行类的对象,要求:
         * 1.运行时类必须提供空参构造器
         * 2.空参构造器的访问权限得够.通常设置为public.
         * 
         * 
         * 通常在javabean中要求提供一个public的空参的构造器.原因:
         * 1.便于通过反射,创建运行时类的对象
         * 2.便于子类继承此运行时类时,默认调用super()时,保证父类由此属性
         * 
         */
        Person obj = (Person) clazz.newInstance();  //百分之九十五都用这个
        System.out.println(obj);
        
        
    }
}

4.1、举例体会反射的动态性(本节有点疑问)

 //体会反射的动态性
    @Test
    public void test2(){

        for(int i = 0;i<100;i++){
            int num = new Random().nextInt(3);
            String classPath = "";
            switch (num){
                case 0:
                    classPath = "java.util.Date";
                    break;
                case 1:
                    classPath = "java.lang.Object";
                    break;
                case 2:
                    classPath = "hxut.java.Person";
                    break;
        }
            try {
                Object obj = getInstance(classPath);
                System.out.println(obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 创建一个指定类的对象
     * classPath:指定类的全类名
     *
     * @param classPath
     * @return
     * @throws Exception
     */
    public Object getInstance(String classPath) throws Exception {
        Class clazz = Class.forName(classPath);
        return clazz.newInstance();
    }

在这里插入图片描述
在这里插入图片描述

05、获取运行时类的完整结构(了解)

在实际开发中不会真的让你获取一个类的完整结构

5.1、提供结构丰富Person类

1、Person类

package hxut.java1;

import java.io.PrintWriter;

/**
 * @author weijiangquan
 * @date 2022/5/6 -11:55
 * @Description
 */

@MyAnnotation(value = "hi")
public class Person extends Creature<String> implements  Comparable<String>,MyInterface{

    private String name;
    int age;
    public int id;


    /**
     * 构造器
     */
    //***********************start**************************************
    @MyAnnotation(value = "abc")
    public Person(){

    }
    private  Person(String name){
        this.name = name;
        this.age = age;
    }
    //*****************************end**********************************
    @MyAnnotation
    private String show(String nation){
        System.out.println("我的国籍是:"+nation);
        return nation;
    }

    public String display(String interests){
        return interests;
    }


    @Override
    public void info() {
        System.out.println("我是一个人");
    }
    @Override
    public int compareTo(String o) {
        return 0;
    }
}

2、Creature类

package hxut.java1;

import java.io.Serializable;

/**
 * @author weijiangquan
 * @date 2022/5/6 -11:55
 * @Description
 */
public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breath(){
        System.out.println("生物");
    }

    public void eat(){
        System.out.println("生物吃东西");
    }
    
}

3、MyInterface

package hxut.java1;

/**
 * @author weijiangquan
 * @date 2022/5/6 -12:03
 * @Description
 */
public interface MyInterface{
    void info();
}

4、MyAnnotation

package hxut.java1;

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

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

/**
 * @author weijiangquan
 * @date 2022/5/6 -12:10
 * @Description
 */

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation{
    String value() default "hello";

}

在这里插入图片描述

5.2、获取运行时类的属性结构及其内部结构

测试类

package hxut.java2;

import hxut.java1.Person;
import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

/**
 * @author weijiangquan
 * @date 2022/5/6 -12:13
 * @Description 获取运行时类的属性结构
 */
public class FieldTest {



    @Test
    public  void test1(){

        Class clazz = Person.class;

        //获取属性结构
        /*
            getFields():获取当前运行时类及其父类中声明为public访问权限的属性

         */
        Field[] fields = clazz.getFields();
        for(Field f:fields){
            System.out.println(f);
        }


        /*
            getDeclaredFields获取当前运行类当中所有属性.(不包含父类中声明的属性)
         */
        System.out.println("*****************************");
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f:declaredFields){
            System.out.println(f);        /*
                                            private java.lang.String hxut.java1.Person.name
                                            int hxut.java1.Person.age
                                             public int hxut.java1.Person.id
                                                */
        }
    }


    /**
     * 权限修饰符 数据类型 变量名
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field f:declaredFields){
            //1.权限修饰符
            int modifiers = f.getModifiers();
            // System.out.println(modifiers);
             System.out.print(Modifier.toString(modifiers)+"\t"); //获取权限
            //2.数据类型

            Class type = f.getType();
            System.out.println(type + "\t");

            //3.变量名
            String fName = f.getName();
            System.out.println(fName);


        }
    }
}

在这里插入图片描述

5.3、获取运行时类的方法结构

package hxut.java2;

import hxut.java1.Person;
import org.junit.Test;

import java.lang.reflect.Method;

/**
 * @author weijiangquan
 * @date 2022/5/6 -12:40
 * @Description
 */
public class MethodTest {

    @Test
    public void test1(){

        Class clazz = Person.class;

        //或取方法
        Method[] methods = clazz.getMethods();

        //getMethods():获取当前运行时类及其运行时类及其所有父类中声明为public权限的方法
        for(Method m:methods){
            System.out.println(m);
        }

        System.out.println("***********");
        //getDeclareMethods():获取当前运行时类中所有的方法,(不包含父类中声明的方法)
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m1:declaredMethods){
            System.out.println(m1);
        }
        
        
        
    }
}

5.4、获取运行时类的方法的内部结构(用的相对来说比较的少)

1、Person类

@MyAnnotation(value="java")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{

    private String name;
    int age;
    public int id;

    public Person() {
    }

    @MyAnnotation(value="C++")
    Person(String name){
        this.name = name;
    }

    private Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    @MyAnnotation
    private String show(String nation){
        System.out.println("我来自" + nation + "星系");
        return nation;
    }

    @Override
    public void info() {
        System.out.println("火星喷子");
    }

    public String display(String interests,int age) throws Exception{
        return interests + age;
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }
    
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

2、测试类

package github3;

import github2.Person;
import org.junit.Test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * 获取运行时类的方法结构
 */
public class MythodTest {

    /**
     * @Xxxx
     * 权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}
     */
    @Test
    public void test2() {
        Class clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            //1.获取方法声明的注解
            Annotation[] annos = m.getAnnotations();
            for (Annotation a : annos) {
                System.out.println(a + "KKKK");
            }

            //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[] pTs = m.getParameterTypes();
            if(!(pTs == null && pTs.length == 0)){
                for(int i = 0;i < pTs.length;i++){
                    if(i == pTs.length - 1){
                        System.out.print(pTs[i].getName() + " args_" + i);
                        break;
                    }
                    System.out.print(pTs[i].getName() + " args_" + i + ",");
                }
            }
            System.out.print(")");

            //6.抛出的异常
            Class[] eTs = m.getExceptionTypes();
            if(eTs.length > 0){
                System.out.print("throws ");
                for(int i = 0;i < eTs.length;i++){
                    if(i == eTs.length - 1){
                        System.out.print(eTs[i].getName());
                        break;
                    }
                    System.out.print(eTs[i].getName() + ",");
                }
            }
            System.out.println("TQA");
        }
    }

}

5.5、获取运行时类的构造器结构

 /*
    或取构造器结构
     */


    @Test
    public void test1(){

        Class clazz = Person.class;

        //getConstructors():获取当前运行时类中声明为public的构造器
        Constructor[] constructors = clazz.getConstructors();

        for(Constructor c:constructors){
            System.out.println(c);
        }


        System.out.println();


        //getDeclaredConstructors 获取当前运行时类中所有的构造器
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c:declaredConstructors){
            System.out.println(c);
        }
    }

5.6、获取运行时类的父类及父类的泛型


    /*
     获取运行时类的父类
     */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Class superclass = clazz.getSuperclass();
        System.out.println(superclass); //run result=>class hxut.java1.Creature
    }

    /*
     获取运行时类的带泛型的父类
     */
    @Test
    public void test3(){
        Class clazz = Person.class;

        Type genericSuperclass = clazz.getGenericSuperclass();

        System.out.println(genericSuperclass); //run result=>hxut.java1.Creature<java.lang.String>
    }
    /*
        获取运行时类的带泛型的父类的泛型

         代码: 逻辑性代码  vs 功能性代码



     */
    // 下面的这个代码直接复制粘贴就行了,到时候需要的时候拿去就可以了
    @Test
    public void test4(){
        Class clazz = Person.class;

        Type genericSuperclass = clazz.getGenericSuperclass();

        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        //获取泛型参数
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        System.out.println(actualTypeArguments[0]); //run result=> class java.lang.String
        // System.out.println(actualTypeArguments[0].getTypeName()); //run result=>java.lang.String
        System.out.println(((Class)actualTypeArguments[0]).getName()); //run result=>java.lang.String


    }

5.7、获取运行时类的接口、所在包、注解等

/**
     * 或取运行时实现类的接口(后续可能会用到)
     */
    @Test
    public void  test5(){
        Class clazz = Person.class;

        Class[] interfaces = clazz.getInterfaces();
        for(Class c:interfaces){
            System.out.print(c+"\t"); //run result=>interface java.lang.Comparable	interface hxut.java1.MyInterface
        }

        // 获取运行时父类实现的接口
        System.out.println("*****************************");
        Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for(Class c1:interfaces1){
            System.out.print(c1+"\t"); //run result=>interface java.io.Serializable
        }
    }
    
    /*
        获取运行时类所在的包
     */
    @Test
    public void test6(){

        Class clazz = Person.class;

        Package pack = clazz.getPackage();
        System.out.println(pack); //run result=>package hxut.java1
    }

    /*
        获取运行时类声明的注解(用的可能会比较多)
     */

    @Test
    public void test7(){
        Class clazz = Person.class;
        Annotation[] annotations = clazz.getAnnotations();
        for(Annotation a:annotations){
            System.out.println(a); //run result=>@hxut.java1.MyAnnotation(value=hi)
        }
    }

06、调用运行时类的指定结构(需要掌握 p654)

6.1、调用运行时类中的指定属性(需要掌握)

1、Person类

package github2;

@MyAnnotation(value="java")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{

    private String name;
    int age;
    public int id;

    public Person() {
    }

    @MyAnnotation(value="C++")
    Person(String name){
        this.name = name;
    }

    private Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    @MyAnnotation
    private String show(String nation){
        System.out.println("我来自" + nation + "星系");
        return nation;
    }

    @Override
    public void info() {
        System.out.println("火星喷子");
    }

    public String display(String interests,int age) throws Exception{
        return interests + age;
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

2、测试类

package hxut.java2;

import hxut.java1.Person;
import org.junit.Test;

import java.lang.reflect.Field;

/**
 * @author weijiangquan
 * @date 2022/5/6 -19:51
 * @Description
 *
 * 调用运行时类中指定的结构: 属性,方法,构造器
 */
public class ReflectionTest{

	//不需要掌握
    @Test
    public void testField() throws Exception{
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        //获取指定的属性: 要求运行时类中属性声明为public(通常不采用此方法)
        Field id = clazz.getField("id");
        //设置当前属性的值

        /**
         * set():参数1:指定设置哪个对象的属性  参数2:将此属性值设置为多少
         */
        id.set(p,1001);

        /*
            或取当前属性的值
            get():参数1: 获取哪个对象的当前属性值
         */
        int pID = (int)id.get(p);
        System.out.println(pID);
    }

    
    /*
    如何操作运行时类中指定的属性  -- 需要掌握
     */
    @Test
    public void testField1() throws Exception{
        Class clazz = Person.class;

        //创建运行时类的对象
        Person p  = (Person) clazz.newInstance();

       //1.getDeclaredField(String name) :获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name"); //这个地方已经拿到了

        //不过这里要设置为true之后才可以访问
        //2.保证当前属性时可方法问的
        name.setAccessible(true);
        
        // 3.获取,设置指定对象的此属性值
        name.set(p,"Tom");
        System.out.println(name.get(p)); //run result=>Tom

    }

}

6.2、调用运行时类中的指定方法(需要掌握)

1.Person类

package hxut.java1;

import java.io.PrintWriter;

/**
 * @author weijiangquan
 * @date 2022/5/6 -11:55
 * @Description
 */

@MyAnnotation(value = "hi")
public class Person extends Creature<String> implements  Comparable<String>,MyInterface{

    private String name;
    int age;
    public int id;


    /**
     * 构造器
     */
    //***********************start**************************************
    @MyAnnotation(value = "abc")
    public Person(){

    }
    private  Person(String name){
        this.name = name;
        this.age = age;
    }
    //*****************************end**********************************
    @MyAnnotation
    private String show(String nation){
        System.out.println("我的国籍是:"+nation);
        return nation;
    }

    public String display(String interests){
        return interests;
    }


    @Override
    public void info() {
        System.out.println("我是一个人");
    }
    @Override
    public int compareTo(String o) {
        return 0;
    }


    private static void showDesc(){
        System.out.println("我是一个无聊的人");
    }
}

2 测试类

    /**
     * 如何操作运行时类中指定的方法  -- 需要掌握
     */

    @Test
    public void testMethod() throws Exception{

        Class clazz = Person.class;

        //创建运行时类的的对象
        Person p = (Person) clazz.newInstance();

        // 1.获取指定的某一个方法
        //getDeclaredMethod():参数1:指明获取方法的名称  参数2:指明获取的方法的形参列表
        Method show = clazz.getDeclaredMethod("show", String.class);

        /*
            invoke(): 参数1:方法的调用者  参数2:给方法形参赋值的实参
         */
        //2.保证当前的方法时可访问的
        show.setAccessible(true);

        //3.调用执行的方法 参数1: 方法的调用者  参数2:给方法形参赋值的实参
        //invoke()的返回值即为对应类中调用的方法的返回值

        Object chn = show.invoke(p, "CHN");//run result=>我的国籍是:CHN
        System.out.println(chn); //run result=>CHN

        System.out.println("*********************如何调用静态方法**************************");

        //private static void showDesc()

        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果调用的运行时类中方法没有返回值,则此 invoke()返回null
        Object invoke = showDesc.invoke(Person.class);
        Object invoke1 = showDesc.invoke(null);  //用这个也是可以的(因为是静态方法) (注意上面的静态属性和静态方法类似)

        System.out.println(invoke); //run result=>null
    }

6.3、调用运行时类中的指定构造器(不常用)

import github2.Person;
import org.junit.Test;

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

/**
 * 调用运行时类中指定的结构：属性、方法、构造器
 */
public class ReflectionTest {

    /**
     * 如何调用运行时类中的指定的构造器
     */
    @Test
    public void testConstructor() throws Exception {
        Class clazz = Person.class; 

        //private Person(String name)
        //1.获取指定的构造器
        //getDeclaredConstructor():参数：指明构造器的参数列表
        Constructor constructor = clazz.getDeclaredConstructor(String.class);

        //2.保证此构造器是可访问的
        constructor.setAccessible(true);

        //3.调用此构造器创建运行时类的对象
        Person per = (Person) constructor.newInstance("Tom");
        System.out.println(per);
    }
}

07、反射的应用：动态代理

7.1、代理模式与动态代理

  • 代理设计模式的原理:
    使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

  • 之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。

  • 动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

  • 动态代理使用场合:

    • 调试
    • 远程方法调用

  • 动态代理相比于静态代理的优点：
    抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

在这里插入图片描述
也就是说,由代理类决定要不要创建代理类的对象,以及何时创建(代理类和被代理类实现同一套接口)
在运行期间看被代理类实现的是拿一套接口,就动态的生成代理类实现同样的接口

在这里插入图片描述

7.2、静态代理举例

package hxut.java3;

/**
 * @author weijiangquan
 * @date 2022/5/6 -21:22
 * @Description
 *
 * 静态代理举例
 */
interface ClothFactory{

    void productCloth();


}
//代理类
class ProxyClothFactory implements ClothFactory{

    private ClothFactory factory; //拿被代理类对象进行实例化

    /**
     * 构造器
     */
    //***********************start**************************************
    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }
    //*****************************end**********************************


    @Override
    public void productCloth() {
        System.out.println("代理工厂做一些准备工作");

        factory.productCloth();

        System.out.println("代理工厂做一些后续的收尾工作");
    }
}

//被代理类
class NeckTest implements ClothFactory{

    @Override
    public void productCloth() {
        System.out.println("造纸厂计划生产一批卫生纸");
    }
}



public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类的对象
        NeckTest neckTest = new NeckTest();

        //创建代理类的对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(neckTest);

        proxyClothFactory.productCloth(); //编译的时候看的是父类接口种 调用的是代理类的方法 //run result=>
    }
}

在这里插入图片描述

7.3、动态代理举例(p664 后面用到再回来写)

package hxut.java3;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author weijiangquan
 * @date 2022/5/6 -21:33
 * @Description 动态代理的举例
 */
interface Human{
    String getBelief();
    void eat(String food);
}

//被代理类
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "The only planet in the solar system without a magnetic field";
    }

    @Override
    public void eat(String food) {
        System.out.println("我不喜欢吃"+food);
    }
}

/**
 * 要想实现动态代理，需要解决的问题？
 * 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
 * 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
 */


class ProxyFactory{
    /**
     * 调用此方法返回一个代理类的对象. 解决问题一
     * @param obj
     * @return
     */
    public static Object getProxyInstance(Object obj){  //obj:被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();

        handler.bind(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler{

    private Object obj;  //需要使用被代理类的对象进行赋值

    public void bind(Object obj){
        this.obj = obj;
    }

    //当我们通过代理类的对象,调用方法 a 时,就会自动的调用如下的方法:invoke()
    //将被代理类要执行的方法 a 的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //method:即为代理类对象调用的方法,此方法也作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object returnValue= method.invoke(obj, args);

        //上述方法的返回值就作为当前类中的invoke()的返回值.
        return returnValue;
    }
}


public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance: 代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时,会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("四川麻辣烫");  //run result=>The only planet in the solar system without a magnetic field  我不喜欢吃四川麻辣烫

        System.out.println("*****************************************************");
        NeckTest fox = new NeckTest();
        ClothFactory ween = (ClothFactory)ProxyFactory.getProxyInstance(fox);
        ween.productCloth(); //run result=>造纸厂计划生产一批卫生纸

    }
}

7.4、AOP与动态代理的举例

本章复习(p659)

说明

本内容开始(p636)(基本已经完结)

莪假裝堅強
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
java 反射机制
08-31
本文将深入探讨Java反射机制，并结合给出的代码示例进行解析。 首先，我们来看如何通过反射获取类的基本信息。在代码中，`Class.forName("reflection.User")` 是用来加载名为 `User` 的类，返回一个 `Class` 对象。...
Java基础学习（18）反射、动态代理
gua_Piter的博客
05-20 852
反射允许对封装类的字段，方法和构造函数的信息进行编程访问就是把一个类当中的所有有关的数据全部拿出来，获取到，便于后面的学习利用反射可以获取到类当中的所有信息想象图简单理解就是通过代理去添加其他想要添加的功能，还不用去修改原先的代码，以防出错通过接口的方式把所有的方法进行传输代理为什么需要代理?代理可以无侵入式的给对象增强其他的功能调用者------>代理--------->对象代理长什么样?代理里面就是对象要被代理的方法Java通过什么来保证代理的样子?
Java基础23：反射与动态代理
码砖师傅的博客
04-01 229
Java中反射与动态代理的基本概念与实现
Java中如何使用反射实现动态代理？
仙草不加料的博客
07-27 1604
了解反射之前，先来了解Java中的两个概念编译期和运行期。编译期是指把源码交给编译器编译成计算机可以执行的文件的过程。在Java中也就是把Java代码编成class文件的过程。编译期只是做了一些翻译功能，并没有把代码放在内存中运行起来，而只是把代码当成文本进行操作。比如检查语法错误。运行期是把编译后的文件交给计算机执行，直到程序运行结束。所谓运行期就把在磁盘中的代码放到内存中执行起来。是Java程序开发语言的特征之一，它允许1.在运行时获取任意一个对象所属的类。...
反射与动态代理
glenshappy的专栏
10-29 511
2、个人认为AOP代理其实就是一种装饰器模式的动态实现，为什么是动态呢？就是由于代理是可以动态的，所以调用的方法都是可以切换的（对应到AOP中其实就是连接点的概念）1、Class实例=运行时类对象。
java反射与动态代理
qq_44931670的博客
11-08 153
反射与动态代理学习小结
JAVA反射机制实例教程
09-04
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。通过反射，开发者可以访问和修改私有成员，调用私有方法，创建对象，以及对类、接口、字段和方法进行操作，极大地...
java反射机制.zip
11-24
java反射机制java反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制.zipjava反射机制...
Java反射机制和动态代理
12-22
主要讲述Java反射机制与设计模式之一：代理模式的原理与应用；同时详细讲述了Java对代理模式的支持以及Java中动态代理的原理，应用与实践。
java反射机制和动态代理的原理
12-15
java反射机制和动态代理的原理，熟悉反射机制和动态代理
Java反射与动态代理：浅入深出与实践
最新发布
qq_40014433的博客
02-02 1196
动态代理是一种在运行时创建代理对象的机制。通过动态代理，我们可以拦截方法调用，并在调用前后执行特定的操作。这种机制常用于实现AOP（面向切面编程）。
Java反射机制详细示例及动态代理
qiancc的博客
09-30 6313
反射可以在程序运行过程中动态获取类的相关信息,包括类由哪个类加载器进行加载,类中的成员变量,成员方法,访问修饰符,返回值类型,构造方法等等; 首先要获取类的Class对象.获取Class对象有三种方法
利用反射实现动态代理
幽默工作室
08-16 1940
代理模式：代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 分析得出设计到三个对象： 其一：抽象类接口 其二：被代理类（具体实现抽象接口的类） 其三：代理类：实际调用被代理类的方法和属性的类，具体代码示例如下。 //抽象类接口interface Human { v
基础 | Java的反射与动态代理
Java名企面试吧
11-01 1300
关于「反射」请参看Class类详解（反射）部分。 动态代理作为Java反射的主要应用之一，其在多种JavaEE框架中均有使用，如Spring框架中AOP的实现原理就是动态代理，面试中提到AOP也必定会问 「谈谈对动态代理的理解？」 相关问题，在此做一个梳理与总结。 谈谈对动态代理的理解？ 动态代理作为设计模式中动态代理模式的一部分，其和静态代理构成鲜明对比。下面分别对代理模式、静态代理和动态代...
Java反射之动态代理
xiaoyaGrace的博客
02-21 192
利用Java反射机制你可以在运行期动态的创建接口的实现。java.lang.reflect.Proxy类就可以实现这一功能。这个类的名字（译者注：Proxy意思为代理）就是为什么把动态接口实现叫做动态代理。动态的代理的用途十分广泛，比如数据库连接和事物管理（transaction management）还有单元测试时用到的动态mock对象以及AOP中的方法拦截功能等等都使用到了动态代理。创建代理 ...
Java之反射机制与动态代理（重要）
MTS的博客
04-01 327
反射机制概述 反射视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作认一对象的内部属性及方法。 加载完类之后在，在堆内存的方法区就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。 反射相关的主要API 理解Class类并获取Class实例 在反射之前，在一个类的外部，不可以通过Pe
Java—反射机制实战及动态代理总结
Andya_net的博客
06-18 251
反射在Java技术应用中是老生常谈的事了，我们每次都是知道个皮毛，这个反射可以动态获取类的信息，比如类的属性和方法，但是在平时疯狂写CURD业务代码时，却很少关注或接触使用到反射机制。当然，这并不代表反射没落，反射无用，其实，在高级开发中，还是大量使用了反射机制的，比如我们常说的动态代理、注解等场景都是需要依靠反射来实现。  反射是在运行状态中，对于任意一个类，我们都能够通过反射机制获取到这个类的所有属性和方法，对于任意一个对象，我们都可以通过...
java反射机制原理详解
06-06
### 回答1： Java反射机制是指在运行时动态地获取一个类的信息，并可以操作类的属性、方法和构造器等。Java反射机制可以使程序员在运行时动态地调用类的方法和属性，扩展类的功能，并可以实现注解、工厂模式以及框架开发等。 Java反射机制的原理如下：首先，Java编译器将Java源代码编译为字节码文件，字节码文件中包含着类的信息，这些信息包括类的名称、方法、属性和构造器等等。接着，Java虚拟机将字节码文件加载到内存中，然后通过类加载器将类加载到内存中形成一个类对象，这个类对象可以操作字节码文件中的信息。 使用Java反射机制的过程如下：首先获取类对象，通过类对象来获取类的构造器、属性、方法等信息，然后调用构造器来创建对象，通过属性获取和设置类的成员属性，通过方法调用类的方法等。 Java反射机制的优点是可以在运行时动态地得到类的信息，使得程序员在程序运行时能够对类进行更加灵活的操作，并可以使得程序更加通用化，同时也存在着一定的性能问题，因为Java反射机制需要Java虚拟机进行一定的额外处理，所以在程序运行时需要进行额外的时间和资源消耗。 总之，Java反射机制是Java语言的一项重要特性，在Java开发中广泛应用，在代码编写、框架开发以及API开发中具有重要作用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

莪假裝堅強

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值