注解和反射

获得反射对象

package TestReflected;

public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {

        Person person = new Student();
        System.out.println("这个人是"+person.name);

        //方式一
        Class C1=person.getClass();
        System.out.println(C1.hashCode());

        //方式二
        Class C2 = Class.forName("TestReflected.Test02");
        System.out.println(C2.hashCode());

        //方式三:通过类名.class获得
        Class C3=Test02.class;
        System.out.println(C3.hashCode());

        //方式四
        Class C4 = Integer.TYPE;
        System.out.println(C4);

        //获得父类类型
        Class C6 = C1.getSuperclass();
        System.out.println(C6);
    }
    }
    class Person{
        String name;
        public Person() {
        }

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

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    class Student extends Person{
        public Student() {
            this.name="学生";
        }
    }
    class Teacher extends Person{
        public Teacher() {
            this.name="老师";
        }
    }

所有类型的Class对象

package TestReflected;

import java.lang.annotation.Annotation;
import java.lang.annotation.ElementType;

public class Test03 {
    public static void main(String[] args) {
        Class C1=Object.class;  //类
        Class C2=Comparable.class;  //接口
        Class C3=String[].class;
        Class C4=int[][].class;
        Class C5= Annotation.class;
        Class C6= ElementType.class;  //枚举类型
        Class C7=Integer.class;  //基本数据类型
        Class C8 =void.class;  //void
        Class C9=Class.class;

        System.out.println(C1);
        System.out.println(C2);
        System.out.println(C3);
        System.out.println(C4);
        System.out.println(C5);
        System.out.println(C6);
        System.out.println(C7);
        System.out.println(C8);
        System.out.println(C9);

        //只要元素类型与维度一样，就是同一个Class
        int[] a =new int[10];
        int[]b=new int[100];
        System.out.println(a.hashCode());
        System.out.println(b.hashCode());
    }
}

类的初始化

package TestReflected;
//测试类什么时候初始化
public class Test04 {
    static {
        System.out.println("main类被加载");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1，主动引用
       // Son son =new Son();
        // main类被加载
        //父类被加载
        //子类被加载

        //反射也会产生主动引用
     //   Class.forName("TestReflected.Son");
        // main类被加载
        //父类被加载
        //子类被加载

        //不会产生类的引用的方法
     //   System.out.println(Son.b);
        //main类被加载
        //父类被加载
        //2
        
        //数组不会加载类
        Son[] array=new Son[5];
    }
}

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;
}

类加载器

类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后再堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口；
类缓存：标准的JavaSE类加载器可以按照要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间，不过jvm垃圾回收机制可以回收这些Class对象；

package TestReflected;

public class Test05 {
    public static void main(String[] args) throws Exception {

        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);

        //获取系统类加载器的父类加载器-->扩展类加载器
        ClassLoader parent=systemClassLoader.getParent();
        System.out.println(parent);

        //获取扩展类加载器的父类加载器-->根加载器
        ClassLoader parent1= parent.getParent();
        System.out.println(parent1);

        //测试当前类是哪个加载器加载的
        ClassLoader classLoader= Class.forName("TestReflected.Test05").getClassLoader();
        System.out.println(classLoader);

        //测试当前类是哪个类加载的
        ClassLoader classLoader2 =Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader2);

        //如何获取系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }
}

获取运行时类的完整结构

package TestReflected;

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

//获得类的信息
public class Test06 {
    private int age=10;
    String name="yan";
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {

        Class c1=Class.forName("TestReflected.Test06");  //包名.类名（这里获取的是类中的东西）


        //获得类的名字
        System.out.println(c1.getName());
        System.out.println(c1.getSimpleName());

        //获得类的属性
        Field[] fields = c1.getFields();  //只能找到public属性
//        for (Field field1 : field) {
//            System.out.println(field);
//        }

        fields=c1.getDeclaredFields();
        for (Field field1 : fields) {
            System.out.println(field1);
        }


        //获得指定属性的值
        Field name=c1.getDeclaredField("name");
        System.out.println(name);

        //获得类的方法
        Method[] methods = c1.getMethods();  //获得本类及其父类的全部Public方法
        for (Method method : methods) {
            System.out.println("正常的："+method);
        }
        Method[] declaredMethods = c1.getDeclaredMethods(); //获得本类的所有方法
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }

        //获得指定的方法

        Method getName =c1.getMethod("getName",null);
        Method setName =c1.getMethod("setName",String.class);
        System.out.println(getName);
        System.out.println(setName);

        //获得指定的构造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        Constructor[] declaredConstructors = c1.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }

        Constructor declaredConstructor = c1.getDeclaredConstructor(int.class,String.class);
        System.out.println(declaredConstructor);
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}