Java基础学习10--反射

1.获取类对象的三种方法

首先定义一个用于测试的类Person：

package com.example.reflection;

public class Person {
    String name;
    int age;

    public Person() {
        super();
        System.out.println("Person的无参构造执行了");
    }

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

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

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

    private void prviMethod() {
        System.out.println("Person的私有方法");
    }

    static void staticMethod() {
        System.out.println("Person的静态方法");
    }
}

获取类对象有以下三种方式：

(1)通过类的对象获取类对象

(2)通过类名获取类对象

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

package com.example.reflection;

public class TestPerson {
    public static void main(String[] args) throws Exception {
        // 1.使用对象获取类对象
        Person p = new Person();
        Class<Person> cp = (Class<Person>) p.getClass();
        System.out.println(cp.hashCode());

        // 2.使用类名获取类对象
        Class<Person> cp2 = Person.class;
        System.out.println(cp2.hashCode());

        // 3.使用Class的formName()方法
        Class<Person> cp3 = (Class<Person>) Class.forName("com.example.reflection.Person");
        System.out.println(cp3.hashCode());
    }
}

 三种方式获取的是同一个类对象。

2.反射常用方法和操作

反射常用方法有：

public String getName()

public Package getPackage()

public Class<? super T> getSuperclass()

public Class<?>[] getInerfaces()

public Constructor<?>[] getConstructors()

public T newInstance()

public Method[] getMethods()

public Field[] getFields()

2.1获取类的基本信息

package com.example.reflection;

public class active1 {

    public static void main(String[] args) throws Exception {
        // 通过反射获取类对象
        Class<?> cp = Class.forName("com.example.reflection.Person");

        // 1.获取类的名字
        System.out.println(cp.getName());

        // 2.获取类的包名
        System.out.println(cp.getPackage());

        // 3. 获取类的父类
        System.out.println(cp.getSuperclass().getName());

        // 4. 获取类继承的接口
        for (Class<?> c1 : cp.getInterfaces()) {
            System.out.println(c1.getName());
        }
    }
}

2.2获取类的构造方法，并创建对象

package com.example.reflection;

import java.lang.reflect.Constructor;

public class active2 {
    public static void main(String[] args) throws Exception {
        // 通过反射获取类对象
        Class<?> cp = Class.forName("com.example.reflection.Person");

        // 1. 获取所有构造函数
        for (Constructor<?> ct : cp.getConstructors()) {
            System.out.println(ct.toString());
        }

        // 2. 获取类的无参构造方法
        Constructor<?> ct2 = cp.getConstructor();
        Person p = (Person) ct2.newInstance(null);
        // p = (Person) cp.newInstance();//简写形式
        System.out.println(p.toString());

        // 3.获取类的有参构造方法
        Constructor<?> ct3 = cp.getConstructor(String.class, int.class);
        Person p2 = (Person) ct3.newInstance("张三", 18);
        System.out.println(p2.toString());
    }
}

2.3获取类的方法，并调用

package com.example.reflection;

import java.lang.reflect.Method;

public class active3 {

    public static void main(String[] args) throws Exception {
        // 通过反射获取类对象
        Class<?> cp = Class.forName("com.example.reflection.Person");
        Person p = (Person) cp.newInstance();

        System.out.println("获取公开的方法和继承的方法");
        for (Method m : cp.getMethods()) {
            System.out.println(m.toString());
        }

        System.out.println("获取所有方法，不含继承的");
        for (Method m : cp.getDeclaredMethods()) {
            System.out.println(m.toString());
        }

        System.out.println("获取公共方法");
        Method eat = cp.getMethod("eat", String.class);
        eat.invoke(p, "牛肉面");
        
        System.out.println("获取私有方法");
        Method priv = cp.getDeclaredMethod("prviMethod");
        priv.setAccessible(true);//允许执行私有方法
        priv.invoke(p, null);
        
        System.out.println("获取静态方法");
        Method stac = cp.getDeclaredMethod("staticMethod");
        stac.invoke(p, null);
    }
}

2.4实现一个可以调用任何对象的任何方法的方法

package com.example.reflection;

import java.lang.reflect.Method;
import java.util.Properties;

public class active4 {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        Properties ps = new Properties();
        invoeAny(ps, "setProperty", new Class[] { String.class, String.class }, "username", "zhangsan");
        System.out.println(ps.getProperty("username"));
    }

    public static Object invoeAny(Object obj, String methodName, Class<?>[] types, Object... args) throws Exception {
        Class<?> cp = obj.getClass();
        Method m = cp.getMethod(methodName, types);
        return m.invoke(obj, args);
    }
}

2.5 获取属性

package com.example.reflection;

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

public class active5 {
    public static void main(String[] args) throws Exception {
        // 通过反射获取类对象
        Class<?> cp = Class.forName("com.example.reflection.Person");
        Constructor<?> ct = cp.getConstructor(String.class, int.class);
        Person p = (Person) ct.newInstance("张三", 18);

        // 公共和继承的属性
        for (Field f : cp.getFields()) {
            System.out.println(f.toString());
        }

        for (Field f : cp.getDeclaredFields()) {
            System.out.println(f.toString());
        }

        // 获取属性
        Field name = cp.getDeclaredField("name");
        System.out.println(name);

        // 给属性赋值
        name.set(p, "法外狂徒");
        System.out.println(p.getName());
    }
}