Java反射

什么是反射

(1)Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息,从而操作类或对象的属性和方法。本质是JVM得到class对象之后,再通过class对象进行反编译,从而获取对象的各种信息。
(2)Java属于先编译再运行的语言,程序中对象的类型在编译期就确定下来了,而当程序在运行时可能需要动态加载某些类,这些类因为之前用不到,所以没有被加载到JVM。通过反射,可以在运行时动态地创建对象并调用其属性,不需要提前在编译期知道运行的对象是谁。
(3)反射机制允许程序在执行期借助于 Reflection API取得任何类的内部信息(比如成员变量,成员方法,构造器等等),并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。
(4)加载类完成之后,在堆中就产生了一个 Class类型的对象(一个类只有一个Class对象)这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以,形象的称之为:反射

反射机制

  • Java反射机制可以完成
    1.在运行时判断任意一个对象所属的类
    2.在运行时构造任意一个类的对象
    3.在运行时得到任意一个类锁具有的成员和方法
    4.在运行时调用任意一个对象的成员和方法
    5.生成动态代理

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

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

package com.hspedu.reflection;
import java.io.FileInputStream;
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;

/**
 * @author 山河与you皆无恙
 */

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

        //2.创建对象,传统的方法,行不通 =》反射机制
        //new classfullpath();

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

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

        Constructor constructor = cls.getConstructor();
        System.out.println(constructor);
        Constructor constructor2 = cls.getConstructor(String.class);//String.class就是String类的class对象

    }
}

获取Class类对象

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

package com.hspedu.reflection.class_;

import com.hspedu.Car;

/**
 * @author 山河与you皆无恙
 *演示得到class对象的各种方式
 */

public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class.forName
        String classAllPath = "com.hspedu.Car";//通过读取配置文件获取
        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 对象
        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.基本数据类型(byte int shot char float double long boolean)按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass);
        //6.基本数据类型对应包装类可以通过 .TYPE 得到 Class 类对象
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE;
        System.out.println(type1);
    }
}

哪些类型有Class对象

  • 如下类型有Clas对象
    1.外部类,成员内部类,静态内部类,局部内部类,匿名内部类
    2.interface:接口
    3.数组
    4.enum:枚举
    5.annotation:注解
    6.基本数据类型
    7.void

package com.hspedu.reflection.class_;

import java.io.Serializable;

/**
 * @author 山河与you皆无恙
 * 演示哪些类型有Class对象
 */

public class AllTypeClass {
    public static void main(String[] args) {
        Class<String> cls1= String.class;//外部类
        Class<Serializable> cls2 = Serializable.class;//接口
        Class<Integer[]> cls3 = Integer[].class;//数组
        Class<float[][]> cls4 = float[][].class;//二维数组
        Class<Deprecated> cls5 = Deprecated.class;//注解
        Class<Thread.State> cls6 = Thread.State.class;//枚举
        Class<Long> cls7 = Long.class;
        Class<Void> cls8 = void.class;
        Class<Class> cls9 = Class.class;
        System.out.println(cls1);
        System.out.println(cls2);
        System.out.println(cls3);
        System.out.println(cls4);
        System.out.println(cls5);
        System.out.println(cls7);
        System.out.println(cls8);
        System.out.println(cls9);

    }
}

类加载

  • 基本说明
    反射机制是java实现动态语言的关键,也就是通过反射实现类动态加载
    1.静态加载:编译时加载相关的类,如果没有则报错,依赖性太强
    2.动态加载:运行时加载需要的类,如果运行时不用该类,即使不存在该类,则不报错,降低了依赖性

  • 类加载时机
    1.当创建对象时(new)//静态加载
    2.当子类被加载时,父类也加载//静态加载
    3.调用类中的静态成员时//静态加载
    4.通过反射//动态加载


类加载流程图

Java反射


package com.hspedu.reflection.classLoad_;

/**
 * @author 山河与you皆无恙
 */

public class ClassLod03 {
    public static void main(String[] args) {
        //1.加载 B类,生成Class对象
        //2.链接 num = 0
        //3.初始化
        //依次自动收集类中所有静态变量的赋值动作和静态代码块中的语句,并合并
        /*
            clinit(){
             System.out.println("B 的静态代码块被执行");
             num = 30;
             num = 100;
            }
            合并:num = 100
         */

        new B();
        System.out.println(B.num);//100,如果直接使用类的静态属性,也会导致类的加载
    }
}
class B{
    static {
        System.out.println("B 的静态代码块被执行");
        num = 30;
    }
    static int num = 100;
    public B(){
        System.out.println("B 的构造方法被执行");
    }
}

获取类结构信息

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;

/**
 * @author 山河与you皆无恙
 * 获取类的结构信息
 */

public class ReflectionUtils {
    public static void main(String[] args)  {

    }
    @Test
    public void api_02() throws ClassNotFoundException {
        //得到Class对象
        Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
        //规定:说明:默认修饰符是 0,public是1,private是2,protected是4,static是8,final是16
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(" 本类中所有属性 "+declaredField.getName()+
                    " 本类中所有修饰符值 " +declaredField.getModifiers()+
                    " 该属性的类型 "+declaredField.getType());
        }
        //getDeclaredMethods:获取本类所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(" 获取本类所有方法 "+declaredMethod);
            System.out.println(" 本类中所有属性 "+declaredMethod.getName()+
                    " 本方法访问修饰符值 " +declaredMethod.getModifiers()+
                    " 该方法返回的类型 "+declaredMethod.getReturnType());
            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println(" 该方法的形参类型 "+parameterType);
            }
        }
        System.out.println("================================");
        //getDeclaredConstructors:获取本类所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("获取本类所有构造器"+declaredConstructor.getName());
            Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println(" 该构造器的形参类型 "+parameterType);
            }
        }
    }
    @Test
    public void api_01() throws ClassNotFoundException {
        //得到Class对象
        Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
        //getName:获取全类名
        System.out.println(personCls.getName());//com.hspedu.reflection.Person
        //getSimpleName:获取简单类名
        System.out.println(personCls.getSimpleName());//Person
        //getFields:获取所有public修饰的属性,包含本类以及父类的
        Field[] fields = personCls.getFields();
        for (Field field: fields) {
            System.out.println("本类以及父类的="+field.getName());
        }
        //getFields:获取本类所有属性
        Field[] declaredField = personCls.getDeclaredFields();
        for (Field field : declaredField) {
            System.out.println("获取本类所有属性="+field.getName());
        }
        //getMethods:获取所有public修饰的方法,包含本类及父类的
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
            System.out.println();
        }
        //getDeclaredMethods:获取本类所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("获取本类所有方法"+declaredMethod);
        }
        //getConstructors:获取本类以及父类的构造器
        Constructor<?>[] constructors = personCls.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("获取本类以及父类的构造器"+constructor.getName());
        }
        //getDeclaredConstructors:获取本类所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("获取本类所有构造器"+declaredConstructor.getName());
        }
        //getPackage:以Package形式返回 包信息
        System.out.println(personCls.getPackage());
        //getSuperclass:以Class形式返回父类信息
        Class<?> superclass = personCls.getSuperclass();
        System.out.println("父类的Class对象="+superclass);
        //getInterfaces:以Class[]返回接口信息
        Class<?>[] personClsInterfaces = personCls.getInterfaces();
        for (Class<?> personClsInterface : personClsInterfaces) {
            System.out.println("接口信息="+personClsInterface);
        }
        //getAnnotations:以Annotation[]返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息="+annotations);
        }
    }
}
class A{
    public String hobby;
}
 class  Person extends A{
    //属性
     public String name;
     protected int age;
     String job;
     private double sal;
     public Person(){}
     public Person(String name){}
     public void m1(){

     }
     protected void m2(){

     }
      void m3(){

     }
     private void m4(){

     }
 }

反射爆破创建实例

package com.hspedu.reflection;

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

/**
 * @author 山河与you皆无恙
 */

public class ReflectCreateInstance {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //1.先获取User类的Class对象
        Class<?> userClass = Class.forName("com.hspedu.reflection.User");
        //2.通过pubic的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
        //3.通过pubic的有参构造器创建实例
        //3.1先得到对应的构造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
        //3.2 创建实例并传入实参
        Object hsp = constructor.newInstance("韩顺平");
        System.out.println("hsp = "+hsp);
        //4.通过非pubic的有参构造器创建实例
        //4.1先得到私有的构造器对象
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class,String.class);
        //4.2 创建实例并传入实参
        constructor1.setAccessible(true);//爆破【包里破解】使用反射可以访问private构造器/方法/属性
        Object user2 = constructor1.newInstance(100"张三丰");
        System.out.println("user2 = "+user2);
    }
}
class User{
    private int age = 10;
    private String name = "韩顺平教育";
    public User(){}
    public User( String name){
        this.age = age;
        this.name = name;
    }
    private User(int age,String name){
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + ''' +
                '}';
    }
}

反射爆破操作属性

package com.hspedu.reflection;

import java.lang.reflect.Field;

/**
 * @author 山河与you皆无恙
 * 演示反射操作属性
 */

public class ReflectAccessProperty {
    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();
        //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
        System.out.println(o);
    }
}
class Student{
    public int age;
    private static String name;
    public Student(){

    }
   /* public Student(String name){
        this.name=name;
    }*/

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

反射爆破操作方法

package com.hspedu.reflection;

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

/**
 * @author 山河与you皆无恙
 * 演示反射操作方法
 */

public class ReflectAccessMethod {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, 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);
        //3.1得到hi方法对象
        Method hi = bossCls.getDeclaredMethod("hi",String.class);
        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
    }
}
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);
    }
}


我亦无他,唯他熟尔!


Java反射



原文始发于微信公众号(itmkyuan):Java反射

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由极客之音整理,本文链接:https://www.bmabk.com/index.php/post/39466.html

(0)
小半的头像小半

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!