【Java基础】反射

已于 2023-02-21 16:41:29 修改
阅读量447 收藏
点赞数
分类专栏： Java基础 文章标签： java jvm 开发语言
于 2023-02-21 14:40:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50799082/article/details/129142107
版权

概述

引入

package ref;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.Properties;

public class Ref {

    public static void main(String[] args) throws Exception {

        //加载properties

        Properties properties = new Properties();

        properties.load(new FileInputStream("src\\re.properties"));

        String calsspath= properties.getProperty("classpath");

        String methodName=properties.getProperty("method");

//        System.out.println(method);

//         System.out.println(calss);

        //使用反射机制解决

       //(1) 加载类, 返回Class类型的对象cls

        Class cls=Class.forName(calsspath);

        //实例化对象

        Object o = cls.newInstance();

        //通过 cls 得到你加载的类 com.hspedu.Cat 的 methodName"hi"  的方法对象

        //即：在反射中，可以把方法视为对象（万物皆对象

        Method method = cls.getMethod(methodName);

        method.invoke(o); //传统方法 对象.方法() , 反射机制 方法.invoke(对象)

        //得到字段

        //getfield 不能得到私有的字段，只能得到共有的字段

//        Field name = cls.getField("name");

          Field age = cls.getField("age");

        System.out.println(age.get(o));

        //得到构造器

        Constructor constructor = cls.getConstructor();//()中可以指定参数，返回无参构造器

        Constructor constructor1 = cls.getConstructor(String.class);//String.class 就是 String类的class 对象

        System.out.println(constructor1);

    }

}

原理

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

在这里插入图片描述

优化

在这里插入图片描述

优缺点

优点：

  • 可以动态的创建和使用对象（也是框架底层核心），使用灵活，没有反射机制，框架技术就是去底层支持

缺点：

  • 使用反射基本是解释执行，对执行速度有影响
  • 反射调用方法时可以忽略权限检查，获取这个类的私有方法和属性，因此可能会破坏类的封装性而导致安全问题。

Class类

在这里插入图片描述

在这里插入图片描述

常用方法

类型访问方法返回值类型说明
包路径getPackage()Package 对象获取该类的存放路径
类名称getName()String 对象获取该类的名称
继承类getSuperclass()Class 对象获取该类继承的类
实现接口getlnterfaces()Class 型数组获取该类实现的所有接口
构造方法getConstructors()Constructor 型数组获取所有权限为 public 的构造方法
getDeclaredContruectors()Constructor 对象获取当前对象的所有构造方法
方法getMethods()Methods 型数组获取所有权限为 public 的方法
getDeclaredMethods()Methods 对象获取当前对象的所有方法
成员变量getFields()Field 型数组获取所有权限为 public 的成员变量
getDeclareFileds()Field 对象获取当前对象的所有成员变量
内部类getClasses()Class 型数组获取所有权限为 public 的内部类
getDeclaredClasses()Class 型数组获取所有内部类
内部类的声明类getDeclaringClass()Class 对象如果该类为内部类，则返回它的成员类，否则返回 null
String classpath="learn.Car";

//<?>代表不确定的cls

Class<?> cls = Class.forName(classpath);

System.out.println(cls);//显示的时cls对象是那个类的Class对象 class learn.Car

System.out.println(cls.getClass());//显示的是cls的运行类型class java.lang.Class

//得到包名

System.out.println(cls.getPackage());//package learn

System.out.println(cls.getPackage().getName());//learn

//得全类名

System.out.println(cls.getName());//learn.Car

//通过cls创建实例

Car car = (Car)cls.newInstance();

car.setName("宝马");

System.out.println(car.getName());

//获取属性，但属性要是共有的

Field weight = cls.getField("weight");

System.out.println(weight.get(car));

//设置属性

weight.set(car,200);

System.out.println(weight.get(car));

//得到所有的字段属性,也是public

Field[] fields = cls.getFields();

System.out.println(fields.length);//1

for (Field field:

     fields) {

    System.out.println(field.getName());

}

得到Class对象的方法

        //1.Class.forName 往往通过配置文件读取到

        String classpath="learn.Car";

        Class<?> cls = Class.forName(classpath);

        System.out.println(cls);

        System.out.println(cls.hashCode());

        //2.类名.class 多用于参数传递

        Class<Car> cls2 = Car.class;

        System.out.println(cls2);

        System.out.println(cls2.hashCode());

        //3.通过对象名来获取 对象名.getclas

        Car car=new Car();

        Class cls3=car.getClass();

        System.out.println(cls3);

        System.out.println(cls3.hashCode());

        //4.通过类加载器（4种），来获取

        //   1,先得到类加载器

        ClassLoader classLoader = car.getClass().getClassLoader();

        //    2,通过类加载器得到类对象

        Class<?> cls4= classLoader.loadClass(classpath);

        System.out.println(cls4);

        System.out.println(cls4.hashCode());

        //5.基本数据类型也可以 int.class

        Class<Integer> integerClass = int.class;

        System.out.println(integerClass);//int

        //6.基本数据类型的包装类 Integer.TYPE
        Class<Integer> type = Integer.TYPE;

        System.out.println(type);//int

        System.out.println(integerClass.hashCode());

        System.out.println(type.hashCode());//Integer.TYPE和int.class二者是一样的，底层通过拆箱和装箱是同一个

在这里插入图片描述

那些类型有Class对象

在这里插入图片描述

Class<String> stringClass = String.class;//外部类

Class<Serializable> serializableClass = Serializable.class;//接口类

Class<int[]> aClass = int[].class;//数组类

Class<Deprecated> deprecatedClass = Deprecated.class;//注解类

Class<Thread.State> stateClass = Thread.State.class;//枚举类

Class<Integer> integerClass = int.class;//基本数据类型类

Class<Integer> integerClass1 = Integer.class;//基本数据类型包装类类

Class<Void> voidClass = void.class;//void 类

Class<Class> classClass = Class.class;//Class类,也是一种外部类

通过反射获取类的结构信息

Class类

在这里插入图片描述

package class_;

import org.junit.Test;

import java.lang.annotation.Annotation;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class Class07 {

    public static void main(String[] args) {

    }

    @Test

    public void api01() throws ClassNotFoundException {

        Class<?> peopleClass = Class.forName("class_.People");

        //获得全类名

        System.out.println(peopleClass.getName());//class_.People

        //获得简单类名

        System.out.println(peopleClass.getSimpleName());//people

        //获取本类以及父类的所有公共属性

        Field[] fields = peopleClass.getFields();

        for (Field field:

             fields) {

            System.out.println(field.getName());

        }

        //获取本类的所有属性,包括私有等

        System.out.println("===");

        Field[] declaredFields = peopleClass.getDeclaredFields();

        for (Field field:

                declaredFields) {

            System.out.println(field.getName());

        }

        //获取本类及父类的public方法,不限于直接父类

        System.out.println("====");

        Method[] methods = peopleClass.getMethods();

        for (Method method : methods) {

            System.out.println(method.getName());

        }

        //获取本类的所有方法

        System.out.println("=====");

        Method[] declaredMethods = peopleClass.getDeclaredMethods();

        for (Method declaredMethod : declaredMethods) {

            System.out.println(declaredMethod.getName());

        }

        //获取本类的所有public构造器,没有父类

        System.out.println("=====");

        Constructor<?>[] constructors = peopleClass.getConstructors();

        for (Constructor<?> constructor : constructors) {

            System.out.println(constructor.getName());

        }

        //获取本类的所有方法，不局限于public

        System.out.println("+++");

        Constructor<?>[] declaredConstructors = peopleClass.getDeclaredConstructors();

        for (Constructor<?> declaredConstructor : declaredConstructors) {

            System.out.println(declaredConstructor.getName());

        }

        //得到包名

        System.out.println(peopleClass.getPackage());//package class_

        //得到父类的信息

        System.out.println(peopleClass.getSuperclass());//class class_.Animal

        //返回接口

        Class<?>[] interfaces = peopleClass.getInterfaces();

        for (Class<?> anInterface : interfaces) {

            System.out.println(anInterface.getName());

        }

        //返回注解

        Annotation[] annotations = peopleClass.getAnnotations();

        for (Annotation annotation : annotations) {

            System.out.println(annotation);

        }

    }

}

interface IFA {

}

interface IFB {

}

class Animal{

    public String hobby;

    public void hi() {

    }

    public Animal() {

    }

    public Animal(String hobby) {

    }

}

@Deprecated

class People extends Animal implements IFA,IFB{

    //属性

    public String name;

    protected static int age; // 4 + 8 = 12

    String job;

    private double sal;

    //构造器

    public People(){

    }

    public People(String name) {

    }

    //私有的

    private People(String name, int age) {

    }

    //方法

    public void m1(String name, int age, double sal) {

    }

    protected String m2() {

        return null;

    }

    void m3() {

    }

    private void m4() {

    }

}

Filed类，Method类

在这里插入图片描述

package class_;

import org.junit.Test;

import java.lang.annotation.Annotation;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

public class Class07 {

    public static void main(String[] args) {

    }

    @Test

    public void api01() throws ClassNotFoundException {

        Class<?> peopleClass = Class.forName("class_.People");

        //获得全类名

        System.out.println(peopleClass.getName());//class_.People

        //获得简单类名

        System.out.println(peopleClass.getSimpleName());//people

        //获取本类以及父类的所有公共属性

        Field[] fields = peopleClass.getFields();

        for (Field field:

             fields) {

            System.out.println(field.getName());

        }

        //获取本类的所有属性,包括私有等

        System.out.println("===");

        Field[] declaredFields = peopleClass.getDeclaredFields();

        for (Field field:

                declaredFields) {

            System.out.println(field.getName());

        }

        //获取本类及父类的public方法,不限于直接父类

        System.out.println("====");

        Method[] methods = peopleClass.getMethods();

        for (Method method : methods) {

            System.out.println(method.getName());

        }

        //获取本类的所有方法

        System.out.println("=====");

        Method[] declaredMethods = peopleClass.getDeclaredMethods();

        for (Method declaredMethod : declaredMethods) {

            System.out.println(declaredMethod.getName());

        }

        //获取本类的所有public构造器,没有父类

        System.out.println("=====");

        Constructor<?>[] constructors = peopleClass.getConstructors();

        for (Constructor<?> constructor : constructors) {

            System.out.println(constructor.getName());

        }

        //获取本类的所有方法，不局限于public

        System.out.println("+++");

        Constructor<?>[] declaredConstructors = peopleClass.getDeclaredConstructors();

        for (Constructor<?> declaredConstructor : declaredConstructors) {

            System.out.println(declaredConstructor.getName());

        }

        //得到包名

        System.out.println(peopleClass.getPackage());//package class_

        //得到父类的信息

        System.out.println(peopleClass.getSuperclass());//class class_.Animal

        //返回接口

        Class<?>[] interfaces = peopleClass.getInterfaces();

        for (Class<?> anInterface : interfaces) {

            System.out.println(anInterface.getName());

        }

        //返回注解

        Annotation[] annotations = peopleClass.getAnnotations();

        for (Annotation annotation : annotations) {

            System.out.println(annotation);

        }

    }

    @Test

    public void api02() throws ClassNotFoundException {

        Class<?> peopleClass = Class.forName("class_.People");

        //获取本类中所有的属性

        Field[] declaredFields = peopleClass.getDeclaredFields();

        for (Field declaredField : declaredFields) {

            System.out.println("本类中的属性："+declaredField.getName()+

                    "该属性的修饰符："+declaredField.getModifiers()+

                    " 该属性的类型"+declaredField.getType());

        }

    }

    @Test

    public void api03() throws ClassNotFoundException {

        Class<?> peopleClass = Class.forName("class_.People");

        //获取本类中所有的方法

        Method[] declaredMethods = peopleClass.getDeclaredMethods();

        for (Method declaredMethod : declaredMethods) {

            System.out.println("该类的方法"+declaredMethod.getName()+

                    "该属性的修饰符："+declaredMethod.getModifiers()+

                    "该类的返回类型"+declaredMethod.getReturnType());

            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();

            for (Class<?> parameterType : parameterTypes) {

                System.out.println("该方法的参数类型"+parameterType.getName());

            }

        }

    }

    @Test

    public void api04() throws ClassNotFoundException {

        Class<?> peopleClass = Class.forName("class_.People");

        //获取本类中所有的构造器

        Constructor<?>[] declaredConstructors = peopleClass.getDeclaredConstructors();

        for (Constructor<?> declaredConstructor : declaredConstructors) {

            System.out.println(declaredConstructor);

            System.out.println(declaredConstructor.getName());//名字

            System.out.println(declaredConstructor.getModifiers());//修饰符

            System.out.println(declaredConstructor.getParameterCount());//参数个数

        }

    }

}

interface IFA {

}

interface IFB {

}

class Animal{

    public String hobby;

    public void hi() {

    }

    public Animal() {

    }

    public Animal(String hobby) {

    }

}

@Deprecated

class People extends Animal implements IFA,IFB{

    //属性

    public String name;

    protected static int age; // 4 + 8 = 12

    String job;

    private double sal;

    //构造器

    public People(){

    }

    public People(String name) {

    }

    //私有的

    private People(String name, int age) {

    }

    //方法

    public void m1(String name, int age, double sal) {

    }

    protected String m2() {

        return null;

    }

    void m3() {

    }

    private void m4() {

    }

}

动态加载和静态加载

在这里插入图片描述

package class_;

import learn.Car;

import javax.management.MBeanRegistration;

import java.util.Scanner;

public class Class05 {

    public static void main(String[] args) throws ClassNotFoundException {

        Scanner scanner=new Scanner(System.in);

        String key=scanner.next();

        switch (key){

            case "1":

                //静态加载，如果没有import learn.Car，编译javac就会报错

                Car car =new Car();

            case "2":

                //动态加载,javac编译不会报错

                Class<?> aClass = Class.forName("learn.Cat");

                break;

        }

    }

}

类加载

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

类加载前两个阶段由JVM控制，初始化是由程序员控制，主要是静态成员

  1. 加载loading
    • JVM在该阶段的主要目的是将字节码从 不同的数据源（可能是class文件，也可能是jar包，甚至是网络）转换成二进制字节流加载到内存（方法区中）并生成一个该类的java.lang.Class对象（堆中）
  2. 连接Linking
    1. 验证verification
      • 目的是为了确保Class文件的字节流中包含的信息复合当前虚拟机的要求，并且不会危害虚拟机自身的安全
      • 包括：文件格式验证（是否以魔数 oxcafebage开头）、元数据验证、字节码验证和符号引用验证
      • 可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施，缩短虚拟机加载的时间
    2. 准备preparation
      • JVM会在该阶段对静态变量，分配内存并默认初始化（对应数据类型的默认初始化值，eg.0,0L,null,false等）（和Class对象一起存放在堆中)
    3. 解析resolution
      • 虚拟机将常量池内的符号引用替换为直接引用的过程
      • 即在编译阶段，并没有放到内存中没有内存地址，所以引用是符号引用；在解析这一步把符号引用替换为直接引用
  3. 初始化initialization
    • 到初始化阶段，才开始执行类中定义的Java代码，此阶段执行clinit()方法的过程
    • clinit()方法是由编译器按照语句在源文件中出现的顺序，一次自动收集类中所有的静态变量的赋值动作和静态代码块中的语句，并进行合并
    • 虚拟机会保证一个类的clinit()方法在多线程环境中被正确的加锁，同步，如果多个线程同时去初始化一个类，俺么只会有一个线程去执行这个类的clint()方法

通过反射创建对象

在这里插入图片描述

package class_;

import org.junit.Test;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

public class calss08 {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {

        //得到Class对象

        Class<?> cls = Class.forName("class_.User");

        //通过public的无参构造器创建对象

        Object o = cls.newInstance();

        System.out.println(o);

        //通过public的有参构造器创建实例

        //先获得有参构造器，才创建实例

        Constructor<?> constructor = cls.getConstructor(String.class);

        Object zhang = constructor.newInstance("zhang");

        System.out.println(zhang);

        //通过private的有参构造器

        Constructor<?> declaredConstructor = cls.getDeclaredConstructor(int.class, String.class);

        declaredConstructor.setAccessible(true);//爆破，使用返反射可以用private构造器

        Object baby = declaredConstructor.newInstance(2, "baby");

        System.out.println(baby);

    }

}

class User { //User类

    private int age = 10;

    private String name = "gao";

    public User() {//无参 public

    }

    public User(String name) {//public的有参构造器

        this.name = name;

    }

    private User(int age, String name) {//private 有参构造器

        this.age = age;

        this.name = name;

    }

    public String toString() {

        return "User [age=" + age + ", name=" + name + "]";

    }

}

类的成员和方法

在这里插入图片描述

package com.hspedu.reflection;

import java.lang.reflect.Field;

/**

 * @author 韩顺平

 * @version 1.0

 * 演示反射操作属性

 */

public class ReflecAccessProperty {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {

        //1. 得到Student类对应的 Class对象

        Class<?> stuClass = Class.forName("com.hspedu.reflection.Student");

        //2. 创建对象

        Object o = stuClass.newInstance();//o 的运行类型就是Student

        System.out.println(o.getClass());//Student

        //3. 使用反射得到age 属性对象

        Field age = stuClass.getField("age");

        age.set(o, 88);//通过反射来操作属性

        System.out.println(o);//

        System.out.println(age.get(o));//返回age属性的值

        //4. 使用反射操作name 属性

        Field name = stuClass.getDeclaredField("name");

        //对name 进行暴破, 可以操作private 属性

        name.setAccessible(true);

        //name.set(o, "老韩");

        name.set(null, "老韩~");//因为name是static属性，因此 o 也可以写出null

        System.out.println(o);

        System.out.println(name.get(o)); //获取属性值

        System.out.println(name.get(null));//获取属性值, 要求name是static

    }

}

class Student {//类

    public int age;

    private static String name;

    public Student() {//构造器

    }

    public String toString() {

        return "Student [age=" + age + ", name=" + name + "]";

    }

}

package com.hspedu.reflection;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

/**

 * @author 韩顺平

 * @version 1.0

 * 演示通过反射调用方法

 */

public class ReflecAccessMethod {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        //1. 得到Boss类对应的Class对象

        Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");

        //2. 创建对象

        Object o = bossCls.newInstance();

        //3. 调用public的hi方法

        //Method hi = bossCls.getMethod("hi", String.class);//OK

        //3.1 得到hi方法对象

        Method hi = bossCls.getDeclaredMethod("hi", String.class);//OK

        //3.2 调用

        hi.invoke(o, "韩顺平教育~");

        //4. 调用private static 方法

        //4.1 得到 say 方法对象

        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);

        //4.2 因为say方法是private, 所以需要暴破，原理和前面讲的构造器和属性一样

        say.setAccessible(true);

        System.out.println(say.invoke(o, 100, "张三", '男'));

        //4.3 因为say方法是static的，还可以这样调用 ，可以传入null

        System.out.println(say.invoke(null, 200, "李四", '女'));

        //5. 在反射中，如果方法有返回值，统一返回Object , 但是他运行类型和方法定义的返回类型一致

        Object reVal = say.invoke(null, 300, "王五", '男');

        System.out.println("reVal 的运行类型=" + reVal.getClass());//String

        //在演示一个返回的案例

        Method m1 = bossCls.getDeclaredMethod("m1");

        Object reVal2 = m1.invoke(o);

        System.out.println("reVal2的运行类型=" + reVal2.getClass());//Monster

    }

}

class Monster {}

class Boss {//类

    public int age;

    private static String name;

    public Boss() {//构造器

    }

    public Monster m1() {

        return new Monster();

    }

    private static String say(int n, String s, char c) {//静态方法

        return n + " " + s + " " + c;

    }

    public void hi(String s) {//普通public方法

        System.out.println("hi " + s);

    }

}
程序员加文
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java 基础 - 反射
Liarboy
09-15 4089
注解是插入你代码中的一种注释或者说是一种元数据（meta data）。这些注解信息可以在编译期使用预编译工具进行处理（），也可以在运行期使用Java反射机制进行处理。}在TheClass类定义的上面有一个的注解。注解的定义与接口的定义相似，下面是}在interface前面的@符号表名这是一个注解，一旦你定义了一个注解之后你就可以将其应用到你的代码中，就像之前我们的那个例子那样。在注解定义中的两个指示和，说明了这个注解该如何使用。表示这个注解可以在运行期通过反射访问。
6-2 异常：物品安全检查 (20分) java pta
m0_46553277的博客
11-01 2552
这是函数题模板。这里写题目要求。 车站检查危险品的设备，如果发现危险品会发出警告。编程模拟设备发现危险品的情况。编程要求如下： 1. 通过继承Exception类，编写一个DangerException类。 a) 该异常类有构造方法，该构造方法使用super调用父类构造方法，使用字符串：“属于危险品！”，对父类变量message进行初始化。 2. 编写商品类：Goods，该类包含以下成员： a) 私有的name属性(String类型)，表示商品名称。 b) 私有的isDanger属性(boolean型)，表
蓝桥杯第十四届模拟赛第二期试题【Java解析】
qq_54525549的博客
11-29 1887
蓝桥杯第十四届模拟赛第二期Java实现。
反射的相关知识
pureorange的博客
11-30 123
反射 反射体现运行时的动态性 public class NewInstance1 { //体现反射的动态性 public static void main(String[] args) throws Exception { int i = new Random().nextInt(3); String classPath=""; switch (i){ case 0: classPath=
Java基础篇：反射机制详解
张维鹏的博客
12-03 21万+
一、什么是反射： 反射是Java的特征之一，是一种间接操作目标对象的机制，核心是JVM在运行的时候才动态加载类，并且对于任意一个类，都能够知道这个类的所有属性和方法，调用方法/访问属性，不需要提前在编译期知道运行的对象是谁，他允许运行中的Java程序获取类的信息，并且可以操作类或对象内部属性。程序中对象的类型一般都是在编译期就确定下来的，而当我们的程序在运行时，可能需要动态的加载一些...
Java反射技术详解
黄林晴
04-14 23万+
前言 相信很多人都知道反射可以说是Java中最强大的技术了，它可以做的事情太多太多，很多优秀的开源框架都是通过反射完成的，比如最初的很多注解框架，后来因为java反射影响性能，所以被运行时注解APT替代了，java反射有个开源框架jOOR相信很多人都用过，不过我们还是要学习发射的基础语法，这样才能自己写出优秀的框架，当然这里所讲的反射技术，是学习Android插件化技术、Hook技术等必不可...
Java基础之—反射（非常重要）
热门推荐
sinat_38259539的博客
05-13 73万+
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的
Java基础之反射
星星的博客
08-29 1万+
一、加载类的三种方式 Class clazz1=Class.forName("类的完整名称"); 　　Class clazz2=new Person().getClass(); 　　Class clazz3=Person.class; 二、Class对象提供了如下常用方法 public ConstructorgetConstructor(Class<?>.....
Java基础进阶反射
qq_46096136的博客
09-11 7066
通过java语言中的反射机制可以操作字节码文件。 优点类似于黑客。（可以读和修改字节码文件。） 通过反射机制可以操作代码片段。（class文件。） 反射机制相关的重要的类有哪些？ java.lang.Class：代表整个字节码，代表一个类型，代表整个类。java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法java.lang.reflect.Field：代表
Java基础 反射篇.md
08-11
### 反射基础篇文末总结 反射是Java中一个非常强大的特性，它提供了运行时操作类的能力。虽然反射可以带来很多便利，但也需要注意其潜在的问题，合理地使用反射，可以使我们的代码更加灵活和高效。在实际开发中，...
Java基础反射reflect
01-20
在程序运行期间，Java运行时系统始终为所有的对象维护一个被称为运行时的类型标识。这个信息跟踪着每个对象所属的类。 获取类字节码方式 Class.forName(); 静态方法调用 Class forName = Class.forName(path); 类型...
jreflect:Java 基础反射操作工具包
05-02
反射Java基础反射操作工具包下载依赖< repositories> < repository> < id>github-maven-repo</ id> < url>... public class User { pr
java基础之反射讲解
04-10
### Java基础之反射讲解 #### 一、反射概念与应用场景 **反射**是Java语言提供的一种能在运行时分析和操作类及其成员的强大功能。通过反射，我们可以在程序运行期间动态地获取类的信息，并且能够创建和操作这些类...
新手学习java反射基础
08-25
Java 反射基础知识点 Java 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。下面我们来一起学习一下吧。 一、...
JAVA进阶补充
2301_80150315的博客
08-15 963
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
Java基础之原反补码
u012135697的博客
08-14 475
整数类型数据在计算机底层进行存储或运算，以补码方式进行！ 正整数的原反补码，一模一样！
【Spring框架】
最新发布
m0_71941456的博客
08-18 643
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1107
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
"Java基础反射机制与动态代理
大学课程讲义《Java基础-反射》的内容主要是介绍了Java中的反射机制。反射是指在运行时动态地获取对象的类型信息并操作对象的能力。通过反射，我们可以获取到一个类的属性、方法、构造器等信息，并且可以在运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值