javaseday31补充(反射 三种获取字节码对象 获取空参有参对象 进行构造函数和无参有参函数使用)

/*
 * java反射机制是在于宁状态中 对于任意一个类(class文件) 都能知道这个类的所有属性和方法
 * 对于任意一个对象 都能够调用它的任意一个方法和属性
 * 这种动态获取的信息以及动态调用对象的方法的功能被称为java语言的反射机制
 * 动态获取类中信息就是java反射
 * 可以理解为对类的解剖
 * 要想对字节码文件进行解剖 必须要有字节码文件对象
 * 如何获取字节码文件对象
 */
public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        getClassObject_03();
    }


    /*
     * 方式三
     * 3、只要通过给定的类的字符串名称就可以获取该类 更具有扩展性
     * 可以用class类中的方法完成
     * 该方法就是forName
     * 这种方式只要有名称即可 更为方便 扩展性更强
     * 
     */

    private static void getClassObject_03() throws ClassNotFoundException {
        String className="com.in.reflect.Person";//放的是字符串 和导不导包不相关 导包和下面两个相关
        Class clazz = Class.forName(className);
        System.out.println(clazz);
    }

    /*
     * 方式二
     * 2、任何数据类型都具备一个静态的属性.class来获取其对应的class对象
     * 相对简单 但是还是要明确用到类中的静态成员
     * 还是不够扩展
     * 
     */
    private static void getClassObject_02() {
        Class clazz = Person.class;
        Class clazz1 = Person.class;
        System.out.println(clazz==clazz1);
    }

    /*
     * 
     * 获取字节码对象的方法
     * 1、object类中的getClass方法
     * 想要用这种方式 必须要明确具体的类并创建对象
     * 麻烦
     */
    public static void getClassObject_01() {
        Person p = new Person();
        Class clazz =p.getClass();
        Person p1 = new Person();
        Class clazz1 = p1.getClass();
        System.out.println(clazz1==clazz);
    }
}

private static void creatObject_02() throws ClassNotFoundException, Exception, SecurityException {
//      com.in.reflect.Person p  = new com.in.reflect.Person("小恰",11);
        /*
         * 当获取指定名称对应类中所体现的对象时 
         * 而该对象初始化不使用空参数构造函数时 该怎么办？
         * 既然是通过指定的构造函数进行对象的初始化 
         * 所以应该先获取到该构造函数 通过字节码文件对象即可完成
         * 该方法是getConstructor(paramterTypes)
         */
        String name = "com.in.reflect.Person";
        Class clazz =   Class.forName(name);
        //获取指定的构造函数对象
        Constructor constructor = clazz.getConstructor(String.class,int.class);
        //通过该构造器对象的newInstance方法进行对象的初始化
        Object obj = constructor.newInstance("小妹",55);

    }

    private static void creatObject_01() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //早期 new 的 时候根据被new 的类的名称 寻找该类的字节码文件并加载进内存 
        // 并创建该字节码文件对象 并接着创建该字节码文件的对应的Person对象
        com.in.reflect.Person p = new com.in.reflect.Person();
        //现在
        String name = "com.in.reflect.Person";
        //找寻该名称类文件 并加载进内存 并产生class对象
        Class clazz =   Class.forName(name);
        //如何产生该类的对象
        Object obj = clazz.newInstance();//也进行初始化
    }

/*
     * 获取字节码文件中的字段
     */

    private static void getFieldDemo() throws NoSuchFieldException, SecurityException, ClassNotFoundException, Exception, IllegalAccessException {
        Class clazz = Class.forName("com.in.reflect.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);

        System.out.println(field);
//      com.in.reflect.Person p = new   com.in.reflect.Person();
//      p.age=30;

    }

private static void getMethodDemo_3() throws Exception {
        Class clazz = Class.forName("com.in.reflect.Person");
        Method method = clazz.getMethod("paramMethod", String.class,int.class);//获取有参数的 需要名字 参数类型
        Object obj = clazz.newInstance();
        method.invoke(obj, "xi",11);
    }

    private static void getMethodDemo_2() throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, Exception, InvocationTargetException {
        Class clazz = Class.forName("com.in.reflect.Person");
        Method method = clazz.getMethod("show", null);//获取空参数一般方法
        Constructor constructor = clazz.getConstructor(String.class,int.class);

        Object obj = constructor.newInstance("笑话",11);
        method.invoke(obj, null);

        System.out.println(method);
//      Person p = new Person();
//      p.show();
    }
    /*
     * 获取指定Class中的公共函数
     */
    private static void getMethodDemo() throws ClassNotFoundException {
        Class clazz = Class.forName("com.in.reflect.Person");
        Method[] methods =   clazz.getMethods();//获取共有的方法
        methods = clazz.getDeclaredMethods();//只获取本类中的方法 包括私有
        for(Method method:methods) {
            System.out.println(method);
        }
    }

MainBoard mb = new MainBoard();
        mb.run();
        //每次添加一个设备都需要修改代码传递一个新创建的对象
//      mb.usePCI(new SoundCard());
        //能不能不修改代码就完成这个动作
        //不用new来完成 而是直接获取其class文件 在内部实现创建对象的动作
        File configFile = new File("pci.properties");
        Properties prop = new Properties();//配置文件中不能加封号
        FileInputStream fi = new FileInputStream(configFile);
        prop.load(fi);//把流中数据加载到集合当中
        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);
        }
        fi.close();

public class Mainboard {

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

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

public  interface PCI {
    public void open() ;
    public void close();
}
public class SoundCard implements PCI{
    public void open() {
        System.out.println("sound打开");
    }
    public void close() {
        System.out.println("sound关闭");
    }
}
pci.properties 配置文件
pci1=com.in.reflect.SoundCard