黑马程序员------反射机制

黑马程序员------反射机制

 

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

*反射其实就是动态加载一个指定的类，并获取该类中的所有的内容。

*而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。

*就是把JAVA类中的各种成分反射成为相应的JAVA类
*简单说：反射技术可以理解为对一个类进行解剖。

 

1.2 反射机制原理图：

 

*
*
* 要想要对字节码文件进行解剖，必须要有字节码文件对象.
* 如何获取字节码文件对象呢？（示例1）

 示例1：
 1 public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
            
        getClassObject_1();
    
    }
    /*
     * 只要通过给定的类的 字符串名称就可以获取该类，更为扩展。
     * 可是用Class类中的方法完成。
     * 该方法就是forName.
     * 这种方式只要有名称即可，更为方便，扩展性更强。 
     */
    
    public static void getClassObject_1() throws ClassNotFoundException {
        
        String className = "cn.itcast.bean.Person";
        
        Class clazz = Class.forName(className);
        
        System.out.println(clazz);
    }
    
}

 

1.3 反射的好处：大大的增强了程序的扩展性。

1.4 反射的基本步骤：
1、获得Class对象，就是获取到指定的名称的字节码文件对象。
2、实例化对象，获得类的属性、方法或构造函数。
3、访问属性、调用方法、调用构造函数创建对象。

得到类的字节码文件相同，这三种方式。
1.Class cls1=类名.class 相对简单，还是需要明确类名
2.cls1.getclass();必须要明确具体的类，并创建对象
3.class.forName("完整的类名（带包名）");

 

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

package cn.itcast.reflect.demo;

import java.io.FileReader;
import java.lang.reflect.Constructor;

public class ReflectDemo2 {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, Exception {

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

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

    public static void createNewObject() throws ClassNotFoundException, InstantiationException, IllegalAccessException{
        
        
        //早期：new时候，先根据被new的类的名称找寻该类的字节码文件，并加载进内存，
//        并创建该字节码文件对象，并接着创建该字节文件的对应的Person对象.
//        cn.itcast.bean.Person p = new cn.itcast.bean.Person();
        
        //现在：
        String name = "cn.itcast.bean.Person";
        //找寻该名称类文件，并加载进内存，并产生Class对象。
        Class clazz = Class.forName(name);
        //如何产生该类的对象呢？
        Object obj  = clazz.newInstance();
        
        
        
        
    }
}

 

示例3：获取Class的字段

package cn.itcast.reflect.demo;

import java.lang.reflect.Field;

public class ReflectDemo3 {

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

    /*
     * 获取字节码文件中的字段。
     */
    public static void getFieldDemo() throws Exception {
        
        Class clazz = Class.forName("cn.itcast.bean.Person");
        
        Field field = null;//clazz.getField("age");//只能获取公有的，
        
        field = clazz.getDeclaredField("age");//只获取本类，但包含私有。 
        
        //对私有字段的访问取消权限检查。暴力访问。
        field.setAccessible(true);
        
        Object obj = clazz.newInstance();
        
                //为对象的属性赋值        
                field.set(obj, 89);
        
        //获取某对象的某属性值
        Object o = field.get(obj);
        
        System.out.println(o);
        
//        cn.itcast.bean.Person p = new cn.itcast.bean.Person();
//        p.age = 30;
        
    }
    
}
    

 

示例4：获取Class中的方法

package cn.itcast.reflect.demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ReflectDemo4 {

    public ReflectDemo4() {
    }

    public static void main(String[] args) throws Exception {

        getMethodDemo_3();
        
    }
    
    

    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();
        
        method.invoke(obj, "小强",89);
        
        
    }

    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(String.class,int.class);
        Object obj = constructor.newInstance("小明",37);
        
        
        method.invoke(obj, null);
        
        
        
    }

    /*
     * 获取指定Class中的所有公共函数。
     */
    public static void getMethodDemo() 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);
        }
        
        
    }

}

 

练习：反射练习

代码：

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

运行结果：