JAVA学习笔记(六十一)- 反射Reflection

反射Reflection

import java.lang.reflect.Modifier;

/*
 * 反射Reflection
 * java.lang.Class类
 */
public class Test01 {
    public static void main(String[] args) {
        String name = "tom";

        // 方式一：通过对象getClass()方法
        // 任意一个类的对象，都有一个getClass()方法
        // 可以通过此获取获取当前对象的类型所对应的Class对象
        Class cls = name.getClass();
        showInfo(cls);

        //方式二：通过Class类的forName()静态方法
        try {
            Class cls2=Class.forName("com.itany.basejava.day37.Test01");
            showInfo(cls2);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //方式三：通过指定类的class属性
        Class cls3=Student.class;
        showInfo(cls3);


    }

    // 获取Class对象的相关信息
    public static void showInfo(Class cls) {
        System.out.println("类的全名：" + cls.getName());
        System.out.println("类名：" + cls.getSimpleName());
        System.out.println("所属包：" + cls.getPackage());
        System.out.println("是否为本地类：" + cls.isLocalClass());
        System.out.println("是否为接口：" + cls.isInterface());
        System.out.println("是否为数组：" + cls.isArray());
        System.out.println("是否为基本数据类型：" + cls.isPrimitive());
        // 获取其父类的Class对象
        Class superCls = cls.getSuperclass();
        System.out.println("父类的全名：" + superCls.getName());
        // 获取类的修饰符
        int m = cls.getModifiers();
        System.out.println("修饰符为：");
        if (Modifier.isPublic(m)) {
            System.out.print("public ");
        }
        if (Modifier.isStatic(m)) {
            System.out.print("static ");
        }
        if (Modifier.isAbstract(m)) {
            System.out.print("abstract ");
        }
        if (Modifier.isFinal(m)) {
            System.out.print("final ");
        }
        System.out.println("**************************************\n");
    }
}

通过反射访问构造方法，实例化对象

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

/*
 * 通过反射访问构造方法，实例化对象
 * Constructor类
 */
public class Test03 {
    public static void main(String[] args) throws Exception {
        // 创建一个Dog类的对象
        // Dog dog1=new Dog("大黄", 3, "男");

        // 创建一个Dog类的Class对象
        Class<Dog> cls = Dog.class;

        /*
         * 实例化无参构造函数的对象，两种方式
         */
        // 1.通过Class对象的newInstance()方法创建实例，只适用于通过无参构造方法创建对象
        Dog dog = (Dog) cls.newInstance();
        // dog.show();
        Method method = cls.getDeclaredMethod("show");
        method.invoke(dog);
        System.out.println("*************************\n");

        // 2.获取参数为空的构造方法
        Constructor c = cls.getDeclaredConstructor();
        Dog dog2 = (Dog) c.newInstance();
        dog2.show();
        System.out.println("*************************\n");

        /*
         * 实例化带参构造方法的对象
         */
        Constructor c2 = cls.getDeclaredConstructor(new Class[] { String.class,
                int.class, String.class });
        Dog dog3 = (Dog) c2.newInstance("小黄", 2, "女");
        dog3.show();

        /*
         * 通过private修饰的构造方法实例化对象
         */
        Constructor<Dog> c3 = cls.getDeclaredConstructor(new Class[] {
                String.class, String.class });
        c3.setAccessible(true);
        Dog dog4=c3.newInstance("巨黄","中");
        dog4.show();

    }
}

/*
 * Animal父类
 */
class Animal {
    public String name;
    int age;

    public Animal() {
        System.out.println("父类无参的构造方法");
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("父类中带参的构造方法");
    }

    public void show() {
        System.out.println("父类中的show方法");
    }
}

/*
 * Dog类，继承自Animal
 */
class Dog extends Animal {
    String sex;

    public Dog() {
        System.out.println("子类中无参的构造方法");
    }

    public Dog(String name, int age, String sex) {
        System.out.println("子类中带参的构造方法");
    }

    private Dog(String name, String sex) {
        System.out.println("子类中带两个参数的构造方法");
    }

    // 重写父类中的show方法
    public void show() {
        System.out.println("子类中的show方法");
    }

}

Field类

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

/*
 * Field类
 */
public class Test02 {
    public static void main(String[] args) throws SecurityException,
            NoSuchFieldException, IllegalArgumentException,
            IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        // 创建一个Student类的对象，即学生对象
        Student stu1 = new Student();
        Student stu2 = new Student();
        // 创建一个Student类对象，即Student类的Class对象
        Class cls = Student.class;

        /*
         * Field属性操作;
         */
        // 1.获取Student类中的所有属性，包含本类和父类中所有public修饰的所有属性
        // Field[] fields = cls.getFields();
        // 2.获取Student类中的所有属性，包含本类中的任意修饰符修饰的所有属性
        Field[] fields = cls.getDeclaredFields();
        for (Field f : fields) {
            System.out.println(f.getName());
            // System.out.println(f.toString());
        }
        System.out.println("**********************\n");
        // 3.获取Student类中指定的属性
        Field name = cls.getField("name");
        Field grade = cls.getDeclaredField("grade");
        Field sex = cls.getSuperclass().getDeclaredField("sex");
        // 为属性赋值
        // stu1.name="tom";//直接通过对象名.属性名赋值
        name.set(stu1, "alice");// 为指定对象的属性赋值
        System.out.println("stu1的name：" + name.get(stu1));
        // 设置属性为可访问，即设置访问修饰符
        grade.setAccessible(true);
        grade.set(stu1, 2);// 为stu1的私有属性grade赋值
        System.out.println("stu1的grade：" + grade.get(stu1));
        System.out.println("*****************************************\n");

        /*
         * Method方法操作
         */
        // 1.获取Student类中所有的方法
        //Method[] methods = cls.getMethods();

        Method[] methods=cls.getDeclaredMethods();
        for (Method m : methods) {
            System.out.println(m.getName());
        }
        // 2.获取Student类中指定的方法
        //stu1.calc(10, 25);
        Class[] args1={int.class,double.class};
        Method calc=cls.getMethod("calc", args1);
        Object[] args2={10,25.4};
        double sum=(Double) calc.invoke(stu1, args2);
        System.out.println("两数之和为："+sum);

        //获取private修饰的方法
        Method show=cls.getDeclaredMethod("show");
        show.setAccessible(true);//不检测访问修饰符
        show.invoke(stu2);//调用方法


    }
}

/*
 * Person类
 */
class Person {
    public String name;
    int age;
    private String sex;
    protected double height;
}

/*
 * Student类，继承自Person
 */
class Student extends Person {
    public int id;// 学号
    private int grade;// 年级编号
    String className;// 班级名称

    public Student(){

    }

    public int getGrade() {
        return grade;
    }

    public void setGrade(int grade) {
        this.grade = grade;
    }

    public int calc(int num1, int num2) {
        return num1 + num2;
    }

    public double calc(int num1, double num2) {
        return num1 + num2;
    }

    private void show(){
        System.out.println("第六排右数第二个人有点22222");
    }
}