Java获取Class实例的四种方式、通过反射调用类的构造器，属性和方法

清疚 2023-07-25 09:09 1阅读 0赞

Class实例对应着一个运行时类（加载到内存中的类）。可以作为Class实例的对象：  
1，class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类；  
2，接口；  
3，数组；  
4，枚举类  
5，注解；  
6，基本数据类型；  
7，void

获取运行时类的属性结构和内部结构  
getField()：获取运行时类及其父类中声明为public的属性  
getDeclaredField()：获取当前运行时类中所有的属性（不包括父类）  
其他结构类似。

package reflection;
    
    import org.junit.Test;
    
    import java.io.FileInputStream;
    import java.io.InputStream;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;
    import java.util.Properties;
    
    public class Class4ways {
        
    
        @Test
        public void getProperties() throws Exception {
        
            Properties pro = new Properties();
            FileInputStream fis = new FileInputStream("src//pro.properties");
            pro.load(fis);
            System.out.println(pro.getProperty("user"));
            System.out.println(pro.getProperty("age"));
    
            ClassLoader loader = Class4ways.class.getClassLoader();
            InputStream is = loader.getResourceAsStream("pro.properties");
            Properties pro2 = new Properties();
            pro2.load(is);
            System.out.println(pro2.getProperty("user"));
            System.out.println(pro2.getProperty("age"));
        }
        //四种方法是同一个实例
        public static void main(String[] args) throws Exception {
        
            //方式一：调用运行时类的属性 .class
            Class<Person> c1 = Person.class;
            System.out.println("c1 = " + c1);
    
            //方式二：通过运行时类的对象
            Person p1 = new Person();
            Class<Person> c2 = (Class<Person>) p1.getClass();
    
            //方式三：调用Class的静态方法，最常用
            Class<Person> c3 = (Class<Person>) Class.forName("reflection.Person");
            System.out.println(c1==c3);
    
            //使用类的加载器
            ClassLoader loader = Class4ways.class.getClassLoader();
            Class<Person> c4 = (Class<Person>) loader.loadClass("reflection.Person");
    
    
            //通过反射创建类的对象
            Constructor<Person> constructor = c3.getConstructor(String.class, int.class);
            Person chrix = constructor.newInstance("Chrix", 18);
            System.out.println("chrix = " + chrix);
    
            //通过反射调用对象的属性和方法
            Field name = c3.getDeclaredField("name");
            name.set(chrix,"xiaoming");
            System.out.println("chrix = " + chrix);
    
            Method show = c3.getDeclaredMethod("show");
            show.invoke(chrix);
    
            //通过反射调用私有结构,构造器、属性、方法
            Field age = c3.getDeclaredField("age");
            age.setAccessible(true);
            age.set(chrix,20);
            System.out.println("chrix = " + chrix);
    
            Method display = c3.getDeclaredMethod("display", String.class);
            display.setAccessible(true);
            String str = (String)display.invoke(chrix,"Hello");
            System.out.println(str);
        }
    }
    class Person{
        
        public String name;
        private int age;
    
        public Person(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
        
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public Person() {
        
        }
    
        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;
        }
        public void show(){
        
            System.out.println("I am a peroson.");
        }
        private String display(String str){
        
            System.out.println("str = " + str);
            return str;
        }
    }