Java三阶(3)-反射

最新推荐文章于 2024-08-16 23:08:28 发布

(ง •_•)ง(ง •_•)ง

最新推荐文章于 2024-08-16 23:08:28 发布

阅读量125

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/chenchen900/article/details/123462227

版权

文章目录

反射

反射

反射机制

通过外部文件配置，在不修改源码情况下，来控制程序，也符合设计模式的oop原则（开闭原则）。

package com.hspedu.reflection.question;

import com.hspedu.Cat;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

@SuppressWarnings({"all"})
public class ReflectionQuestion {
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Cat cat = new Cat();
        cat.hi();

        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath = properties.get("classfullpath").toString();
        String method = properties.get("method").toString();
        System.out.println(classfullpath);
        System.out.println(method);
        //new classfullpath()

        //使用反射机制解决
        //(1)加载类，返回Class类型的对象cls
        Class cls = Class.forName(classfullpath);
        //(2)通过cls得到你加载的类com.hspedu.Cat的对象实例
        Object o = cls.newInstance();
        //(3)通过cls得到你加载的类 com.hspedu.Cat 的method“hi” 的方法对象
        // 即：在反射中，可以把方法视为对象（万物皆是对象）
        Method method1 = cls.getMethod(method);
        //(4)通过method1调用方法：即通过方法对象来实现调用方法
        method1.invoke(o);//传统方法 对象.方法名() ,反射机制 方法.invoke(对象)
        
        
         //getField不能得到私有属性
        Field ageField = cls.getField("age");
        System.out.println(ageField.get(o));//传统写法 对象.成员变量，反射：成员变量对象.get(对象)
        Constructor constructor = cls.getConstructor();//()中可以指定构造器参数类型，返回无参构造器
        System.out.println(constructor);

        Constructor constructor1 = cls.getConstructor(String.class);//这里老师传入的是String.class就是String类的Class对象
        System.out.println(constructor1);
    }
}

反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息（比如成员变量，构造器，成员方法等等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到
加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象）,这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称为：反射。

在这里插入图片描述

反射机制可以完成
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时得到任意一个类所具有的成员变量和方法
- 在运行时调用任意一个对象的成员变量和方法
- 生成动态代理
反射相关的主要类
- java.lang.Class 代表一个类，Class对象表示某个类加载后在堆中的对象
- java.lang.reflect.Method 代表类的方法，Method对象表示某个类的方法
- java.lang.reflect.Field 代表类的成员变量，Field对象表示某个类的成员变量
- java.lang.reflect.Constructor 代表类的构造方法，Constructor对象表示构造器
反射机制的优点和缺点
- 优点：可以动态的创建和使用对象（也是框架底层核心），使用灵活，没有反射机制，框架机制就失去底层支撑
- 缺点：使用反射基本是解释执行，对执行速度有影响
反射调用优化-关闭访问检查
- Method和Field、Constructor对象都有setAccessible()方法
- setAccessible作用是启动和禁用访问安全检查的开关
- 参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查。

public class Reflection02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        m1();
        m2();
        m3();

    }
    public static void m1(){
        Cat cat = new Cat();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            cat.hi();
        }
        long end = System.currentTimeMillis();
        System.out.println("time = " + (end - start));
    }
    public static void m2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        Class cls = Class.forName("com.hspedu.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            hi.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("time = " + (end - start));
    }
    public static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class cls = Class.forName("com.hspedu.Cat");
        Object o = cls.newInstance();
        Method hi = cls.getMethod("hi");
        hi.setAccessible(true);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 900000000; i++) {
            hi.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("time = " + (end - start));
    }
}

Class类

基本介绍

Class也是类，因此也继承Object类
Class类对象不是new出来的，而是系统创建的（类对应的Class类对象）
对于某个类的Class类对象，在内存中只有一份，因此类只加载一次
每个类的实例都会记得自己是由哪个Class实例所创建
通过Class对象可以完整地得到一个类的完整结构，通过一系列API
Class对象是存放在堆的
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据（包括方法代码，变量名，方法名，访问权限等）

在这里插入图片描述

常用方法

public class Class02 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        String classAllPath = "com.hspedu.Car";
        //1.获取到Car类 的Class对象
        //<?>表示不确定的Java类型，这里会出现一个找不到类的异常
        Class<?> cls = Class.forName(classAllPath);
        //2.输出cls
        System.out.println(cls);//显示cls对象，是哪个类的Class对象 com.hspedu.Car（不是Car对象）
        System.out.println(cls.getClass()); //真正的运行类型，这个Class类也可以得到它对应的class
        //java.lang.Class
        //3.得到包名
        System.out.println(cls.getPackage().getName()); //com.hspedu
        //4.得到全类名
        System.out.println(cls.getName());//com.hspedu.Car
        //5.通过cls创建对象实例
        Car car = (Car)cls.newInstance();
        System.out.println(car);//Car{brand='宝马', price=5000000, color='白色'}
        //6.通过反射获取属性
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));//宝马 如果私有属性就会报错
        //7.通过反射给属性赋值
        brand.set(car,"奔驰");
        System.out.println(brand.get(car));
        //8.可以得到所有的属性（字段）
        Field[] fields = cls.getFields();
        for(Field f : fields){
            System.out.println(f.getName());//属性/字段的各个名称
        }
    }
}

获取Class类对象

前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException，实例Class cls1 = Class.forName(“java.lang.Cat”); 应用场景：多用于配置文件，读取类全路径，加载类
前提：若已知具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高实例：Class cls2 = Cat.class; 应用场景：多用于参数传递，比如通过反射得到对应构造器对象
前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象，实例：Class class = 对象.getClass(); 应用场景：通过创建好的对象，获取Class对象
其他方式：ClassLoader cl = 对象.getClass().getClassLoader();
Class class4 = cl.loadClass(“类的全类名”)
基本数据(int, char, boolean, float, double, byte, long, short)按如下方式得到Class类对象。Class cls = 基本数据类型.class
基本数据类型对应的包装类，可以通过.type得到Class类对象。Class cls = 包装类.TYPE

在这里插入图片描述

public class GetClass {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class.forName
        Class cls1 = Class.forName("com.hspedu.Cat");
        System.out.println(cls1);

        //2.类名.Class(多用于参数的传递)
        Class<Cat> cls2 = Cat.class;
        System.out.println(cls2);

        //3.对象.getClass
        //运行类型就是这个对象关联的Class对象
        Cat cat = new Cat();
        Class<? extends Cat> cls3 = cat.getClass();//运行类型
        System.out.println(cls3);

        //4.类加载器得到Class对象 4种类加载器
        //(1)先得到类加载器Car
        ClassLoader classLoader = cat.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        Class<?> cls4 = classLoader.loadClass("com.hspedu.Cat");
        System.out.println(cls4);
        //cls1 cls2 cls3 cls4是同一个
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());

        //5.基本数据(int char boolean float double byte long short)按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass);//int
        System.out.println(characterClass);//char
        System.out.println(booleanClass);//boolean

        //6.基本数据类型对应的包装类，可以通过.type得到Class类对象
        Class<Integer> type = Integer.TYPE;
        Class<Character> type1 = Character.TYPE;
        System.out.println(type);//int
        System.out.println(integerClass.hashCode());//1735600054
        System.out.println(type.hashCode());//1735600054
    }
}

哪些类型有Class对象

外部类，成员内部类，静态内部类，局部内部类，匿名内部类
interface：接口
数组
enum：枚举
annotation：注解
基本数据类型
void

public class AllTypeClass {
    public static void main(String[] args) {
        Class<String> stringClass = String.class;//外部类
        Class<Serializable> serializableClass = Serializable.class;//接口
        Class<Integer[]> aClass = Integer[].class;//一维数组
        Class<float[][]> aClass1 = float[][].class;//二维数组
        Class<Deprecated> deprecatedClass = Deprecated.class;//注解
        Class<Thread.State> stateClass = Thread.State.class;//枚举
        Class<Long> longClass = long.class;//基本数组类型
        Class<Void> voidClass = void.class;//void
        Class<Class> classClass = Class.class;
    }
}

类加载

基本说明

反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载；
静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性

类加载时机

当创建对象时 //静态加载
当子类被加载时,父类也加载 //静态加载
通过类中的静态成员时 //静态加载
通过反射 //动态加载

package com.hspedu.reflection.class_;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Scanner;

public class ClassLoad {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Scanner scanner = new Scanner(System.in);
        String key = scanner.next();
        switch (key){
            case "1":
                Fish fish = new Fish();//静态加载，依赖性很强
                fish.eat();
                System.out.println("eat");
                break;
            case "2":
                //反射->动态加载
                Class<?> person = Class.forName("Person");//加载Person类【动态加载】
                Object o = person.newInstance();
                Method hi = person.getMethod("hi");
                hi.invoke(o);
                System.out.println("ok");
            default:
                System.out.println("finish");
        }
        //因为new Dog()是静态加载，所以必须编写Dog类
        //Person类是动态加载，所以，没有编写Person类也不会报错，只有当动态加载该类是，才会报错
    }
}
class Fish{
    public void eat(){
        System.out.println("大鱼吃小鱼");
    }
}

在这里插入图片描述

加载阶段：JVM在该阶段的主要目的是将字节码从不同的数据源（可能是class文件、也可能是jar包，甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象。
连接阶段-验证：
- 目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
- 包括：文件格式验证（是否以魔数 oxcafebabe开头）、元数据验证、字节码验证和符号引用验证
- 可以考虑使用 -Xverify:none 参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间。
连接阶段-准备
- JVM会在该阶段对静态变量，分配内存并默认初始化（对应数据类型的默认初始值，如0、0L、null、false等）。这些变量所使用的内存都将在方法区中进行分配。
连接阶段-解析
- 虚拟机将常量池内的符号引用替换为直接引用的过程。

public class Test {
    public static void main(String[] args) {
        //new B();
        //1.加载B类，并生成B的class对象
        //2.连接，num = 0
        //3.初始化阶段
        //     依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并
        /*
                clinit(){
                    System.out.println("B 类的静态代码块执行");
                    //num = 300;
                    num = 100;
                }
                合并：num = 100;
         */
        System.out.println(B.num);//100 如果直接使用类的静态属性，也会导致类的加载
    }
}
class A{
    public int n1 = 10;
    public static int n2 = 20;
    public static final int n3 = 30;
    //分析类加载的连接阶段-准备，属性的处理
    //1.n1是实例属性，不是静态变量，因此在准备阶段不会分配内存
    //2.n2是静态变量，分配内存 n2 是默认初始化 0，而不是20
    //3.n3 是static final 是常量，他和静态变量不一样，因为一旦赋值就不变，n3 = 30
}
class B{
    static {
        System.out.println("B 类的静态代码块执行");
        num = 300;
    }
    static int num = 100;
    public B(){
        System.out.println("B 构造器被执行");
    }
}

初始化
- 到了初始化阶段，才真正开始执行类中定义的Java程序代码，此阶段是执行()方法的过程
- ()方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。
- 虚拟机会保证一个类的()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。
- 正因为有上面那个机制，才能保证某个类在内存中，只有一份class对象

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

package com.hspedu.reflection;

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 ReflectionUtils {
    public static void main(String[] args) {

    }
    @Test
    public void api_01() throws ClassNotFoundException, NoSuchMethodException {
        //得到Class对象
        Class<?> aClass = Class.forName("com.hspedu.reflection.Person");
        //getName:获取全类名
        System.out.println(aClass.getName());//com.hspedu.reflection.Person
        //getSimpleName:获取简单类名
        System.out.println(aClass.getSimpleName());//Person
        //getFields:获取所有public修饰的属性，包括本类以及父类的
        System.out.println("---------本类及父类属性-----------");
        Field[] fields = aClass.getFields();
        for(Field field : fields){
            System.out.println(field.getName());
        }
        //getDeclaredFields:获取本类中所有属性
        System.out.println("---------本类属性---------");
        Field[] declaredFields = aClass.getDeclaredFields();
        for(Field f : declaredFields){
            System.out.println(f.getName());
        }
        //getMethods:获取所有public修饰的方法，包括本类以及父类的
        System.out.println("----------本类及父类方法----------");
        Method[] methods = aClass.getMethods();
        for(Method method : methods){
            System.out.println(method.getName());
        }
        //getDeclaredMethods:获取本类中所有方法
        System.out.println("---------本类方法----------");
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for(Method m : declaredMethods){
            System.out.println(m.getName());
        }
        //getConstructor:获取所有public修饰的构造器，包含本类
        System.out.println("======本类公有构造器=======");
        Constructor<?>[] constructors = aClass.getConstructors();
        for(Constructor constructor : constructors){
            System.out.println(constructor.getName());
        }
        //getDeclaredConstructor:获取本类中所有构造器
        System.out.println("----------本类构造器-----------");
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for(Constructor c : declaredConstructors){
            System.out.println(c.getName());
        }
        //getPackage:以Package形式返回 包信息
        System.out.println("-----------getPackage-----------");
        Package aPackage = aClass.getPackage();
        System.out.println(aPackage);
        //getSuperclass:以Class形式返回父类信息
        System.out.println("----------getSuperclass-----------");
        Class<?> superclass = aClass.getSuperclass();
        System.out.println(superclass.getName());
        //getInterfaces:以Class[] 形式返回接口信息
        System.out.println("----------getInterfaces--------");
        Class<?>[] interfaces = aClass.getInterfaces();
        //getAnnotations:以Annotation[] 形式返回注解信息
        for (Class<?> anInterface : interfaces) {
            System.out.println(anInterface);
        }
        System.out.println("----------getAnnotations-----------");
        Annotation[] annotations = aClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
    }
    @Test
    public void api_02() throws ClassNotFoundException, NoSuchMethodException {
        //得到Class对象
        Class<?> aClass = Class.forName("com.hspedu.reflection.Person");
        //getDeclaredFields:获取本类中所有属性
        //1.getModifiers:以int形式返回修饰符，说明：默认修饰符是0，public是1，private是2，protected是4，
        // static是8，final是16，两个同时的话是相加
        //2.getType:以Class形式返回类型
        //3.getName:返回属性名
        System.out.println("---------本类属性---------");
        Field[] declaredFields = aClass.getDeclaredFields();
        for(Field f : declaredFields){
            System.out.println(f.getName() + "  该属性的修饰符值 = " + f.getModifiers()
            + "  该属性的类型 = " + f.getType());
        }
    }
    @Test
    public void api_03() throws ClassNotFoundException, NoSuchMethodException {
        //得到Class对象
        Class<?> aClass = Class.forName("com.hspedu.reflection.Person");
        //1.getModifiers:以int形式返回修饰符，说明：默认修饰符是0，public是1，private是2，protected是4，
        // static是8，final是16，两个同时的话是相加
        //2.getReturnType:以Class形式获取 返回类型
        //3.getName:返回方法名
        //4.getParameterTypes:以class[]返回参数类型数组
        System.out.println("----------本类方法----------");
        Method[] methods = aClass.getDeclaredMethods();
        for(Method method : methods){
            System.out.println(method.getName() + "  该方法的修饰符值 = " + method.getModifiers()
                    + "  该方法的返回类型 = " + method.getReturnType());
            Class<?>[] parameterTypes = method.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("该方法的形参类型" + parameterType);
            }
        }
    }
    @Test
    public void api_04() throws ClassNotFoundException, NoSuchMethodException {
        //得到Class对象
        //1.getModifiers:以int形式返回修饰符
        //2.getName:返回构造器名（全类名）
        //3.getParameterTypes:以class[]返回参数类型数组
        Class<?> aClass = Class.forName("com.hspedu.reflection.Person");
        System.out.println("----------本类构造器-----------");
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for(Constructor c : declaredConstructors){
            System.out.println(c.getName());
            Class[] parameterTypes = c.getParameterTypes();
            for (Class parameterType : parameterTypes) {
                System.out.println(parameterType);
            }
        }
    }
}
class A {
    public String hobby;
    public A(){}
    protected A(String hobby){
        this.hobby = hobby;
    }
    public void hi(){}
}
interface B{
    int i = 1;
}
interface C{
    int j = 1;
}
@Deprecated
class Person extends A implements B,C{
    public String name;
    protected int age;
    String job;
    private double sal;
    protected Person(){}
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void m1(){}
    protected void m2(){}
    void m3(){}
    private void m4(){}
}

通过反射创建对象

方式一：调用类中的public修饰的无参构造器
方式二：调用类中的指定构造器
Class类相关方法
- newInstance:调用类中的无参构造器，获取对应类的对象
- getConstructor (Class…clazz):根据参数列表，获取对应的public构造器对象
- getDecalaredConstructor (Class…clazz):根据参数列表，获取对应的构造器对象
Constructor类相关方法
- setAccessible:暴破
- newInstance(Object…obj):调用构造器

package com.hspedu.reflection;

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

public class ReflecCreateInstance {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //1.先获取到User类的Class对象
        Class<?> aClass = Class.forName("com.hspedu.reflection.User");
        //2.通过public的无参构造器创建实例
        Object o = aClass.newInstance();
        System.out.println(o);
        //3.通过public的有参构造器创建实例[先得到对应的构造器再创建对象并传入实参]
        Constructor<?> constructor = aClass.getConstructor(String.class);
        Object marry = constructor.newInstance("Marry");
        System.out.println(marry);
        //4.通过private的有参构造器创建实例【先得到私有的构造器，创建实例】
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(int.class, String.class);
        declaredConstructor.setAccessible(true);//暴破，使用反射可以访问private构造器，反射面前都是纸老虎
        Object jack = declaredConstructor.newInstance(18, "jack");
        System.out.println(jack);
    }
}
class User{
    private int age = 10;
    private String name = "刚刚";
    public User(){
    }
    private User(int age,String name){
        this.age = age;
        this.name = name;
    }
    public User(String name){
        this.name = name;
    }
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

通过反射访问类中的成员

访问属性

根据属性名获取Field对象--------Field f = class对象.getDeclaredField(属性名)；
暴破：f.setAccessible(true)；//f是Field
访问
- f.set(o,值)；
- syso(f.get(o));
如果是静态属性，则set和get中的参数o，可以写成null

package com.hspedu.reflection;

import java.lang.reflect.Field;

public class ReflectAccessProperty {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        //1.得到Student类对应的Class对象
        Class<?> aClass = Class.forName("com.hspedu.reflection.Student");
        //2.创建对象
        Object o = aClass.newInstance();//o的运行类型是Student
        System.out.println(o);
        //3.使用反射得到age属性对象
        Field age = aClass.getField("age");
        age.set(o,88);
        System.out.println(o);
        System.out.println(age.get(o));

        //4.使用反射操作name 属性
        Field name = aClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(null,"jack");//因为name是static属性，因此o也可以是null
        //name.set(o."jack");
        System.out.println(o);
        System.out.println(name.get(null));
        System.out.println(name.get(o));
    }
}
class Student{
    public int age;
    private static String name;
    public Student(){}

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

访问方法

根据方法名和参数列表获取Method方法对象：Method m = clazz.getDeclaredMethod(方法名，XX.class);
获取对象：Object o = clazz.newInstance();
暴破：m.setAccessible(true);
访问：Object returnValue = m.invoke(o,实参列表)；
注意：如果是静态方法，则invoke的参数o，可以写成null

package com.hspedu.reflection;

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

public class ReflectAccessMethod {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //1.得到Boss类对应的Class对象
        Class<?> aClass = Class.forName("com.hspedu.reflection.Boss");
        //2.创建对象
        Object o = aClass.newInstance();
        //3.调用public的hi方法
        Method hi = aClass.getDeclaredMethod("hi",String.class);
        //Method hi = aClass.getMethod("hi", String.class);
        hi.invoke(o,"xixiixixix");
        //4.调用private static 方法
        Method say = aClass.getDeclaredMethod("say", int.class, String.class, char.class);
        say.setAccessible(true);
        System.out.println(say.invoke(o,5,"hahaha",'A'));
        System.out.println(say.invoke(null,99,"yayaya",'B'));
        //5.在反射中，如果方法有返回值，统一返回Object,但是他的运行类型和方法定义的返回类型一致
        Object invoke = say.invoke(null, 300, "enenen", 'C');
        System.out.println(invoke);
    }
}
class Boss{
    public int age;
    private static String name;
    public Boss(){}
    private static String say(int n,String s,char c){
        return n + " " + s + " " + c;
    }
    public void hi(String s){
        System.out.println("hi " + s);
    }
}

(ง •_•)ง(ง •_•)ง

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java三阶(3)-反射

文章目录反射反射机制Class类基本介绍常用方法获取Class类对象哪些类型有Class对象类加载基本说明类加载时机通过反射获取类的结构信息通过反射创建对象通过反射访问类中的成员访问属性访问方法反射反射机制通过外部文件配置，在不修改源码情况下，来控制程序，也符合设计模式的oop原则（开闭原则）。package com.hspedu.reflection.question;import com.hspedu.Cat;import java.io.FileInputStream;impor
复制链接

扫一扫