注解

Java反射机制概述

Redlection反射是java被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection APL取得任何类的内部信息,并能直接操作任意对象的内部属性及方法.
加载完类之后,在堆内存的反方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息,我们可以通过这个对象看到类的结构.这个对象就像一面镜子,透过这个镜子看到类的结构,所以,我们称之为:反射正常方式-->引入需要的包类的名称-->通过new实例化-->取得实例化对象反射方式-->实例化对象-->getClass()方法-->取到完整的"包装"名称
getClass()方法返回一个Class类,此类是Java反射的源头,实际上所谓的反射从程序的运行结果来看也很好理解,即:可以通过对象反射求出类的名称

package com.cyf.reflection;
//什么叫反射
public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class<?> class1 = Class.forName("com.cyf.reflection.User");
        System.out.println(class1);

        //一个类在内存中只有一个class对象
        //一个类被加载后,类的整个结构都会被封装在class对象中
    }
}
class User{
    String name;
    int age;
    String sex;

    public User() {
    }

    public User(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", sex='" + sex + ''' +
                '}';
    }
}

获取Class的获取方式

第一种:通过对象获取===对象.getClass();
第二种:forname获取===Class.forname("包名");
第三种:通过类名.class获取===类名.class;

package com.cyf.reflection;
//class的获取方式
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Person();
        System.out.println("这个人是:"+person.name);
        //方式一:通过对象获取
        Class<? extends Person> aClass = person.getClass();
        System.out.println(aClass);
        //方式二:forname获取
        Class<?> aClass1 = Class.forName("com.cyf.reflection.XueSheng");
        System.out.println(aClass1);
        //方式三:通过类名.class获取
        Class<XueSheng> xueShengClass = XueSheng.class;
        System.out.println(xueShengClass);
        
        //获取父类类型
        Class<? super XueSheng> superclass = xueShengClass.getSuperclass();
        System.out.println(superclass);
    }
}

class Person{
    public String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + ''' +
                '}';
    }
}
class XueSheng extends Person{
    public XueSheng() {
        super.name = "我是学生";
    }
}
class LaoShi extends Person{
    public LaoShi(String name) {
        super.name = "我是老师";
    }
}

那些类型可以有Class对象

Class:外部类,成员内部类,静态内部类,局部内部类,匿名内部类
interface:接口
[]:数组
enum:枚举
annotation:注解@interface
基本数据类型
void

类的加载与ClassLoader的理解

加载:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,如何生成一个代表这个类的java.lang.Class对象
链接:将java类的二进制代码合并到JVM的运行状态之中的过程
- 验证:确保加载的类信息符合JVM规范,没有安全方面的问题
- 准备:正式为类变量(static)分配内存并设置类默认初始化阶段,这些内存都将在方法区中进行分配.
- 解析:虚拟机常量池内的符号引用(常量名)替换为直接引用地址的过程
初始化:
- 执行类构造器()方法的过程.类构造器()方法是有编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的.(类构造器是构造类信息的,不是构造该类对象的构造器)
- 当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化
- 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

什么时候会发生初始化

类的主动引用(一定会发生类的初始化)
- 当虚拟机启动,先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员(除了final常量)和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类,如果其父类没有被初始化,则先会初始化它的父类
类的被动引用(不会发生类的初始化)
- 当访问一个静态域时,只有真正声明这个域的类才会被初始化.当通过子类引用父类的静态变量,不会导致子类初始化
- 通过数组定义类引用,不会触发此类的初始化
- 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了 )

package com.cyf.reflection;
//测试类什么时候会被初始化
public class Test03 {
    static {
        System.out.println("Main被加载...");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
        Son son = new Son();
        //反射也会产生主动引用
        Class.forName("com.cyf.reflection.Son");
        //不会产生类的引用的方法
        Son[] array = new Son[5];

        System.out.println(Son.b);

        System.out.println(Son.M);
    }
}
class Father{
    static int b = 2;
    static {
        System.out.println("父类被加载...");
    }
}
class Son extends Father{
    static {
        System.out.println("子类被加载...");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}

package com.cyf.reflection;

import org.testng.annotations.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

public class Test05 {
    @Test
    public void Test01() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        System.out.println("=========获取公开构造方法===========");
        Class<?> aClass = Class.forName("com.cyf.reflection.pojo.UserSt");
        Constructor<?>[] constructor = aClass.getConstructors();
        for (Constructor<?> constructor1 : constructor) {
            System.out.println(constructor1);
        }
        System.out.println("=========获取全部构造方法===========");
        Constructor<?>[] declaredConstructors = aClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
            System.out.println("1.=============获取构造方法的名字===========");
            System.out.println(declaredConstructor.getName());
            System.out.println("2.===========构造函数对象获取构造函数的参数类型===========");
            Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
            System.out.println(Arrays.toString(parameterTypes));
        }
        System.out.println("=============获取公有,无参的构造方法===============");
        Constructor<?> constructor1 = aClass.getConstructor(null);
        System.out.println(constructor1);
        System.out.println(constructor1.getName());
        System.out.println(Arrays.toString(constructor1.getParameterTypes()));
        System.out.println("=============获取私有的构造方法,并调用===============");
        Constructor<?> declaredConstructor = aClass.getDeclaredConstructor(char.class);
        declaredConstructor.setAccessible(true);
        Object o = declaredConstructor.newInstance('男');
        System.out.println(o);
    }
    @Test
    public void Test02() throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        System.out.println("=============获取公开的字段==============");
        Class<?> aClass = Class.forName("com.cyf.reflection.pojo.UserSt");
        Field[] fields = aClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("============获取全部的字段================");
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println("============获取公有字段**并调用================");
        Field sex = aClass.getField("sex");
        Object o = aClass.getConstructor().newInstance();
        sex.set(o,"男");
        System.out.println(sex.get(o));
        System.out.println("============获取私有字段****并调用================");
        Field esx = aClass.getDeclaredField("esx");
        Object o1 = aClass.newInstance();
        esx.setAccessible(true);
        esx.set(o1,1);
        System.out.println(esx.get(o1));
    }
    @Test
    public void Test03() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<?> aClass = Class.forName("com.cyf.reflection.pojo.UserSt");
        System.out.println("***************获取所有的”公有“方法*******************");
        Method[] methods = aClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("***************获取所有的方法，包括私有的*******************");
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        System.out.println("***************获取公有的show1()方法*******************");
        Method tesst1 = aClass.getMethod("Tesst1", null);
        Object o = aClass.getConstructor().newInstance();
        tesst1.invoke(o,null);
        System.out.println("***************获取私有的show1()方法******************");
        Method tesst3 = aClass.getDeclaredMethod("Tesst3", String.class, int.class);
        Object o1 = aClass.getConstructor().newInstance();
        tesst3.setAccessible(true);
        tesst3.invoke(o1,"张三",1);
    }
}

反射--学习笔记

注解

Java反射机制概述

获取Class的获取方式

那些类型可以有Class对象

类的加载与ClassLoader的理解

什么时候会发生初始化