Java反射机制

一、什么是反射？

在运行状态中，对于任意一个类，都能够获取到这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性（包括私有），这种动态获取的信息，及调用对象的方法的功能就称为Java的反射机制。

二、获取类对象

1、什么是类对象？

　　创建Dog类和Cat类

public class Dog {
    private String name;
    private int age;
    public Dog() {

    }
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }    
    /*getter and setter*/
}

public class Cat {
    private String name;
    private String hobby;
    /*getter and setter*/
}

　　实例化两个Dog类的对象

Dog dog1 = new Dog("大黄", 5);
Dog dog2 = new Dog("小黑", 3);

在理解类对象之前，先说我们熟悉的对象之间的区别：

       dog1和dog2都是Dog对象，他们的区别在于，各自有不同的名称、年龄。

然后说说类之间的区别

　　Dog和Cat都是类，他们的区别在于有不同的方法，不同的属性。

类对象，就是描述一个类都有什么属性，什么方法的。所有的类，都存在一个类对象，这个类对象用于提供类本身的信息.

2、获取类对象的三种方式

　　　1. Class.forName
　　　2. Dog.class
　　　3. new Dog().getClass()

  try {
            Class class1 = Class.forName("yingshe.Dog");
            System.out.println(class1);
            Class class2 = Dog.class;
            System.out.println(class2);
            Class class3 = new Dog().getClass();
            System.out.println(class3);

            System.out.println(class1 == class2);
            System.out.println(class1 == class3);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

执行结果

　　在一个JVM中，一种类，只会有一个类对象存在。所以以上三种方式取出来的类对象，都是一样的。

3、获取类对象的时候会导致类属性被初始化

　　Dog类加上代码

static String msg;

    static {
        System.out.println("初始化msg");
        msg="被初始化了";
    }

　　获取类对象

　　无论什么途径获取类对象，都会导致静态属性被初始化，而且只会执行一次。（除了直接使用 Class c = Hero.class 这种方式，这种方式不会导致静态属性被初始化）

 

三、创建对象

　　与传统的通过new 来获取对象的方式不同，反射机制，会先拿到Hero的“类对象”,然后通过类对象直接创建对象或获取“构造器对象” ，再通过构造器对象创建一个对象

　　 T newInstance()
　　　　创建由此 类对象表示的类的新实例。

　　Constructor getConstructor()
　　　　返回一个 Constructor对象

import java.lang.reflect.Constructor;

public class Test2 {
    public static void main(String[] args) {
        //获取类对象
        Class classDog = Dog.class;
        try {
            //用类对象直接创建
            Dog dog1 = (Dog)classDog.newInstance();
            dog1.setName("大黄");
            dog1.setAge(5);
            System.out.println(dog1);

            //获取构造器再创建
            //构造器
            Constructor constructor = classDog.getConstructor();
            //通过构造器实例化
            Dog dog2 = (Dog) constructor.newInstance();
            dog2.setName("小黑");
            dog2.setAge(4);
            System.out.println(dog2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

四、访问属性

 为了访问属性，将name修改为public属性

对于private修饰的成员，需要使用setAccessible(true)才能访问和修改。

通过反射修改属性值

import java.lang.reflect.Field;

public class Test3 {
    public static void main(String[] args){
        Dog dog =new Dog();
        //使用传统方式修改name的值为大黄
        dog.name = "大黄";
        System.out.println(dog.name);
        try {
            //获取类Dog的名字叫做name的字段
            Field f1= dog.getClass().getDeclaredField("name");
            //修改这个字段的值
            f1.set(dog, "小黑");
            //打印被修改后的值
            System.out.println(dog.name);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

五、部分函数

1、Field[] getFields()
　　返回包含一个数组 Field对象反射由此表示的类或接口的所有可访问的公共字段、类对象。
2、Field[] getDeclaredFields()
　　动态的返回的数组 Field对象反映此表示的类或接口声明的所有字段 类对象

增加Dog属性

public class Dog {
    public String name;  //public
    private int age;  private
    String health;   //默认
    protected int weigth;  //protected
    //其他函数
}

import java.lang.reflect.Field;

public class Test4 {
    public static void main(String[] args){
        Class classDog=Dog.class;
        Field[] fields1 = classDog.getFields();
        System.out.println("类的public属性");
        for (Field f : fields1){
            System.out.println(f.getName());
        }
        Field[] fields2 = classDog.getDeclaredFields();
        System.out.println("类的所有属性");
        for (Field f : fields2){
            System.out.println(f.getName());
        }
    }
}

执行结果

3、Method[] getMethods()

　　返回包含一个数组 方法对象反射由此表示的类或接口的所有公共方法 类对象，包括那些由类或接口和那些从超类和超接口继承的声明。
4、Method[] getDeclaredMethods()
　　返回包含一个数组 方法对象反射的类或接口的所有声明的方法，通过此表示 类对象，包括公共，保护，默认（包）访问和私有方法，但不包括继承的方法。

5、Object invoke(Object obj, Object… args)
　　在具有指定参数的 方法对象上调用此 方法对象表示的底层方法

例如：取得setName方法映射给method，method调用invoke函数第一个对象为操作对象，第二个参数为参数(可以是数组)

import java.lang.reflect.Method;

public class Test5 {
    public static void main(String[] args) {
        Class classDog = Dog.class;
        try {
            Dog dog = (Dog) classDog.newInstance();
            Method method = classDog.getMethod("setName", String.class);
            method.invoke(dog, "名字");
            System.out.println(dog.name);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

六、反射有什么用？

1、首先准备两个业务类，这两个业务类很简单，就是各自都有一个业务方法，分别打印不同的字符串

package reflection; 
public class Service1 { 
    public void doService1(){
        System.out.println("业务方法1");
    }
}

package reflection; 
public class Service2 { 
    public void doService2(){
        System.out.println("业务方法2");
    }
}

2、非反射方式

当需要从第一个业务方法切换到第二个业务方法的时候，使用非反射方式，必须修改代码，并且重新编译运行，才可以达到效果

package reflection; 
public class Test { 
    public static void main(String[] args) {
//      new Service1().doService1();
        new Service2().doService2();
    }
}

3、反射方式

使用反射方式，首先准备一个配置文件，就叫做spring.txt吧, 放在src目录下。 里面存放的是类的名称，和要调用的方法名。
在测试类Test中，首先取出类名称和方法名，然后通过反射去调用这个方法。
当需要从调用第一个业务方法，切换到调用第二个业务方法的时候，不需要修改一行代码，也不需要重新编译，只需要修改配置文件spring.txt，再运行即可。
这也是Spring框架的最基本的原理，只是它做的更丰富，安全，健壮。

spring.txt

class=yingshe.Service1
method=doService1

TestF.java

import java.io.File;
import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;

public class TestF {

    @SuppressWarnings({"rawtypes", "unchecked"})
    public static void main(String[] args) throws Exception {

        //从spring.txt中获取类名称和方法名称
        File springConfigFile = new File("g:\\spring.txt");
        Properties springConfig = new Properties();
        springConfig.load(new FileInputStream(springConfigFile));
        String className = (String) springConfig.get("class");
        String methodName = (String) springConfig.get("method");

        //根据类名称获取类对象
        Class clazz = Class.forName(className);
        //根据方法名称，获取方法对象
        Method m = clazz.getMethod(methodName);
        //获取构造器
        Constructor c = clazz.getConstructor();
        //根据构造器，实例化出对象
        Object service = c.newInstance();
        //调用对象的指定方法
        m.invoke(service);

    }
}

执行结果

 

转载于:https://www.cnblogs.com/GG-Bond/p/10644278.html