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

    }
}

执行结果

 

posted @ 2019-04-02 18:05  Star灬木子李  阅读(190)  评论(0编辑  收藏  举报