反射基础

类模板类，字段类，方法类，构造器

package testPart1;

import org.w3c.dom.ls.LSOutput;

import java.io.InputStream;
import java.lang.reflect.*;
import java.util.Arrays;

/**
 * 类模板类 Class<T>
 * Class构建T这个类型的模板
 * Class<T> 说明了T类型对应的类 ，T就是解剖类
 * Class<T>类是反射的核心
 *      1.通过模板处理所有类，
 * 获得类的模板类对象--就是类似import 导入文件的对象
 * 常用方法
 *  1.public native boolean isInstance(Object obj) 比较 模板类是否是obj的类的子类
 *  2.public boolean equals(Object obj) 判断是否是同一个模板类  通过各种方式创建的模板类都一样
 *  3.public String getName()  获得模板类的类全限定名
 *  4.public Field getField(String name) 只能获得public修饰的字段
 *  5.public Field getDeclaredField(String name) 获得任何权限修饰的字段
 *  6.public Method getMethod(String name, Class<?>... parameterTypes) 只能获得public修饰的方法
 *  7.public Method getDeclaredMethod(String name, Class<?>... parameterTypes) 获得任何权限修饰的方法
 * 字段类，Field
 *  可以处理模板类对象的对应字段
 *  修改，查看某个对象的字段
 *  相应方法
 *  1.解析类的字段操作
 *  public String getName()  获得字段名
 *  public Class<?> getType()  获得字段的模板类
 *  public int getModifiers()  获得字段修饰符的数值和，所有修饰符
 *  2.对象属性值相关
 *  public void set(Object obj, Object value)  修改obj对象的相应属性值为value
 *  public Object get(Object obj) 得到obj对象的相应属性值
 *
 *  Modifier类，类型
 *  相应方法
 *  public static String toString(int )
 *  可以将修饰符数值转为字符串
 *
 * Method类
 * 相应方法、
 * 1.解析类的方法属性
 * public String getName() 得到方法名
 * public Class<?> getReturnType() 得到方法模板类
 * public int getParameterCount()  得到方法参数数量
 * public Class<?>[] getParameterTypes()  得到方法参数类型数值
 * public Object invoke(Object obj, Object... args) 执行某个对象的方法
 *
 * 注意点
 * 权限相关
 * getDeclaredField
 * getDeclaredMethod
 *
 */

public class Test1 {

    public static void test(){
        /**
         * 1.获取目标类型的类类型（模板类）---这是使用反射的基础
         * 要想使用Class<T>，首先就是将对象的类模板获得到，
         * 方式一 class关键字+类名获取，特点就是直接返回了确定类型，耦合度高
         * 方式二 forName静态方法+类的全限定名获取
         * 方式三 对象的getClass()方法
         * 考虑点 是否需要确定泛型类型，是谁在用，
         *      1.用户使用，就确定类型
         *      2.开发者最好不确定类型
         */
        Class<String> c1 = String.class;
        try {
            Class<?> c2 = Class.forName("java.lang.String");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        String name = "刘";
        Class<?> c3 = name.getClass();

        /**
         * 2.获取目标解析类的字段
         * 默认获取解析类的public字段信息
         * getField只能获得类中是public的
         * 获得一个解析类的所有的字段信息
         */
        User u = new User();
        Class c = u.getClass();
        try {
            Field age = c.getField("age");
            System.out.println("字段名称:"+age.getName());
            System.out.println("字段类型:"+age.getType().getName());
            System.out.println("修饰符的值:"+age.getModifiers());
            System.out.println("修饰符是:"+ Modifier.toString(age.getModifiers()));
            User tmp = (User)c.newInstance();
            System.out.println("设置对象的字段值");
            age.set(tmp,23);
            System.out.println(tmp.age);
            System.out.println(age.get(tmp));
            Field[] files = c.getFields();
            Arrays.stream(files).forEach((f)->{
                System.out.println("字段名："+f.getName()+"，字段类型"+f.getType().getName()+"，字段修饰符"+Modifier.toString(f.getModifiers()));
            });
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        try {
            Field name1 = c.getDeclaredField("name");
            Field[] names = c.getDeclaredFields();
            for (int i = 0,len = names.length;i<len;i++){
                System.out.println("字段修饰符:"+Modifier.toString(names[i].getModifiers())+"字段类型:"+names[i].getType().getName()+"字段名:"+names[i].getName());
            }
            User tmp = (User)c.newInstance();
            System.out.println("设置对象的字段值");
            name1.set(tmp,"张三");
            System.out.println(tmp.name);
            System.out.println(name1.get(tmp));
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 易错点
     * 1.找不到指定类异常 相应.class文件找不到，
     * 错误代码：
     * Class.forName("张三");   Class.forName("String");
     * 错误原因： 参数字符串里面应该是类的全限定名(包名+类名）.1不能是类名2.也不能理解是普通字符串对象
     * 拓展，这个就相当于导包的时候import里面的值；同时需要考虑classpath正确。
     * 2.解剖权限不足
     * 错误代码  String.class.getField("hash"); User.class.getField("name");
     * 错误原因： 权限不够， 1.默认只能解剖public的成员.就理解是public默认允许解剖
     * 拓展，权限修饰符 -> 其它作用
     * 3.修改获得字段值需要先实例化对象（本质是修改一个对象的属性值）
     * 字段可以单独读，但是修改值是修改某个对象的相应字段值。
     *  特殊，属于类的属性也需要通过对象修改，age.set(User,23);错误的
     */

    /**
     * 3.获得解析类的方法，执行对象的方法
     */
    public static void test2() {
        User user = new User();
        Class c = user.getClass();
        try {
//            c.getMethod("方法名","参数类型的解析类".getClass());
            Method info = c.getMethod("info");
            System.out.println("名称："+info.getName());
            System.out.println("返回类型"+info.getReturnType().getName());
            System.out.println("修饰符："+Modifier.toString(info.getModifiers()));
            System.out.println("参数数量："+info.getParameterCount());

            //执行方法
            //调用对象，方法参数
            try {
                info.invoke(user);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            }

            info = c.getMethod("setAge", int.class);
            c.getDeclaredMethod("setAge",int.class);
//            info = c.getMethod("setAge", Integer.class);//不能这样写
            System.out.println("名称："+info.getName());
            System.out.println("返回类型"+info.getReturnType().getName());
            System.out.println("修饰符："+Modifier.toString(info.getModifiers()));
            System.out.println("参数数量："+info.getParameterCount());
            System.out.println("第一个参数类型："+info.getParameterTypes()[0].getName());

            try {
                info.invoke(user,20);
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
                throw new RuntimeException(e);
            }
            user.info();
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 4.通过反射创建对象
     * 获得对象的构造器对象
     * java默认的构造方法类型
     */
    public static void test3() {
        User u = new User();
        Class c  = u.getClass();
        Constructor con =null;
        try {
            con = c.getConstructor();
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
        //获得构造方法属性

        //构造方法权限
        System.out.println("构造方法权限为："+Modifier.toString(con.getModifiers()));

        //打印参数类型
        Class[] para = con.getParameterTypes();
        if (null!=para){
            for (int i = 0,len=para.length;i<len;i++){
                System.out.println(para[i].getTypeName());
            }
        }
        //执行构造方法
        try {
            User user = (User)con.newInstance();
            user.setAge(20);
            System.out.println(user.getAge());
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }

        try {
            con = c.getConstructor(String.class,int.class);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        }
        //获得构造方法属性

        //构造方法权限
        System.out.println("构造方法权限为："+Modifier.toString(con.getModifiers()));

        System.out.println("参数列表为:");
        //打印参数类型
        para = con.getParameterTypes();
        if (null!=para){
            for (int i = 0,len=para.length;i<len;i++){
                System.out.print(para[i].getTypeName()+",");
            }
        }
    }
    /**
     * 5.类模板其它方法
     */

    public static void main(String[] args) {
        /**
         * 类模板的路径
         * getResource(""),得到模板类的绝对路径，其实就是.class文件的父目录--路径中可以包含包
         * getSimpleName(),得到模板类的名字，不带包名，区别getName()获得类的全限定名
         */

        Class u = User.class;
        Class s = Student.class;
        Student student = new Student();
        User user = new User();
        System.out.println(u.getResource(""));
        System.out.println(u.getSimpleName());

        /**
         * equals(Object )和isInstance(Object )方法
         * equals用于比较两个模板类是否相等 1.实际是判断的地址2.一个类的模板类只有一个地址
         * isInstance用于模板类和非模板类的比较， 可类比instanceof
         * 1.判断模板类是否是对象父（爷爷，祖先）类的模板类和是对象的模板类，
         *      反过来理解对象是否是模板类处理的类的子类，或者本身，或者孙子，或者后代。
         * 2.可以替代 instanceof
         *
         */

        System.out.println(u.equals(user));//false
        System.out.println(s.equals(student));//false

        System.out.println(u.equals(user.getClass()));//true
        System.out.println(user.getClass().equals(u));//true

        System.out.println(u.equals(s));//false
        System.out.println(s.equals(u));//false

        System.out.println(s.isInstance(u));//false
        System.out.println(u.isInstance(s));//false

        System.out.println(s.isInstance(user));//false
        System.out.println(s.isInstance(student));//true

        System.out.println(u.isInstance(user));//true
        System.out.println(u.isInstance(student));//true

        Class o = Object.class;
        System.out.println(o.isInstance(user));//true
        System.out.println(o.isInstance(student));//true

        System.out.println(user instanceof User);//true
        System.out.println(user instanceof Student);//false

        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof User);//true
        System.out.println(student instanceof Object);//true
    }
}

 2022/9/13

　　反射和类构造

　　通过反射可以得到类模板，在创建类模板的时候会实例化类的静态方法，初始化静态成员,执行静态代码块的代码

案例就是：注册 jdbc驱动的时候只需要写

　　　Class.forName("com.mysql.cj.jdbc.Driver");

然后会自动把类构造出来，就能注册驱动。