类对象

类对象：类加载的产物，封装了一个类的所有信息（类名，父类，接口，属性，方法，构造方法）

每一个类加载到内存之后都对应一个class对象

每个类有且只有一个class对象

获取类对象

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

   • Student s = new Student();

   • Class<?> c = s.getClass();

2. 通过类名获取类对象

   • Class<?> c = 类名.class;

3. 通过静态方法获取类对象（记得抛出异常）[推荐使用]

   • Class<?> c = Class.forName("包名.类名");

反射

常用方法

• public String getName()

• public Package getPackage()

• public Class<? super T> getSuperclass()

• public Class<?>[] getInterfaces()

• public Constructor<?>[] getConstructor()

• public T newInstance()

• public Method[] getMethods()

• public Field[] getFields()

常见操作

附：person类

public class person implements Serializable,Cloneable {
    public String name;
​
    public person() {
    }
​
    public person(String name) {
        this.name = name;
    }
​
    public void eat(){
        System.out.println(this.name+"在吃饭");
    }
​
    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                '}';
    }
​
    public void eat(String food){
        System.out.println(this.name+"在吃"+food);
    }
​
    private void sleep(){
        System.out.println(this.name + "在睡觉");
    }
​
    public static void quiet(){
        System.out.println("保持安静");
    }
}

使用反射获取类的名字，包名，父类，接口

public class Demo1 {
    public static void main(String[] args) throws Exception{
        reflectOpe1();
    }
    public  static void reflectOpe1() throws Exception{
        //1 获取类对象person
        Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
        //获得类的全名称
        System.out.println(class1.getName());
        //得到包名(getPackage() 返回包的类对象)
        System.out.println(class1.getPackage().getName());
        //获取父类()(getSuperclass() 返回父类的类对象)
        System.out.println(class1.getSuperclass().getName());
        //获取接口(getInterfaces() 返回数组)
        Class<?>[] classes = class1.getInterfaces();
        System.out.println(Arrays.toString(classes));
    }
}

使用反射获取类的构造方法并创建对象

public class Demo1 {
    public static void main(String[] args) throws Exception{
        reflectOpe2();
    }
​
    public  static void reflectOpe2() throws Exception{
        Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
        //获取类的构造方法Constructor(getConstructors()返回数组)
        Constructor<?>[] cons = class1.getConstructors();
        for (Constructor<?> con : cons){
            System.out.println(con.toString());
        }
        //获取类中的无参构造
        Constructor<?> con = class1.getConstructor();
        Object zhangsan = (person)con.newInstance();
        System.out.println(zhangsan.toString());
        //简便方法
        person wangwu = (person) class1.newInstance();
        System.out.println(wangwu.toString());
​
        //获取类中的带参构造
        Constructor<?> con2 = class1.getConstructor(String.class);
        person xiaoli = (person) con2.newInstance("小李");
        System.out.println(xiaoli.toString());
    }
}

使用反射获取类中的方法并调用

public class Demo1 {
    public static void main(String[] args) throws Exception{
        reflectOpe3();
    }
​
    public  static void reflectOpe3() throws Exception{
        Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
​
        //获取方法
        //getMethods()  获取公开的方法 包括继承的方法
        Method[] methods = class1.getMethods();
        for (Method method : methods) {
            System.out.println(method.toString());
        }
        //getDeclaredMethods() 获取所有方法，不包含继承的
        Method[] Methods2 = class1.getDeclaredMethods();
        for (Method method : Methods2) {
            System.out.println(method.toString());
        }
​
        //获取单个方法
        //调用无参无返回值
        Method eatMethod = class1.getMethod("eat");
        person zhangsan = (person) class1.newInstance();
        eatMethod.invoke(zhangsan);
​
        //无参有返回值
        Method toStringMethod = class1.getMethod("toString");
        Object result = toStringMethod.invoke(zhangsan);
        System.out.println(result);
​
        //带参
        Method eatMethod2 = class1.getMethod("eat",String.class);
        eatMethod2.invoke(zhangsan,"鸡腿");
​
        //获取私有方法
        Method privateMethod = class1.getDeclaredMethod("sleep");
        //设置访问权限无效
        privateMethod.setAccessible(true);
        privateMethod.invoke(zhangsan);
​
        //获取静态方法
        Method staticMethod = class1.getMethod("quiet");
        staticMethod.invoke(null);
​
    }
}

反射调用任何对象的通用方法

public class Demo1 {
    public static void main(String[] args) throws Exception{
        Properties properties = new Properties();
        //原本的方法
        properties.setProperty("name","zhangsan");
        System.out.println(properties.toString());
        //invokeAny()
        invokeAny(properties,"setProperty",new Class[]{String.class,String.class},"username","张三");
        System.out.println(properties.toString());
    }
​
    public static Object invokeAny(Object obj,String methodName,Class<?>[] types,Object...args) throws Exception{
        //obj是对象名，methodName是方法名，types是方法参数，args是参数的数据
        //获取类对象
        Class<?> class1 = obj.getClass();
        //获取方法
        Method method = class1.getMethod(methodName,types);
        //调用
        return method.invoke(obj,args);
    }
}

使用反射获取类中的属性

public class Demo1 {
    public static void main(String[] args) throws Exception{
        reflectope4();
    }
    public static void reflectope4() throws Exception{
        //获取类对象
        Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
        //获取属性(字段) 公开的字段，父类继承的字段
        Field[] fields = class1.getFields();
        System.out.println(fields.length);
        //获取属性(字段) 所有字段 不包含继承
        Field[] fields1 = class1.getDeclaredFields();
        System.out.println(fields1.length);
​
        //获取name属性
        Field namefield = class1.getDeclaredField("name");
        namefield.setAccessible(true);//设置权限
        //赋值 正常调用
        person zhangsan = (person) class1.newInstance();
        namefield.set(zhangsan,"张三");//相当于zhangsan.name = "张三";
        //获取值
        System.out.println(namefield.get(zhangsan));
    }
}