反射机制。

最新推荐文章于 2024-09-30 10:13:29 发布
最新推荐文章于 2024-09-30 10:13:29 发布
阅读量233 收藏
点赞数
分类专栏： 自学 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41571545/article/details/123533668
版权 
package com.www.java;

/**
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class Person {
    private String name;
    public int age;

    public Person() {
    }

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

    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;
    }
    public void show(){
        System.out.println("你好，sb");
    }
    private String showNation(String nation){
        System.out.println("我的国籍是" + nation);
        return nation;
    }

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


package com.www.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;

/**
 * 1.直接new和运用反射都能调用公共结构，开发中优先使用new
 * 2.使用反射时机？反射特征：动态性（不确定用哪个对象）
 * 3.封装性与反射矛盾？不建议调用私有，但可以调用
 *
 * 关于java.lang.Class的理解
 * 1.类的加载过程：程序经过javac.exe后，生成一个或多个字节码文件（.class）。
 *   接着，java.exe对某个字节码文件进行解释运行，相当于将字节码文件加载到内存中，此过程问类加载。
 *   加载到内存中的类，为运行时类，可作为Class的一个实例。换句话说，Class的一个实例对应着一个运行时类。
 * 2.加载到内存中的运行时类，会在内存中缓存一段时间，在此时间内，我们可以通过不同的方式获取此运行时类。
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class ReflectionTest {
    //反射之前，在Person外部，不可以通过对象调用其私有结构
    @Test
    public void test(){
        Person p1 = new Person("Tom",12);
        p1.age = 23;
        p1.show();
    }

    //反射之后
    @Test
    public void test1() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        //通过反射创建Person对象
        Class clazz = Person.class;
        Constructor cons = clazz.getConstructor(String.class, int.class);
        Object obj = cons.newInstance("Tom", 12);
        Person p = (Person)obj;
        System.out.println(p.toString());
        //调用对象指定属性、方法
        Field age = clazz.getDeclaredField("age");
        age.set(p, 10);
        System.out.println(p.toString());

        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);

        //通过反射，可以调用Person类私有结构
        Constructor cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = (Person)cons1.newInstance("Jerry");
        System.out.println(p1);

        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1, "LiLei");
        System.out.println(p1);

        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        String nation = (String) showNation.invoke(p1, "中国");
        System.out.println(nation);


    }

    //获取Class实例方式
    @Test
    public void test2() throws ClassNotFoundException {
        //1.调用运行时类的属性.class
        Class clazz = Person.class;

        //2.通过运行时类的对象，调用getClass（）
        Person person = new Person();
        Class clazz1 = person.getClass();

        //3.调用Class的静态方法：forName(String classPath)(最常用)
        Class clazz2 = Class.forName("com.www.java.Person");

        System.out.println(clazz == clazz1);//true
        System.out.println(clazz == clazz2);//true

        //4.使用类的加载器（了解）：ClassLoader
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class clazz3 = classLoader.loadClass("com.www.java.Person");
    }
}


package com.www.java;

import org.junit.Test;

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

/**
 * 了解类的加载器
 *
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class ClassLoaderTest {

    @Test
    public void test(){
        //对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);
        //调用系统类加载器的getParent()：获取扩展类加载器
        ClassLoader parent = classLoader.getParent();
        System.out.println(parent);
        //调用扩展类加载器的getParent()：无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);
    }

    /*
    Properties：用来读取配置文件

     */
    @Test
    public void test1() throws IOException {

        Properties properties = new Properties();
        //读取配置文件方式一：此时文件在当前module下
//        FileInputStream fileInputStream = new FileInputStream("jdbc.properties");
//        properties.load(fileInputStream);

        //读取配置文件方式二：此时文件在当前module的src下
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream resourceAsStream = classLoader.getResourceAsStream("jdbc1.properties");
        properties.load(resourceAsStream);


        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        System.out.println("user = " + user + "\tpassword = " + password);

    }
}


package com.www.java;

import org.junit.Test;

import java.util.Random;

/**
 * 通过反射创建对应的运行时类的对象
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class NewInstanceTest {

    @Test
    public void test() throws InstantiationException, IllegalAccessException {
        Class<Person> clazz = Person.class;
        /*
        newInstance()：调用此方法，创建对应的运行时类的对象，内部调用了空参构造器（所以一定要有空参构造器，且权限不能是private）

        在javabean中要求提供一个空参构造器，原因：
        1.便于通过反射创建运行时类对象
        2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
         */
        Person obj = clazz.newInstance();
        System.out.println(obj);
    }

    @Test
    public void test1() throws Exception {
        int num = new Random().nextInt(3);//0,1,2
        String classPath = "";
        switch (num){
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.www.java.Person";
                break;
        }
        Object obj = getInstance(classPath);
        System.out.println(obj);


    }
    //创建指定类对象
    //classPath：指定类全类名
    public Object getInstance(String classPath) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class clazz = Class.forName(classPath);
        return clazz.newInstance();//sql下不能调空参构造器java.lang.InstantiationException: java.sql.Date
    }
}

获取运行时类属性、方法等

package com.www.java1;

import java.io.Serializable;

/**
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class Creature<T> implements Serializable {
        private char gender;
        public double weight;

        private void breath(){
                System.out.println("生物呼吸");
        }
        public void eat(){
                System.out.println("生物进食");
        }


}


package com.www.java1;

/**
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
@MyAnnotation(value = "hi")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{
    private String name;
    int age;
    public int id;

    public Person() {
    }
    @MyAnnotation(value = "abc")
    private Person(String name) {
        this.name = name;
    }

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

    @MyAnnotation
    private String show(String nation){
        System.out.println("我的国籍是" + nation);
        return nation;
    }

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

    @Override
    public void info() {
        System.out.println("你是一个大坏蛋");
    }

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


package com.www.java1;

/**
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public interface MyInterface {
    void info();
}


package com.www.java1;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;


/**
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
@Target({TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}


package com.www.java2;

import com.www.java1.Person;
import org.junit.Test;

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

/**
 * 获取运行时类属性
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class FieldTest {
    @Test
    public void test(){
        Class clazz = Person.class;

        //获取属性结构
        //getFields()：获取当前运行时类及父类中声明为public的属性
        Field[] fields = clazz.getFields();
        for(Field f:fields){
            System.out.println(f);
        }

        //getDeclaredFields()：获取当前运行时类自身的属性（不包含父类）
        Field[] fields1 = clazz.getDeclaredFields();
        for(Field f:fields1){
            System.out.println(f);
        }

    }

    @Test
    public void test1(){
        Class clazz = Person.class;
        Field[] fields1 = clazz.getDeclaredFields();
        for(Field f:fields1){
            //权限修饰符
            int modifiers = f.getModifiers();//返回修饰符对应数数字
            System.out.print(Modifier.toString(modifiers));//再将对应数字翻译回来

            //数据类型
            Class<?> type = f.getType();
            System.out.print("\t" + type.getName());
            //变量名
            String name = f.getName();
            System.out.println("\t" + name);
            System.out.println();
        }
    }

}


package com.www.java2;

import com.www.java1.Person;
import org.junit.Test;

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

/**
 * 获取运行时类方法
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class MethodTest {
    @Test
    public void test(){
        Class<Person> clazz = Person.class;

        //获取当前运行时类及父类中声明为public的所有方法
        Method[] methods = clazz.getMethods();
        for(Method m:methods){
            System.out.println(m);
        }
        System.out.println("*****");
        //getDeclaredMethods()：获取当前运行时类自身的所有方法
        Method[] methods1 = clazz.getDeclaredMethods();
        for(Method m:methods1){
            System.out.println(m);
        }
    }
    /*
    @Xxxx(注解)
    权限修饰符 返回值类型 方法名（参数1，参数2，...）throws XxxException{}
     */
    @Test
    public void test1(){

        Class<Person> clazz = Person.class;
        Method[] methods1 = clazz.getDeclaredMethods();
        for(Method m:methods1){
            //1.获取方法声明的注解
            Annotation[] annotations = m.getAnnotations();
            for(Annotation a:annotations){
                System.out.println(a);
            }
            //2.权限修饰符
            System.out.print(Modifier.toString(m.getModifiers()) + " ");

            //3.返回值类型
            System.out.print(m.getReturnType().getName() + " ");
            //4.方法名
            System.out.print(m.getName());
            System.out.print("(");
            //5.形参列表
            Class<?>[] parameterTypes = m.getParameterTypes();
            if(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.println("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();
        }
    }
}


package com.www.java2;

import com.www.java1.Person;
import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * @author www
 * @creat 2022-{MONTH}-{DAY}
 */
public class OtherTest {
    /*
    获取构造器结构
     */
    @Test
    public void test(){
        Class<Person> clazz = Person.class;
        //获取当前运行时类中声明为public的构造器
        Constructor<?>[] constructors = clazz.getConstructors();
        for(Constructor c:constructors){
            System.out.println(c);
        }
        //获取当前运行时类所有的构造器
        Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c:declaredConstructors){
            System.out.println(c);
        }
    }
    /*
    获取运行时类的父类
     */
    @Test
    public void test1(){
        Class<Person> clazz = Person.class;
        Class<? super Person> superclass = clazz.getSuperclass();
        System.out.println(superclass);
    }
    /*
    获取运行时类带泛型的父类
     */
    @Test
    public void test2(){
        Class<Person> clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);
    }
    /*
    获取运行时类带泛型的父类的泛型
     */
    @Test
    public void test3(){
        Class<Person> clazz = Person.class;
        Type genericSuperclass = clazz.getGenericSuperclass();
        ParameterizedType cc = (ParameterizedType)genericSuperclass;
        Type[] actualTypeArguments = cc.getActualTypeArguments();//Type实现了Class
        //第一种
//        for(Type t:actualTypeArguments){
//            System.out.println(t.getTypeName());
//        }
        //第二种
        for(Type t:actualTypeArguments){
            System.out.println(((Class)t).getName());
        }
    }
    /*
    获取运行时类实现的接口
     */
    @Test
    public void test4(){
        Class<Person> clazz = Person.class;
        Class<?>[] interfaces = clazz.getInterfaces();
        for(Class c:interfaces){
            System.out.println(c);
        }
    }
    /*
    获取运行时类所在包
     */
    @Test
    public void test5() {
        Class<Person> clazz = Person.class;
        Package aPackage = clazz.getPackage();
        System.out.println(aPackage);
    }
}
新手学java2021
关注
专栏目录
Java--反射机制原理、几种Class获取方式及应用场景
JustinQin
08-24 3万+
目录学习背景一、Java反射机制是什么？1.1 反射原理1.2 举例说明二、Java反射机制中获取Class的三种方式及区别？2.1 三种方式及区别2.2 代码演示区别三、Java反射机制的应用场景有哪些？3.1 应用场景3.2 应用场景实现3.2.1 简单工厂模式3.2.2 简单工厂模式优化（应用场景）3.2.1 代理模式中动态代理（应用场景） 学习背景 学习Java的小伙伴，可能听过Java反射机制，但是熟悉又有点陌生，本文主要是通过思考面试中经常被问到的几个Java反射机制的问题，再通过理论知识结合代
Python反射机制
lbj1260200629的博客
11-27 2318
Python反射机制
Java基础篇：反射机制详解
热门推荐
张维鹏的博客
12-03 21万+
一、什么是反射： 反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行的时候才动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些...
反射机制
qq_45874107的博客
03-07 1万+
反射机制 反射机制是什么 1.反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法； 2.对于任意一个对象，都能够调用它的任意一个方法和属性； 3.这种动态获取的信息以及动态调用对象的方法的功能就是反射机制； 4.也就是说通过反射机制，我们可以获取想要获取到的东西，对前面所学到的范围限定词的限制就可以打破约束 反射机制的作用 1.在运行时判断任意一个对象所属的类； 2.在运行时构造任意一个类的对象； 3.在运行时判断任意一个类所具有的成员变量和方法； 4.在运行时调用任意一个对象的方法；
Java反射机制
2303_77640525的博客
09-11 1151
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取信息以及动态调用对象的方法的功能称为java语言的反射机制。在仅知道“包名+类名”的情况下使用。动态获取类的信息。
Java-反射机制（超详解）
weixin_52533007的博客
05-11 4万+
Java反射机制概述一、Java反射机制概述1. Java Reflection2. 动态语言 vs 静态语言二、 理解Class类并获取Class的实例1. 概述2. 方法3. 哪些类型可以有Class对象？4. 获取Class类的实例(四种方法)三、类的加载与ClassLoader的理解1. 类的加载过程2. 什么时候会发生类初始化？3. 类加载器的作用4. JVM中不同类型的类的加载器5.6. Properties：用来读取配置文件。四、 创建运行时类的对象五、获取运行时类的完整结构1. 获取当前
Java 中的反射机制（两万字超全详解）
林二月的博客
09-08 2万+
文章目录一、反射概述1. 什么是反射？2. 反射机制原理3. 反射优点和缺点4. 类加载概述5. 类加载各阶段完成的功能5.1 加载阶段5.2 连接阶段——验证5.3 连接阶段——准备5.4 连接阶段——解析5.5 初始化阶段二、Class 类1. 动态加载2. 小结三、访问字段1. 获取字段值2. 设置字段值3. 小结四、调用方法1. 调用方法2. 调用静态方法3. 调用非 public方法4. 多态5. 小结五、调用构造方法六、获取继承方法1. 获取父类的Class2. 获取interface3. 继承
Java 反射机制
lucky_fd的博客
04-30 2149
Reflection(反射)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象 (一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
Java反射机制详解
weixin_53840353的博客
08-16 1593
反射指的是程序在运行时可以访问、检测和修改它自己的状态或行为。Java反射机制提供了一些类和接口，允许开发者在运行时获取类的元数据（如类名、方法、属性等），并对这些元数据进行操作。Java反射机制是一个强大的工具，允许开发者在运行时动态操作类的结构和行为。尽管反射带来了一定的性能开销和代码复杂性，但在许多场景下仍然非常有用。理解和正确使用反射机制，可以提高代码的灵活性和可扩展性。在实际开发中，应该根据具体需求和性能考虑，合理使用反射机制。
反射机制原理
明思齐的博客
06-14 1186
简介：反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。反射概念(简单)：反射机制也被应用到了视窗系统、操作系统和文件系统中。 Java中，反射是一种强大的工具。它使你能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。1.什么是反射？反射是一种机制,利用反射机制动态的实例化对象、读写属性、调用方法、构造函数。2.如何得到类对象一切反射相关的代码都从获得类对象开始 3种获取方式： 1 类名.cl
Qt 使用QMetaObject实现反射机制代码demo
07-29
在编程领域，反射机制是一种强大的特性，允许程序在运行时检查自身的行为，包括类的信息、对象的状态以及函数的调用等。在C++的世界里，Qt框架提供了一种实现反射的手段，即QMetaObject系统。这个系统允许我们动态地...
PHP基于反射机制实现自动依赖注入的方法详解
12-20
在依赖注入的上下文中，反射机制被用来动态地获取类的构造函数或方法的参数信息，以便于创建和注入相应的依赖对象。 首先，我们看一个简单的工具类`Ioc`，它是依赖注入容器的实现： ```php class Ioc { // ... ...
C++反射机制实现
03-21
在讨论C++反射机制实现的过程中，我们首先需要明确反射机制的概念和分类。反射的定义源自人工智能领域，它主要涉及到两种反射结构：结构反射和计算反射。结构反射侧重于元类与类之间的关系，计算反射则关注于计算...
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
Java 反射机制实例详解
08-29
Java 反射机制实例详解 Java 反射机制实例详解是一种动态语言机制，允许在程序运行时加载、探知和使用编译期间完全不知道的类、生成其对象实体，调用其方法或者对属性设值。下面是 Java 反射机制实例详解的知识点：...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 688
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
java将word转pdf
最新发布
紫月7575的博客
09-30 421
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 474
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1083
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java反射机制深度解析
"JAVA基础－－JAVA中的反射机制详解" JAVA反射机制是Java语言的一个核心特性，它允许程序在运行时动态地获取类的信息并操作类的对象。反射机制为Java提供了强大的元数据访问能力，使代码能够对自身进行检查并且可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

新手学java2021

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

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

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

打赏作者

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

抵扣说明：

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

余额充值