黑马程序员_92_反射

　——- android培训、java培训、期待与您交流！ ———-

概述

JAVA反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象方法的功能称为java语言的反射机制。

动态获取类中信息，就是java反射。可以理解为对类的解剖。

如果想要对指定名称的字节码文件进行加载并获取其中的内容并调用，这时就使用到了反射技术。

所谓的框架就是对外提供一些接口，也就是功能扩展的标准，由实现类按照这个接口标准去实现。框架内部如果需要操纵这些实现类的对象完成某些操作，那么只需要把这些实现类的全名（包名+类名）写在某个配置文件中，框架代码只需要读取这个配置文件，就可以获取这个实现类的字节码文件，然后利用反射技术创建这个实现类的对象并且调用相应的方法完成一些操作。

用于描述字节码的类就是Class类，创建对象，可以提取字节码文件中的内容，如字段、构造函数、一般函数。
该类就可以获取字节码文件中的所有内容，那么反射就是依靠该类完成的。想要对一个类文件进行解剖，只要获取到该类的字节码文件对象即可。

演示

示例
获取字节码文件对象的3种方式
Person.java

public class Person
{
        private int age;
        private String name;

    public Person(int age,String name){
                super();
                this.age = age;
                this.name = name;

                System.out.println("Person param run..." + this.name + ":" + this.age);
        }

        public Person(){
                super();

                System.out.println("person run");
        }

        public void show(){
                System.out.println(name + "...show run..." + age);
        }

        private void privateMethod(){
                System.out.println("method run");
        }

        public void paramMethod(String str,int num){
                System.out.println("paramMethod run..." + str + ":" + num);
        }

        public static void staticMethod(){
                System.out.println("static method run...");
        }
}

ReflectDemo.java

import cn.itcast.bean.Person;

//要想要对字节码文件进行解剖，必须要有字节码文件对象。
public class ReflectDemo
{
        public static void main(String[] args) throws ClassNotFoundException {
                getClassObject_1();
                System.out.println("--------------------");
                getClassObject_2();
                System.out.println("--------------------");
                getClassObject_3();
        }

   /*
        * 获取字节码对象的方式：
        * 方式一：Object类中的getClass()方法的。
        * 想要用这种方式，必须要明确具体的类，并创建对象。
        * 麻烦。
        */
        public static void getClassObject_1(){

                Person p = new Person();
                Class clazz = p.getClass();

                Person p1 = new Person();
                Class clazz1 = p1.getClass();

                System.out.println(clazz == clazz1);
        }

        /*
        * 方式二：任何数据类型都具备一个静态的属性.class来获取其对应的Class对象。
        * 相对简单，但是还是要明确用到类中的静态成员。
        * 还是不够扩展。
        */
        public static void getClassObject_2(){

                Class clazz = Person.class;
                Class clazz1 = Person.class;

                System.out.println(clazz == clazz1);
        }

        /*
        * 方式三：只要通过给定的类的字符串名称就可以获取该类，更为扩展。
        * 可以用Class类中的方法完成。
        * 该方法就是forName。
        * 这种方法只要有名称即可，更为方便，扩展性更强。
        */
        public static void getClassObject_3() throws ClassNotFoundException {

                //可以把类的字符串名称写到配置文件中，然后读取出来。
                String className = "cn.itcast.bean.Person";
                Class clazz = Class.forName(className);

                System.out.println(clazz);
        }
}

运行结果图

示例2
获取Class中的构造函数

import cn.itcast.bean.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ReflectDemo
{
        public static void main(String[] args) throws Exception {
                createNewObject_1();
                System.out.println("--------------------");
                createNewObject_2();
        }

        public static void createNewObject_1() throws ClassNotFoundException,InstantiationException,IllegalAccessException {
                //早期：new时候，先根据被new的类的名称找寻该类的字节码文件，并加载进内存，
                //并创建该字节码文件对象，并接着创建该字节文件的对应的Person对象。
                //Person p = new Person();

                //现在：
                String name = "cn.itcast.bean.Person";
                //找寻该文件类文件，并加载进内存，并产生Class对象。
                Class clazz = Class.forName(name);
                //如何产生该类的对象呢？
                Object obj = clazz.newInstance();//调用Person的空参构造函数
        }

        public static void createNewObject_2() throws ClassNotFoundException,InstantiationException,NoSuchMethodException,IllegalAccessException,InvocationTargetException {

                //Person p = new Person("小强",39);

                /*
                * 当获取指定名称对应类中的所体现的对象时。
                * 而该对象初始化不使用空参数构造函数该怎么办呢？
                * 既然是通过指定的构造函数进行对象的初始化。
                * 所以应该先获取到该构造函数，通过字节码文件对象即可完成。
                * 该方法是：getConstructor(parameterTypes);
                */

                String name = "cn.itcast.bean.Person";
                //找寻该名称类文件，并加载进内存，并产生Class对象。
                Class clazz = Class.forName(name);
                //获取到了指定的构造函数对象
                Constructor constructor = clazz.getConstructor(int.class,String.class);
                //通过该构造器对象的newInstance方法进行对象的初始化。
                Object obj = constructor.newInstance(38,"小明");
        }
}

运行结果图

示例3
获取Class的字段

import cn.itcast.bean.Person;
import java.lang.reflect.Field;

public class ReflectDemo
{
        public static void main(String[] args) throws Exception {
                getFieldDemo();
        }

        /*
        * 获取字节码文件中的字段。
        */
        public static void getFieldDemo() throws Exception {

                Class clazz = Class.forName("cn.itcast.bean.Person");

                //getField只能获取所有可访问公共字段，private获取不到。
                //Field field = claszz.getField("age");

                //getDeclaredField可以获取到公共字段，也可以获取到私有字段。
                Field field = clazz.getDeclaredField("age");

                //对私有字段的访问取消权限检查，暴力访问。
                field.setAccessible(true);

                Object obj = clazz.newInstance();

                //为对象的属性赋值
                field.set(obj,89);

                //获取某对象的某属性值
                Object o = field.get(obj);

                System.out.println(field);
        }
}

运行结果图

示例4
获取Class中的方法

import cn.itcast.bean.Person;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;

public class ReflectDemo
{
        public static void main(String[] args) throws Exception {
                getMethodDemo_1();
                System.out.println("---------------------------");
                getMethodDemo_2();
                System.out.println("---------------------------");
                getMethodDemo_3();
        }

        /*
        * 获取指定Class中的公共函数。
        */
        public static void getMethodDemo_1() throws Exception {

                Class clazz = Class.forName("cn.itcast.bean.Person");

                Method[] methods = clazz.getMethods();//获取的都是公有的方法

                methods = clazz.getDeclaredMethods();//只获取本类中所有方法，包括私有。

                for(Method method : methods){
                        System.out.println(method);
                }
        }

        public static void getMethodDemo_2() throws Exception {

                Class clazz = Class.forName("cn.itcast.bean.Person");

                Method method = clazz.getMethod("show",null);//获取空参数一般方法

                Object obj = clazz.newInstance();

                Constructor constructor = clazz.getConstructor(int.class,String.class);
                obj = constructor.newInstance(37,"小明");

                method.invoke(obj,null);
        }

        public static void getMethodDemo_3() throws Exception {

                Class clazz = Class.forName("cn.itcast.bean.Person");

                Method method = clazz.getMethod("paramMethod",String.class,int.class);//获取空参数一般方法

                Object obj = clazz.newInstance();

                Constructor constructor = clazz.getConstructor();
                obj = constructor.newInstance();

                method.invoke(obj,"小强",89);
        }
}

运行结果图

练习

PCI.java

package cn.itcast.reflect.test;

public interface PCI
{
        public void open();
        public void close();
}

SoundCard.java

package cn.itcast.reflect.test;

public class SoundCard implements PCI
{
        public void open(){
                System.out.println("sound open");
        }

        public void close(){
                System.out.println("sound close");
        }
}

NetCard.java

package cn.itcast.reflect.test;

public class NetCard implements PCI
{
        public void open(){
                System.out.println("net open");
        }

        public void close(){
                System.out.println("net close");
        }
}

Mainboard.java

package cn.itcast.reflect.test;

public class Mainboard
{
        public void run(){
                System.out.println("main board run...");
        }

        public void usePCI(PCI p){
                if(p != null){
                        p.open();
                        p.close();
                }
        }
}

pci.Properties

pci1=cn.itcast.reflect.test.SoundCard
pci2=cn.itcast.reflect.test.NetCard

ReflectTest.java

package cn.itcast.reflect.test;

import java.io.File;
import java.io.FileInputStream;

import java.util.Properties;

/*
* 电脑运行
*/
public class ReflectTest
{
        public static void main(String[] args) throws Exception {

                Mainboard mb = new Mainboard();

                mb.run();
                //每次添加一个设备都需要修改代码传递一个新创建的对象
                //mb.usePCI(new SoundCard());
                //能不能不修改代码就可以完成这个动作
                //不用new完成，而是只获取其class文件，在内部实现创建对象的动作。

                File configFile = new File("pci.properties");

                Properties prop = new Properties();
                FileInputStream fis = new FileInputStream(configFile);

                prop.load(fis);

                for(int x = 0; x < prop.size(); x++){

                        String pciName = prop.getProperty("pci" + (x + 1));

                        Class clazz = Class.forName(pciName);//用Class去加载这个pci子类

                        PCI p = (PCI)clazz.newInstance();

                        mb.usePCI(p);
                }

                fis.close();
        }
}

运行结果图