java中的反射

类的对象：类new出来的对象，是实例对象。

类对象：类加载的产物，封装了一个类的所有信息（类名，父类，接口，属性，方法，构造方法）。如下图所示，每个类加载到内存中，都有属性，方法，构造方法等，根据面向对象思想，我们把这些事物抽取出来，构成class类。

每个类加载到内存后都对应一个calss对象，每个类有且只有一个class对象。

在编译时，在配置中添加-verbose:calss，可以显示类的加载过程。

---

获取类对象的三种方式：

1. 通过类的对象，获取类对象：

Student s = new Student();

Class c = s.getClass();

2.通过类名获取类对象

Class c = 类名.class;

3.通过静态方法获取类对象

Class c = Class.forName("包名.类名");

---

反射demo展示：

创建一个Person类·：

package com.qf.person;

import java.io.Serializable;

public class Person implements Serializable, Cloneable {
    String city;
    public String isMale;
    private String name;
    private int age;

    public Person() {
        System.out.println("获取类的无参构造。。。");
    }

    public Person(String name, int age) {
        System.out.println("获取类的有参构造。。。");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public void eat() {
        System.out.println("吃东西");
    }

    public void eat(String food) {
        System.out.println("吃" + food);
    }

    private void privateMethod() {
        System.out.println("这是一个私有方法！");
    }

    public static void staticMethod() {
        System.out.println("这是一个静态方法！");
    }
}

通过调用这个类学习反射的常用方法：

package com.qf.person;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Properties;

public class TestPerson {
    public static void main(String[] args) throws Exception {
        // reflectOpen1();
        // reflectOpen2();
        // reflectOpen3();
        // reflectOpen4();
        reflectOpen5();
    }

    public static void reflectOpen1() throws Exception {
        Class class1 = Class.forName("com.qf.person.Person");
        System.out.println(class1.getName());
        System.out.println(class1.getPackage().getName());
        System.out.println(class1.getSuperclass().getName());

        Class<?>[] classes = class1.getInterfaces();
        System.out.println(Arrays.toString(classes));
        System.out.println(class1.getSimpleName());
        System.out.println(class1.getTypeParameters());
    }

    /**
     * 反射获取类的构造方法
     * @throws Exception
     */
    public static void reflectOpen2() throws Exception {
        Class class1 = Class.forName("com.qf.person.Person");
        Constructor<?>[] cons = class1.getConstructors();
        System.out.println(Arrays.toString(cons));

        System.out.println("获取类的无参构造：");
        Constructor<?> constructor = class1.getConstructor();
        Person penson = (Person)constructor.newInstance();
        
        System.out.println(penson.toString());

        System.out.println("获取类的有参构造：");
        Constructor<?> constructor1 = class1.getConstructor(String.class, int.class);
        Person person1 = (Person)constructor1.newInstance("张三", 12);
        System.out.println(person1.toString());
    }

    /**
     * 反射获取类的方法
     */
    public static void reflectOpen3() throws Exception {
        // 获取类对象
        Class<?> classes = Class.forName("com.qf.person.Person");
        // getMethods()获取公开的方法，包括从从父类继承的方法
        Method[] methods = classes.getMethods();
        System.out.println("getMethods()获取公开的方法，包括从从父类继承的方法：");
        for (Method method : methods) {
            System.out.println(method.toString());
        }
        // getDeclaredMethods()获取类的所有方法，不包括从从父类继承的方法
        System.out.println("getDeclaredMethods()获取类的所有方法，不包括从从父类继承的方法：");
        methods = classes.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.toString());
        }

        Person person = (Person)classes.newInstance();
        System.out.println("获取单个方法：eat");
        Method eatMethod = classes.getMethod("eat");
        eatMethod.invoke(person);

        System.out.println("获取单个方法：toString");
        Method toStringMethod = classes.getMethod("toString");
        Object o = toStringMethod.invoke(person);
        System.out.println(o);

        System.out.println("获取单个方法：带参数eat");
        eatMethod = classes.getMethod("eat", String.class);
        eatMethod.invoke(person, "apple");

        // 调用私有方法的时候，要设置权限
        System.out.println("获取私有方法：privateMethod");
        Method privateMethod = classes.getDeclaredMethod("privateMethod");
        privateMethod.setAccessible(true);
        privateMethod.invoke(person);

        // 调用静态对象,静态方法的调用不需要对象，只需要类名，因此，obj参数为null
        System.out.println("获取静态方法：staticMethod");
        Method staticMethod = classes.getMethod("staticMethod");
        staticMethod.invoke(null);
    }

    /**
     * 使用反射调用任何对象的方法
     *
     * @throws Exception
     */
    public static void reflectOpen4() throws Exception {
        Properties properties = new Properties();
        // 普通方法
        properties.setProperty("name", "apple");
        System.out.println(properties.toString());
        // 调用反射方法：invokeAny
        invokeAny(properties, "setProperty", new Class[]{String.class, String.class}, "username", "zhangsan");
        System.out.println(properties.toString());

    }
    public static Object invokeAny(Object obj, String methodName, Class<?>[] type, Object ...arg) throws Exception {
        // 类对象
        Class<?> classes = obj.getClass();
        Method method = classes.getMethod(methodName, type);
        return method.invoke(obj, arg);
    }

    /**
     * 使用反射获取类的属性
     */
    public static void reflectOpen5() throws Exception {
        // 获取类对象
        Class<?> classes = Class.forName("com.qf.person.Person");
        // 获取公开的字段，父类继承的字段
        System.out.println("获取公开的字段，父类继承的字段：");
        Field[] fields = classes.getFields();
        System.out.println(fields.length);
        // 获取所有的属性，包括私有，默认，包含
        System.out.println("获取所有的属性，包括私有，默认，包含：");
        fields = classes.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.toString());
        }

        Person person = (Person)classes.newInstance();
        System.out.println("获得city：");
        Field field = classes.getDeclaredField("city");
        field.set(person, "shagnhai");
        System.out.println(field.get(person));

        System.out.println("获得name：");
        field = classes.getDeclaredField("name");
        field.setAccessible(true);
        field.set(person, "zhangsan");
        System.out.println(field.get(person));
    }
}

---

设计模式：一套被反复使用，多数人知晓的，经过分类编目的，代码设计经验的总结。可重用代码，让代码更容易被他人理解，保证代码的可靠性，重用性。

工厂设计模式：主要是负责对象的创建，遵循“开闭原则”，对拓展开放，对修改关闭，采用反射实现该模式的设计，完成动态的对象创建。

创建一个usb接口：

package com.qf.factoryModel;

public interface Usb {
    void service();
}

分别实现鼠标类，风扇类，u盘类，继承该接口：

// 鼠标类
package com.qf.factoryModel;

public class Mouse implements Usb {
    @Override
    public void service() {
        System.out.println("鼠标开始工作了。。。");
    }
}

// 风扇类
package com.qf.factoryModel;

public class Fan implements Usb {

    @Override
    public void service() {
        System.out.println("风扇开始工作了。。。");
    }
}


// U盘类
package com.qf.factoryModel;

public class Upan implements Usb {
    @Override
    public void service() {
        System.out.println("u盘开始工作了。。。");
    }
}

通过反射实现工厂设计模式：

package com.qf.factoryModel;

public class usbFactory {
    public static Usb usbCreate(String type) {
        Usb usb = null;
        Class<?> classes = null;
        try {
            classes = Class.forName(type);
            usb = (Usb) classes.newInstance();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        return usb;
    }
}

将要拓展的类用properties存储：

1=com.qf.factoryModel.Mouse
2=com.qf.factoryModel.Upan
3=com.qf.factoryModel.Fan

然后通过demo来动态拓展：

package com.qf.factoryModel;

import java.io.FileInputStream;
import java.util.Properties;
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) throws Exception {
        System.out.println("---------1 鼠标 2 u盘 3 风扇------------");
        Scanner scanner = new Scanner(System.in);
        String choise = scanner.next();
        /*
        1==factoryModel.Mouse
        2==factoryModel.Upan
        3==factoryModel.Fan
         */
        Properties properties = new Properties();
        FileInputStream fis = new FileInputStream("D:\\IntelliJ IDEA\\project\\QianFeng\\JavaBase\\Reflect\\src\\com\\qf\\factoryModel\\usb.properties");
        properties.load(fis);
        fis.close();

        Usb usb = usbFactory.usbCreate(properties.getProperty(choise));
        if (usb != null) {
            System.out.println("参数有效！");
            usb.service();
        } else {
            System.out.println("参数无效！");
        }
    }
}