【注解和反射--2】

得到Class类的几种方式

package reflection;
​
//测试Class类的创建方式有哪些
public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是："+person.name);
​
        //方式1：通过对象获得
        Class c1 = person.getClass();
​
        //方式2：forname获得
        Class c2 = Class.forName("reflection.Student");
​
        //方式3：通过类名.class获得
        Class c3 = Student.class;
        //方式4：基本内置类型的包装类都有一个Type属性
        Class c4 = Integer.TYPE;
​
        //获得父类类型
        Class c5 = c1.getSuperclass();
        
​
    }
​
}
class Person{
    public String name;
​
    public Person(String name) {
        this.name = name;
    }
​
    public Person() {
    }
​
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Student extends Person{
    public Student() {
        this.name = "学生";
    }
}
class Teather extends Person{
    public Teather(){
        this.name = "老师";
    }
}

所有类型的Class对象

package reflection;
​
import javax.xml.bind.Element;
import java.lang.annotation.ElementType;
//所有类型的class
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 = Override.class;//注解
        Class c6 = ElementType.class;//枚举类型
        Class c7 = Integer.class;//基本数据类型
        Class c8 = void.class;//void
        Class c9 = Class.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.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

类的加载与ClassLoader

加载 、链接、初始化

类什么时候初始化？

package reflection;
​
//测试类什么时候会初始化
public class Test05 {
    static {
        System.out.println("Main类被加载");
    }
​
    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动引用
//        Son son = new Son();
        //反射也会产生主动引用
//        Class.forName("reflection.Son");
        //不会产生类的引用的方法
//        System.out.println(Son.b);
​
//        Son[] array = new Son[10];
        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 reflection;
​
public class Test06 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);
        //获取系统类加载器的父类加载器-->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println(parent);
        //获取扩展类加载器的父类加载器-->根加载器(c/c++)
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);
​
        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Class.forName("reflection.Test06").getClassLoader();
        System.out.println(classLoader);
        //测试jdk内置的类是谁加载的
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);
​
        //如何获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
        /*
        D:\java\jdk1.8\jre\lib\charsets.jar;
        D:\java\jdk1.8\jre\lib\deploy.jar;
        D:\java\jdk1.8\jre\lib\ext\access-bridge-64.jar;
        D:\java\jdk1.8\jre\lib\ext\cldrdata.jar;
        D:\java\jdk1.8\jre\lib\ext\dnsns.jar;
        D:\java\jdk1.8\jre\lib\ext\jaccess.jar;
        D:\java\jdk1.8\jre\lib\ext\jfxrt.jar;
        D:\java\jdk1.8\jre\lib\ext\localedata.jar;
        D:\java\jdk1.8\jre\lib\ext\nashorn.jar;
        D:\java\jdk1.8\jre\lib\ext\sunec.jar;
        D:\java\jdk1.8\jre\lib\ext\sunjce_provider.jar;
        D:\java\jdk1.8\jre\lib\ext\sunmscapi.jar;
        D:\java\jdk1.8\jre\lib\ext\sunpkcs11.jar;
        D:\java\jdk1.8\jre\lib\ext\zipfs.jar;
        D:\java\jdk1.8\jre\lib\javaws.jar;
        D:\java\jdk1.8\jre\lib\jce.jar;
        D:\java\jdk1.8\jre\lib\jfr.jar;
        D:\java\jdk1.8\jre\lib\jfxswt.jar;
        D:\java\jdk1.8\jre\lib\jsse.jar;
        D:\java\jdk1.8\jre\lib\management-agent.jar;
        D:\java\jdk1.8\jre\lib\plugin.jar;
        D:\java\jdk1.8\jre\lib\resources.jar;
        D:\java\jdk1.8\jre\lib\rt.jar;
        D:\java\code\JavaSE\out\production\base grammar;
        D:\IDEA\IntelliJ IDEA Community Edition 2024.1.4\lib\idea_rt.jar
​
         */
        //双亲委派机制
        
    }
}

获取类运行时结构

package reflection;
​
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
​
//获得类的信息
public class Test07 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        Class c1 = Class.forName("reflection.User");
​
​
        //获得类的名字
        System.out.println(c1.getName());//获得包名+类名
        System.out.println(c1.getSimpleName());//获得类名
​
        //获得类的属性
        //.getDeclaredFields()可以找到全部的属性，而.getFields()只能找到public的属性
        Field[] fields = c1.getDeclaredFields();
​
        for (Field field : fields) {
            System.out.println(field);
        }
​
        //获得指定属性的值
​
        Field name = c1.getDeclaredField("name");
        System.out.println(name);
​
        //获得类的方法
        Method[] methods = c1.getMethods();//获得本类及其父类的全部public方法
        for (Method method : methods) {
            System.out.println("正常的:"+method);
        }
        methods = c1.getDeclaredMethods();//只获得本类的所用方法
        for (Method method : methods) {
            System.out.println("getDeclaredMethods"+method);
        }
        Method getName = c1.getDeclaredMethod("getName", null);
        Method setName = c1.getDeclaredMethod("setName", String.class);
        System.out.println(getName);
        System.out.println(setName);
​
        //获得构造器
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        constructors = c1.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
​
        Constructor constructor = c1.getConstructor(String.class,int.class,int.class);
        System.out.println("指定："+constructor);
​
    }
}