java反射

反射概述

Java 反射，就是在运行状态中。

所以说什么是反射？

反射就是在运行时才知道要操作的类是什么，并且可以在运行时获取类的完整构造，并调用对应的方法。

java反射机制提供了以下几个功能

在运行时判断任意一个对象所属的类；

在运行时构造任意一个类的对象；

在运行时判断任意一个类所具有的成员变量和方法；

在运行时调用任意一个对象的方法。

反射涉及到四个核心类

java.lang.Class.java：类对象；

java.lang.reflect.Constructor.java：类的构造器对象；

java.lang.reflect.Method.java：类的方法对象；

java.lang.reflect.Field.java：类的属性对象；

2.2、反射有什么用，应用场景？

• 操作因访问权限限制的属性和方法；
• 实现自定义注解；
• 动态加载第三方jar包，解决android开发中方法数不能超过65536个的问题；
• 按需加载类，节省编译和初始化APK的时间；

 反射的应用场合

o 在编译时根本无法知道该对象或类可能属于哪些类，程序只依靠运行时信息来发现该对象和类的真实信息

o 比如log4j，Servlet、SSM框架技术都用到了反射

比如：log4j   log4j.appender.stdout=org.apache.log4j.ConsoleAppender   log4j.appender.logfile.layout=org.apache.log4j.PatternLayout  比如：Servlet          HelloServlet        com.bjsxt.servlet.HelloServlet     比如 SSM     class="org..jdbc.datasource.DataSourceTransactionManager">

· 反射的作用

o 动态创建对象

o 动态操作属性

o 动态调用方法

o 动态操作泛型和注解

· 在JDK中，主要由以下类来实现Java反射机制，都位于java.lang.reflect包中

o Class类：代表一个类

o Constructor 类：代表类的构造方法

o Field 类：代表类的成员变量(属性)

o Method类：代表类的成员方法

2.3、反射工作原理

当我们编写完一个Java项目之后，每个java文件都会被编译成一个.class文件，这些Class对象承载了这个类的所有信息，包括父类、接口、构造函数、方法、属性等，这些class文件在程序运行时会被ClassLoader加载到虚拟机中。当一个类被加载以后，Java虚拟机就会在内存中自动产生一个Class对象。我们通过new的形式创建对象实际上就是通过这些Class来创建，只是这个过程对于我们是不透明的而已。

反射的工作原理就是借助Class.java、Constructor.java、Method.java、Field.java这四个类在程序运行时动态访问和修改任何类的行为和状态。

2.4、射的入口—Class类

• Class类是Java 反射机制的起源和入口

• 用于获取与类相关的各种信息

• 提供了获取类信息的相关方法

• Class类继承自Object类 

• Class类是所有类的共同的图纸

• 每个类有自己的对象，好比图纸和实物的关系

• 每个类也可看做是一个对象，有共同的图纸Class，存放类的结构信息，比如类的名字、属性、方法、构造方法、父类和接口，能够通过相应方法取出相应信息

• Class类的对象称为类对象。

【示例2】认识Class类

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

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

    public void show(){
        System.out.println("你好，我是一个人");
    }

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

public class ReflectionTest {
    //在反射之前，对于Person的操作
    @Test
    public void test1(){
        //1,创建Person类的对象
        Person p = new Person("Tom",12);

        //2,通过对象，调用其内部的属性，方法
        p.age = 10;
        System.out.println(p.toString());

        p.show();
        //在Person类外部，不可以通过Person类的对象调用其内部私有结构。
        //比如：name，showNation()以及私有的构造器
    }

    //反射之后，对于Person的操作
    @Test
    public void test2() throws Exception{
        Class clazz  = Person.class;
        //1，通过反射，创建Person类的对象
        Constructor cons = clazz.getConstructor(String.class, int.class);  //调用构造器
        Object obj = cons.newInstance("Tom", 12);
        Person p = (Person)obj;  //强转
        System.out.println(p.toString());
        //2，通过反射，调用对象指定的属性  方法
        //调用属性
        Field age = clazz.getDeclaredField("age");
        age.set(p,10);
        System.out.println(p.toString());
        //调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);

        System.out.println("*********************************************");
        //通过反射，可以调用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,"冯宝宝");
        System.out.println(p1);

        //调用私有的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        //invoke():调用的意思
        Object invoke = showNation.invoke(p1, "中国");//相当于p1.showNation("中国")
        System.out.println(invoke);

        //通过直接new  的方式或反射的方式都可以调用公共的结构，开发中用那个？
        //建议:  直接new的方式
        //什么时候用：反射的方式。反射的特性：动态性
    }
}

总结：

通过直接new 的方式或反射的方式都可以调用公共的结构，开发中用那个？建议: 直接new的方式什么时候用：反射的方式。反射的特性：动态性

反射则是一开始并不知道我要初始化的类对象是什么，自然也无法使用 new 关键字来创建对象了。