栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【笔记】Java反射专题

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【笔记】Java反射专题

反射专题

链接:【韩顺平讲Java】Java反射专题

1. 引出反射

需求:

(1)根据配置文件re.properties指定信息,创建Cat对象并调用方法hi

classfullpath=com.qzy.Cat
method=hi

思考:使用现有技术能做到吗?

(2)这样的需求在学习框架时特别多,即通过外部文件配置,在不修改源码情况下,来控制程序,也符合设计模式的OCP原则(开闭原则:不修改源码,扩容功能)

解答:

(1)传统方法

new 对象 => 调用方法

Cat cat = new Cat();
cat.hi();

(2)使用文件流读取文件的方法

//1. 使用Properties类,可以读写配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("src\re.properties"));
String classfullpathName = properties.get("classfullpath").toString(); //"com.qzy.Cat
String methodName = properties.get("method").toString(); //"hi"
System.out.println("classfullpath=" + classfullpathName);
System.out.println("method=" + methodName);

//2. 创建对象,类似Cat cat1 = new com.qzy.Cat();
Cat cat1 = new classfullpathName() //报错,Cannot resolve symbol 'classfullpathName'

classfullpathName是一个字符串而非类,无法创建对象。

所以该方法不可行。

(3)使用反射机制

//(1)加载类,返回Class类型的对象cls
Class cls = Class.forName(classfullpathName);
//(2)通过cls得到你加载的类 com.qzy.Cat的对象实例
Object o = cls.newInstance();
System.out.println("o的运行类型=" + o.getClass()); //o的运行类型=class com.qzy.Cat
//(3)通过cls得到你加载的类com.qzy.Cat的methodName “hi” 的方法对象
//     即:在反射中,可以吧方法视为对象(万物皆对象)
Method method = cls.getMethod(methodName);
method.invoke(o); // 传统方法: 对象.方法(), 反射机制: 方法.invoke(对象)
2. 反射原理 2.1 原理图

2.2 反射相关类
  1. java.lang.Class:: 代表一个类,Class对象表示某个类加载后再堆中的对象
  2. java.lang.reflect.Method: 代表类的方法,Method对象表示某个类的方法
  3. java.lang.reflect.Field: 代表类的成员变量,Field对象表示某个类的成员变量
  4. java.lang.reflect.Constructor: 代表类的构造方法,Constructor对象表示构造器

这些类在java.lang.reflection

public class Reflection01 {
    public static void main(String[] args) throws Exception {
        //1. 使用Properties类,可以读写配置文件
        Properties properties = new Properties();
        properties.load(new FileInputStream("src\re.properties"));
        String classfullpathName = properties.get("classfullpath").toString(); //"com.qzy.Cat
        String methodName = properties.get("method").toString(); //"hi"
        System.out.println("classfullpath=" + classfullpathName);
        System.out.println("method=" + methodName);

        //2. 使用反射机制解决
        //(1)加载类,返回Class类型的对象cls
        Class cls = Class.forName(classfullpathName);
        //(2)通过cls得到你加载的类 com.qzy.Cat的对象实例
        Object o = cls.newInstance();
        System.out.println("o的运行类型=" + o.getClass()); //o的运行类型=class com.qzy.Cat
        //(3)通过cls得到你加载的类com.qzy.Cat的methodName “hi” 的方法对象
        //     即:在反射中,可以吧方法视为对象(万物皆对象)
        Method method = cls.getMethod(methodName);
        method.invoke(o); // 传统方法: 对象.方法(), 反射机制: 方法.invoke(对象)

        //java.lang.reflect.Field: 代表类的成员变量,Field对象表示某个类的成员变量
        //得到name字段
        //getField不能得到私有的属性private
        Field ageField = cls.getField("age");
        System.out.println(ageField.get(o)); //传统写法:对象.成员变量,反射:成员变量对象.get(对象实例) //输出10

        //java.lang.reflect.Constructor: 代表类的构造方法,Constructor对象表示构造器
        Constructor constructor = cls.getConstructor(); //()可以指定构造器参数类型,返回午餐构造器
        System.out.println(constructor); // public com.qzy.Cat()

        Constructor constructor1 = cls.getConstructor(String.class); //这里传入的String.class就是String类的Class对象
        System.out.println(constructor1); // public com.qzy.Cat(java.lang.String)
    }
}
3. 反射调用优化

反射优点:可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制,框架技术就失去底层支撑。
反射缺点:使用反射基本是解释执行,对执行速度有影响。 —>如何优化?

优化方法:

  • 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 < 100000000; i++) {
            cat.test();
        }
        long end = System.currentTimeMillis();
        System.out.println("传统方法消耗时间:"+ (end-start));
    }
    public static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class cls = Class.forName("com.qzy.Cat");
        Object o = cls.newInstance();
        Method method = cls.getMethod("test");
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            method.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("反射调用(未优化)消耗时间:"+ (end-start));
    }
    public static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        Class cls = Class.forName("com.qzy.Cat");
        Object o = cls.newInstance();
        Method method = cls.getMethod("test");
        method.setAccessible(true);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            method.invoke(o);
        }
        long end = System.currentTimeMillis();
        System.out.println("反射调用(优化)消耗时间:"+ (end-start));
    }
}

运行结果:

传统方法消耗时间:5
反射调用(未优化)消耗时间:185
反射调用(优化)消耗时间:129
4. Class类分析

(1)Class也是类,因此也继承Object类

(2)Class类对象不是new出来的,而是系统创建的

(3)对于某个类的Class类对象,在内存中只有一份,因为类只加载一次

(4)每个类的实例都会记得自己是由哪个Class 实例所生成

(5)通过Class对象可以完整地得到一个类的完整结构,通过一系列API

(6)Class对象是存放在堆的

(7)类的字节码二进制数据,是放在方法区的,有的地方称为类的元数据(包括方法代码,变量名,方法名,访问权限等等(参考:java虚拟机Class对象是放在方法区还是堆中 ?)

5. Class常用方法
public class Class02 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        String classAllPath = "com.qzy.Car";

        //1. 获取到Car类对应的Class对象
        // 表示不确定的Java类型
        Class cls = Class.forName(classAllPath);
        //2. 输出cls
        System.out.println(cls); //显示cls对象,是哪个类的Class对象  class com.qzy.Car
        System.out.println(cls.getClass()); //输出cls运行类型  class java.lang.Class
        //3. 得到包名
        System.out.println(cls.getPackage().getName()); //com.qzy
        //4. 得到全类名
        System.out.println(cls.getName()); //com.qzy.Car
        //5. 通过cls创建对象实例
        //Object o = cls.newInstance();
        Car car = (Car)cls.newInstance();
        System.out.println(car); //Car{brand='宝马', price=100000, color='白色'}
        //6. 通过反射获取属性 brand
        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());
        }
        //brand
        //price
        //color
    }
}
6. 获取Class对象的方法(6种)
  • 前提:已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException,实例:Class cls1 =Class.forName( "java.lang.Cat”);
    应用场景:多用于配置文件,读取类全路径,加载类。

  • 前提:若已知具体的类,通过类的class 获取,该方式最为安全可靠,程序性能最高实例:Class cls2 = Cat.class;
    应用场景:多用于参数传递,比如通过反射得到对应构造器对象。

  • 前提:已知某个类的实例,调用该实例的getClass()方法获取Class对象,实例:Class clazz =对象.getClass(0);
    应用场景:通过创建好的对象,获取Class对象。

  • 其他方式
    ClassLoader cl =对象.getClass().getClassLoader);

    Class clazz4 = cl.loadClass(“类的全类名”);

  • 基本数据(int, char,boolean,float,double,byte,long,short)按如下方式得到Class类对象

    Class cls =基本数据类型.class

  • 基本数据类型对应的包装类,可以通过.type得到Class类对象

    Class cls =包装类.TYPE

public class Class03 {
    public static void main(String[] args) throws ClassNotFoundException {
        String classAllPath = "com.qzy.Car";
        //1. Class.forName
        Class cls1 = Class.forName(classAllPath);
        System.out.println(cls1);
        //2. 类名.class,应用场景:用于参数传递
        Class cls2 = Car.class;
        System.out.println(cls2);
        //3. 对象.getClass(), 应用场景:有对象实例
        Car car = new Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);
        //4. 通过类加载器【4种】来获取到类的Class对象
        //(1)先得到类加载器car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        classLoader.loadClass(classAllPath);
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(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 integerClass = int.class;
        Class characterClass = char.class;
        Class booleanClass = boolean.class;
        System.out.println(integerClass); //int

        //6. 基本数据类型对于的包装类,可以通过.TYPE得到Class类对象
        Class type1 = Integer.TYPE;
        Class type2 = Character.TYPE; //其他包装类BOOLEAN, DOUBLE, LONG, BYTE等等
        System.out.println(type1); //int

        System.out.println(integerClass.hashCode()); //1163157884
        System.out.println(type1.hashCode()); //1163157884
    }
}
7. 哪些类型可以有Class对象
  • class:外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类
  • interface:接口
  • []:数组
  • enum:枚举
  • annotation:注解@interface
  • primitive type:基本数据类型
  • void
public class Class04 {
    public static void main(String[] args) {
        Class c1 = Object.class; //类  class java.lang.Object
        Class c2 = Comparable.class; //接口  interface java.lang.Comparable
        Class c3 = String[].class; //一位数组  class [Ljava.lang.String;
        Class c4 = int[][].class; //二维数组  class [[I
        Class c5 = Override.class; //注解  interface java.lang.Override
        Class c6 = ElementType.class; //枚举  class java.lang.annotation.ElementType
        Class c7 = Integer.class; //基本数据类型  class java.lang.Integer
        Class c8 = void.class; //void  void
        Class c9 = Class.class; //Class  class java.lang.Class

        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);
    }
}

8. 类加载 8.1 静态加载和动态加载

反射机制是java实现动态语言的关键,也就是通过反射实现类动态加载。

  • 静态加载:编译时加载相关的类,如果没有则报错,依赖性太强

  • 动态加载:运行时加载需要的类,如果运行时不用该类,即使不存在该类,则不报错,降低了依赖性

类加载时机:

当创建对象时(new) //静态加载

当子类被加载时,父类也加载 //静态加载

调用类中的静态成员时 //静态加载

通过反射 //动态加载

8.2 类加载流程图

9. 获取类结构信息 9.1 java.lang.Class类
  1. getName:获取全类名
  2. getSimpleName:获取简单类名
  3. getFields:获取所有public修饰的属性,包含本类以及父类的
  4. getDeclaredFields:获取本类中所有属性
  5. getMethods:获取所有public修饰的方法,包含本类以及父类的
  6. getDeclaredMethod:获取本类中所有方法
  7. getConstructors:获取本类所有public修饰的构造器
  8. getDeclaredConstructors:获取本类中所有构造器
  9. getPackage:以Package形式返回包信息
  10. getSuperClass:以Class形式返回父类信息
  11. getInterfaces:以Class[]形式返回接口信息
  12. getAnnotations:以Annotation[]形式返回注解信息
9.2 java.lang.reflect.Field类
  1. getModifiers: 以int形式返回修饰符
    [说明:默认修饰符是0,public 是1,private是2,protected是4static是8,final是16]

    public(1) + static (8) = 9

  2. getType:以Class形式返回类型

  3. getName:返回属性名

9.3 java.lang.reflect.Method类
  1. getModifiers:以int形式返回修饰符

[ 说明:默认修饰符是0,public是1,private是2,protected是4,static是8,final是16 ]

  1. getReturnType:以Class形式获取返回类型

  2. getName:返回方法名

  3. getParameterTypes:以Class[]返回参数类型数组

9.4 java.lang.reflect.Constructor类
  1. getModifiers:以int形式返回修饰符
  2. getName:返回构造器名(全类名)
  3. getParameterTypes:以Class[]返回参数类型数组
10. 通过反射创建对象
  1. 调用类中的public修饰的无参构造器

  2. 调用类中的指定构造器

  3. Class相关方法

    newInstance: 调用类中的无参构造器,获取对应类的对象

    getConstructor(Class…clazz):根据参数列表,获取对应的public构造器对象

    getDecalaredConstructor(Class…clazz):根据参数列表,获取对应的所有构造器对象

  4. Constructor类相关方法

    setAccessible:暴破

    newInstance(Object…obj):调用构造器

public class ReflecCreateInstance {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //1. 先获取到User类的Class对象
        Class cls = Class.forName("com.qzy.reflection.reflectClass.User");
        //2. 通过public的无参构造器创建实例
        Object o = cls.newInstance();
        System.out.println(o); //User [age=20, name=清蒸鱼]
        //3. 通过public的有参构造器创建实例
        
        //3.1 先得到对用构造器
        Constructor constructor = cls.getConstructor(String.class);
        //3.2 创建实例,并传入实参
        Object qzy = constructor.newInstance("qzy");
        System.out.println(qzy); //User [age=20, name=qzy]
        //4. 通过非public的有参构造器创建实例
        Constructor declaredConstructor = cls.getDeclaredConstructor(int.class, String.class);
        //暴破,使用反射可以访问private构造器
        declaredConstructor.setAccessible(true);
        Object gl = declaredConstructor.newInstance(99, "小海");
        System.out.println(gl); //User [age=99, name=小海]
    }
}

class User {
    private int age=20;
    private String name="清蒸鱼";

    public User() {} //public无参构造器

    public User(String name) {
        this.name = name;
    } //public有参构造器

    private User(int age, String name) { //private有参构造器
        this.age = age;
        this.name = name;
    }
    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}
11. 通过反射访问类中的成员 11.1 访问属性
  1. 根据属性名获取Field对象

    Field f = clazz对象.getDeclaredField(属性名)

  2. 暴破: f.setAccessible(true) //f是Field

  3. 访问

    f.set(o, 值);//o表示对象

    syso(f.get(o))

  4. 如果是静态属性,则set和get中的参数o,可以写成null

public class Class05 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {
        Class cls = Class.forName("com.qzy.reflection.reflectClass.Student");
        Object o = cls.newInstance();

        //1. 通过反射得到age属性对象
        Field age = cls.getField("age");
        //通过反射操作age属性
        age.set(o, 99);
        System.out.println(o); //Student [age=99, name=null]
        System.out.println(age.get(o)); //99

        //2. 通过反射得到name属性
        Field name = cls.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o, "小海");
        //因为name是static,所以o也可以设置为null
        //name.set(null, "小海");
        System.out.println(name.get(o)); //小海
        System.out.println(name.get(null));//小海
    }
}

class Student {
    public int age;
    private static String name;
    public Student() {}
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }
}
11.2 访问方法
  1. 根据方法名和参数列表获取Method方法对象:Method m = clazz.getDeclaredMethod(方法名,XX.class);
  2. 获取对象:Object o=clazz.newlnstance();
  3. 暴破:m.setAccessible(true);
  4. 访问:Object returnValue = m.invoke(o,实参列表);
  5. 注意:如果是静态方法,则invoke的参数o,可以写成null!
public class Class06 {
    public static void main(String[] args) throws Exception {
        Class cls = Class.forName("com.qzy.reflection.reflectClass.Boss");
        Object o = cls.newInstance();
        //1. 通过反射获取hi方法
        Method hi = cls.getMethod("hi", String.class);
        hi.invoke(o, "小海"); //hi 小海

        //2. 调用private static 方法
        Method say = cls.getDeclaredMethod("say", int.class, String.class, char.class);
        say.setAccessible(true);
        System.out.println(say.invoke(o, 99, "小海", '男')); //99 小海 男

        //反射中,如果方法有返回值,统一返回Object,但是他运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 100, "小海", '男');
        System.out.println(reVal); //100 小海 男
        System.out.println("reVal的运行类型=" + reVal.getClass()); //reVal的运行类型=class java.lang.String
    }
}

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);
    }
}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/985073.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号