Java学习day42-反射机制

一、通过反射调用类的完整结构

1.使用反射可以取得：

　　①实现的全部接口

　　public Class<?>[] getInterfaces()

　　确定此对象所表示的类或接口实现的接口。

　　②所继承的父类

　　public Class<? Super T> getSuperclass()

　　返回表示此Class所表示的实体（类、接口、基本类型）的父类的Class。

package day19;

public class Test1 {
    public static void main(String[] args){
    try {
        Class clazz = Class.forName("day19.Student");//通过包名.类名的字符串，调用Class.forName方法获取指定类的Class实例
        
        Class superClazz = clazz.getSuperclass();//获取父类
        System.out.println("父类:" + superClazz.getName());
        
        Class[] Interfaces = clazz.getInterfaces();//获取当前类的所有接口
        for(Class c : Interfaces){
            System.out.println("接口:" + c.getName());
        }
        
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    }
}

打印结果为：

 

二、反射获取一个类的构造方法

1.全部的构造器

　　①public Constructor<T>[] getConstructors()

　　返回此Class对象所表示的类的所有public构造方法。

　　②public Constructor<T>[] getDeclaredConstructors()

　　返回此Class对象表示的类声明的所有构造方法。

2.Constryctor类中：

　　①取得修饰符：public int getModifiers();

　　②取得方法名称：public String getName();

　　③取得参数的类型：public Class<?>[] getParameterTypes();

package day19;

public class Student extends Person implements Move,Study{
    public Student(){
        
    }
    
    public Student(String school){
        this.school = school;
    }
    
    private Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    String school;
    
    public void showInfo(){
        System.out.println("学校是: " + this.school);
    }
    
    public void studyInfo() {
        // TODO Auto-generated method stub
        System.out.println("学习的中学的知识");
    }

    public void moveType() {
        // TODO Auto-generated method stub
        System.out.println("骑自行车上学");
    }
    
}

import java.lang.reflect.Constructor;

public class Test1 {
    public static void main(String[] args){
    try {
        Class clazz = Class.forName("day19.Student");

        System.out.println("-------------------------------");
        
        Constructor[] cons = clazz.getConstructors();//获取到类的共有的构造方法
        
        for(Constructor c :cons){
            System.out.println("构造方法名称" + c.getName());//取得方法名称：getName();
            //取得修饰符：c.getModifiers();返回数字1代表public
            System.out.println("构造方法" + c.getName() + "的修饰符是:" + c.getModifiers());
            
            Class[] paramClazz = c.getParameterTypes();//取得构造方法的参数的类型c.getParameterTypes()
            for(Class pc : paramClazz){
                System.out.println("构造方法" + c.getName() + "的参数类型是:" + pc.getName());
            }
        }
        
        System.out.println("-------------------------------");
        
        Constructor[] cons1 = clazz.getDeclaredConstructors();//获取类的所有的构造方法，包括公有和私有的
        for(Constructor c :cons1){
            System.out.println("构造方法名称" + c.getName());//取得方法名称：getName();
            //取得修饰符：c.getModifiers();返回数字1代表private
            System.out.println("构造方法" + c.getName() + "的修饰符是:" + c.getModifiers());
            
            Class[] paramClazz = c.getParameterTypes();
            for(Class pc : paramClazz){
                System.out.println("构造方法" + c.getName() + "的参数类型是:" + pc.getName());
            }
        }
        
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    }
}
    

打印结果为：

 

三、通过反射创建一个对象

package day19;

import java.lang.reflect.Constructor;

public class Test1 {
    public static void main(String[] args){
    try {
        Class clazz = Class.forName("day19.Student");
        try {
            Object obj = clazz.newInstance();//相当于调用Student类无参公有的构造方法
            Student stu = (Student)obj;
            System.out.println(stu.school);
            
            System.out.println("-------------------------------");
            
            Constructor c = clazz.getConstructor(String.class);//指定获取有一个参数并且为String类型的共有的构造方法
            Student stu1 = (Student)c.newInstance("第一中学");//newInstance实例化对象，相当于调用public Student(String school)方法
            System.out.println(stu1.school);
            
            System.out.println("-------------------------------");
            
            //通过反射机制，可以强制调用私有的构造方法
            Constructor c1 = clazz.getDeclaredConstructor(String.class,int.class);//指定获取有两个参数(String，int)的构造方法
            
            c1.setAccessible(true);//解除私有的封装，下面就可以对这个私有方法强制调用
            Student stu2 = (Student)c1.newInstance("xiaobai",12);
            System.out.println(stu2.name + " " +stu2.age);
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    }
}

打印结果为：

 

四、反射机制获取类的方法

1.全部的方法

　　①public Method[] getDeclaredMethods()

　　返回此Class对象所表示的类或接口的全部方法

　　②public Method[] getMethods()

　　返回此Class对象所表示的类或接口的public的方法

2. Method类中：

　　①public Class<?> getReturnType()取得全部的返回值

　　②public Class<?>[] getParameterTypes()取得全部的参数

　　③public int getModifiers()取得修饰符

package day19;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Test1 {
    public static void main(String[] args){
    try {
        Class clazz = Class.forName("day19.Student");
        
//        Method[] ms = clazz.getMethods();//获取到类的所有的公有的方法
        Method[] ms = clazz.getDeclaredMethods();//获取类的所有方法，包括公有的和私有的
        for(Method m : ms){
            System.out.println("方法名:" + m.getName());
            System.out.println("返回值类型:" + m.getReturnType());
            System.out.println("修饰符:" + m.getModifiers());
            
            Class[] pcs = m.getParameterTypes();//获取方法的参数类型，是一个数据，方法有几个参数，数据就有几个元素
            if(pcs != null && pcs.length > 0){
                for(Class pc : pcs){
                    System.out.println("参数类型:" + pc.getName());
                }
            }
            System.out.println("-------------------------------");    
            
        }
        
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        }
    }
}

打印结果：

 

五、反射机制获取类的属性和包

1.全部的Fields

　　①public Fieid[] getFields()

　　代表此Class对象所表示的类或接口的public的Field

　　②public Field[] getDcclaredFields()

　　返回此Class对象所表示的类或接口的全部Field。

2.Field方法中：

　　①public int getModifiers() 以整数形式返回此Field的修饰符

　　②public Class<?> getType() 得到Field的属性类型

　　③public String getName() 返回Field的名称

六、获取类所在的包

package day19;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test1 {
    public static void main(String[] args){
    try {
        Class clazz = Class.forName("day19.Student");

//        Field[] fs = clazz.getFields();//获取类的公有属性，包含父类的公有属性
        Field[] fs = clazz.getDeclaredFields();//获取本类的(不包含父类的属性)所有的属性，包括公有和私有
        
        for(Field f : fs){
            System.out.println("修饰符:" + f.getModifiers());
            System.out.println("属性的类型:" + f.getType());
            System.out.println("属性的名称:" + f.getName());
        }
        
        Package p = clazz.getPackage();//获取类所在的包
        System.out.println(p.getName());
        
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        }
    }
}

打印结果：