java中的反射 学习

一、反射定义

反射即反向探知，像考古学家根据发掘的物品来去探知以前的事情

反射是被视为动态语言的关键，反射机制允许程序在执行期间借助Reflection API来获取类的内部信息（如类的属性和方法），并能够直接操作对象的内部属性和方法。
加载完类之后，在堆内存会产生一个Class类型的对象（一个类在堆中会有多个对象，但是只有一个Class对象）这个Class对象包含了完整的类的结构信息，我们可以通过这个Class对象来获取加载的这个类的结构和属性信息，这个过程称为反射

二、反射的基本操作

1、获取类的四种方式

Class clazz = Person.class;
Class clazz2 = new Person().getClass();
Class clazz3 = Class.forName("com.study.fs.Person");
Class clazz4 = Demo02.class.getClassLoader().loadClass("com.study.fs.Person");

2、基本信息操作

// 获取类的相关结构
int modifier = clazz.getModifiers(); // 获取类修饰符
Package aPackage = clazz.getPackage(); // 获取类包名
String fullClassName = clazz.getName(); // 获取类的全路径名称
String simpleName = clazz.getSimpleName(); // 获取类的简单名称
ClassLoader classLoader = clazz.getClassLoader(); // 获取类加载器
Class[] interfaces = clazz.getInterfaces(); // 获取类实现的接口列表
Class superclass = clazz.getSuperclass(); // 获取类的父类
Annotation[] annotations = clazz.getAnnotations(); // 获取类的注解信息

3、类的属性操作

public final class User extends Person {
    private String name;
    public static  String sex;
    public int age;
    public static String address;

    public int getAge() {
        return age;
    }

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

    public  String getName(String age) {
         return name;
    }

    private void jump(String aname){
        System.out.println(aname+"jump ... ");
    }

    public static void say(String msg){
        System.out.println("say:" + msg);
    }
}

public static void main(String[] args) throws Exception {
        Class<User> userClass = User.class;
        //获取User 对象
        User user = (User) userClass.newInstance();

        //获取类当中的全部的属性，返回一个数组
        Field[] declaredFields = userClass.getDeclaredFields();
        for (Field fi:declaredFields
             ) {
            System.out.println(fi.getName());
        }
        //获取类当中其中一个属性
        Field age = userClass.getDeclaredField("age");
        age.set(user,16);
        System.out.println("我的年龄是："+user.getAge());
        
    }

4、类的方法通过反射调用

public static void main(String[] args) throws Exception {
        Class<User> userClass = User.class;
        //获取User 对象
        User user = userClass.newInstance();

        /**
         * 获取类中的方法，返回一个数组
         */
        //获取类中自定义的方法（public,private）
        Method[] declaredMethods = userClass.getDeclaredMethods();
        for (Method f:
             declaredMethods) {
            System.out.println("通过getDeclaredMethods方法"+f.getName());
        }

        //获取类中所有公共方法 包含自定义的（public）
        Method[] methods = userClass.getMethods();
        for (Method f:methods){
            System.out.println("通过getMethods方法"+f.getName());
        }

        //静态方法调用
        Method say = userClass.getDeclaredMethod("say",String.class);
        say.invoke(null,"我是最棒的！");

        //放开私有的方法调用
        Method jump = userClass.getDeclaredMethod("jump",String.class);
        jump.setAccessible(true);//强制获取权限
        jump.invoke(user,"张三");


    }

5、反射在单例模式中的应用

public class Person {
    private static Person instance;

    private String name;
    private String age;
    private String adress;


}

public class PersonSingle {
    private static PersonSingle instance;


    private PersonSingle() {
        if (instance!=null){
            throw new RuntimeException("实例已经存在了，不存许再来创建");
        }
    }

    public static PersonSingle getInstance(){
        if (instance==null){
            instance = new PersonSingle();
        }
        return instance;
    }

}

public class PersonMain {
    public static void main(String[] args) throws Exception {
        Person person1 = new Person();
        Person person2 = new Person();
        Person person3 = new Person();



        System.out.println(person1);
        System.out.println(person2);
        System.out.println(person3);

        System.out.println("-------------------------------");
        PersonSingle p1 = PersonSingle.getInstance();
        PersonSingle p2 = PersonSingle.getInstance();
        PersonSingle p3 = PersonSingle.getInstance();

        System.out.println(p1);
        System.out.println(p2);
        System.out.println(p3);


        //使用反射来破坏单例
        Constructor<? extends PersonSingle> declaredConstructor = p1.getClass().getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
//        System.out.println(declaredConstructor.newInstance());


        Person person = new Person();
        String aa = person.getClass().getTypeName();//返回该类对象作为字符串表示的实体(类、接口、数组类、基本数据类型或 void)的名称
        String bb = person.getClass().getSimpleName();//返回源代码中给出的基础类的简单名称，如果基础类是匿名的，则返回空字符串
        String cc = String.valueOf(person.getClass().getPackage());//获取对象包名
        System.out.println(aa);
        System.out.println(bb);
        System.out.println(cc);
    }

}