标签：System 反射 Java String 36 Class println public name

Java-Day-36

通过反射获取类的结构信息

第一组：java.lang.Class 类

以下说的包含本类和父类 —— 也包括超类等
- 方法属性之类的若是输出时不加 .getName，则都是输出：com.zyz.Zyz()

public class test {
    public static void main(String[] args) {

    }
    @Test
    public void api() throws ClassNotFoundException {
        //        获取Class对象
        Class<?> zyzClass = Class.forName("com.zyz.Zyz");
        //        getName:获取全类名
        System.out.println(zyzClass.getName()); // com.zyz.Zyz
        //        getSimpleName:获取简单类名
        System.out.println(zyzClass.getSimpleName()); // Zyz
        //        getFields:获取所有public修饰的属性,包括本类以及父类
        Field[] fields = zyzClass.getFields();
        for (Field field : fields) {
            System.out.println("本类即父类的public属性: " + field.getName());
        }
        //        getDeclaredFields:获取本类中所有的属性,无视修饰符
        Field[] declaredFields = zyzClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("获取本类中所有的属性(无视修饰符): " + declaredField.getName());
        }
        //        getMethods:获取所有public修饰的方法,包含本类以及父类的
        Method[] methods = zyzClass.getMethods();
        for (Method method : methods) {
            System.out.println("所有的public修饰的方法: " + method.getName()); 
        }
        //        getDeclaredMethods:获取本类中所有方法
        Method[] declaredMethods = zyzClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中所有方法: " + declaredMethod.getName());
        }
        //        getConstructors:获取所有public修饰的构造器，只限本类
        Constructor<?>[] constructors = zyzClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("本类所有public修饰的构造器： " + constructor.getName()); // com.zyz.Zyz
            // 这里只是输出名字，因为是构造器，所以就是类名路径
        }
        //        getDeclaredConstructors:获取本类的任何修饰符的构造器
        Constructor<?>[] declaredConstructors = zyzClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类所有构造器： " + declaredConstructor.getName()); // com.zyz.Zyz
            // 这里只是输出名字，因为是构造器，所以就是类名路径
        }
        //        getPackage:以Package形式返回包全路径
        System.out.println(zyzClass.getPackage()); // package com.zyz
        //        getSuperclass:以Class形式返回父类的全路径
        System.out.println(zyzClass.getSuperclass()); // class com.zyz.Person
        //        getInterfaces:以Class[]形式返回接口信息
        Class<?>[] interfaces = zyzClass.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("接口信息： " + anInterface); // interface 接口路径
        }
        //        getAnnotations:以Annotation[]形式返回注解信息
        Annotation[] annotations = zyzClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息： " + annotation);
        }
    }
}



class Person {
    public String country;
    public void hi() {}
}

interface ABC {}
interface CBA {}

class Zyz extends Person implements ABC, CBA{
//    四种不同访问权限的测试
    public String name;
    protected int age;
    String job;
    private double sal;

//    方法
    public void m1(){}
    protected void m2(){}
    void m3(){}
    private void m4(){}

    public Zyz() {
    }
}

第二组：java.lang.reflect.Field 类

getModifiers：以 int 形式返回修饰符
- 默认修饰符是 0，public 是 1， private 是 2， protected 是 4，static 是 8，final 是 16
- 类似 public static 这样多个的话就是相加，也就是 9
getType：以 Class 形式返回类型
getName：返回属性名

//        getDeclaredFields:获取本类中所有的属性,无视修饰符
Field[] declaredFields = zyzClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
    System.out.println("获取本类中所有的属性(无视修饰符): " + declaredField.getName()
                       + "该属性修饰符值为："  + declaredField.getModifiers()
                       + "该属性的类型为：" + declaredField.getType());
}

第三组：java.lang.reflect.Method 类

getModifiers：以 int 形式返回修饰符
- 默认修饰符是 0，public 是 1， private 是 2， protected 是 4，static 是 8，final 是 16
- 类似 public static 这样多个的话就是相加，也就是 9
getReturnType：以 Class 形式获取返回类型
getName：返回方法名
getParameterTypes：以 Class[] 返回参数类型数组

//        getDeclaredMethods:获取本类中所有方法
Method[] declaredMethods = zyzClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
    System.out.println("本类中所有方法: " + declaredMethod.getName()
                       + "该方法的访问修饰符为：" + declaredMethod.getModifiers()
                       + "该方法返回的类型为：" + declaredMethod.getReturnType());

    //            输出当前这个方法的形参数组情况
    Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
    for (Class<?> parameterType : parameterTypes) {
        System.out.println("该方法的形参类型为：" + parameterType);
    }
}

第四组：java.lang.reflect.Constructor 类

getModifiers：以 int 形式返回修饰符
getName：返回构造器名 ( 全类名 )
getParameterTypes：以 Class[] 返回参数类型数组
此处三个方法在上面都有类似例子

通过反射创建对象

方式一：调用类中的 public 修饰的无参构造器
方式二：调用类中的指定构造器
Class 类相关方法
- newInstance：调用类中的无参构造器，获取对应类的对象
- getConstructor(Class ... clazz)：根据参数列表，获取对应的 public 构造器对象
- getDecalaredConstructor(Class ... clazz)：根据参数列表，获取所有的对应的构造器对象
Constructor 类相关方法
- setAccessible：暴破
- newInstance(Object ... obj)：调用构造器

案例

class User {
    private String name = "zyz";
    private int age = 100;
    
    public User() { // public的无参构造器
    }
    public User(String name) { // public的有参构造器
        this.name = name;
    }
    private User(String name, int age) { // private的有参构造器
        this.name = name;
        this.age = age;
    }

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

通过反射创建某类的对象，要求该类中必须有 public 的无参构造器

//        1. 先获取到User类的Class对象
        Class<?> userClass = Class.forName("com.zyz.User");

//        2. 通过public的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println("无参的赋最初值的构造器 ——> " + o); // 无参的赋最初值的构造器 ——> User{name='zyz', age=100}

通过调用某个特定构造器的方式，实现创建某类的对象

public 的有参构造器
private 的有参构造器

//        3. 通过public的有参构造器创建实例
        /*
            此时的constructor就是：
                public User(String name) { // public的参数列表为一个String的有参构造器
                    this.name = name;
                }
         */
//        3.1. 先获取对应的构造器
        Constructor<?> constructor = userClass.getConstructor(String.class); // 所有String类型的class对象
//        3.2. 再创建实例并传入形参
        Object babaName = constructor.newInstance("霸霸");
        System.out.println("构造器传入新name ——> " + babaName); // 构造器传入新name ——> User{name='霸霸', age=100}


//        4. 通过非public的有参构造器创建实例 ——> 传统方法不行，但反射可以
//        4.1. 得到private的构造器对象
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(String.class, int.class);
//        4.2. 如果是私有的private，就需要暴破 —— 暴力破解，使用反射可以访问private构造器/方法/属性
        constructor1.setAccessible(true);
//        4.3. 创建实例
        Object zyz = constructor1.newInstance("老朱", 125);
        System.out.println("private的构造器 ——> " + zyz); // private的构造器 ——> User{name='老朱', age=125}

通过反射访问类中的成员

静态可不指明对象，Declared 拿所有成员，私有还是要暴破

属性

根据属性名获取 Field 对象
暴破，私有属性也可以访问到
访问
- f.set(o, 值); // o表示对象
- f.get(o); // o表示对象
注意：如果是静态属性，则 set 和 get 中的参数 o 可以写成 null

public class test {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
//        1. 得到User类对应的Class对象
        Class<?> userClass = Class.forName("com.zyz.User");
//        2. 创建对象
        Object o = userClass.newInstance(); // o 的运行类型就是 User
//        3. 使用反射得到属性对象 ———— public
        Field pubName = userClass.getField("name");
        System.out.println(pubName);
        pubName.set(o, "zyz");
        System.out.println("加上共有属性的名称" + o);
        System.out.println(pubName.get(o));
//        4. 使用反射操作age属性 ———— private static
        Field priAge = userClass.getDeclaredField("age");
//        4.1 对私有的只能用Declared才能包含在内，但想使用或者更改，还是需要暴破，否则无法进行操作
        priAge.setAccessible(true);
//        priAge.set(o, 100);
        priAge.set(null, 250); // 对象位置写null也可以，因为age是静态属性
//        ———— 静态是属于所有对象的，在类加载的时候就已经有了，所以null也无妨，写上 o 的写法是因为对象也是可以直接操作静态的
        System.out.println("再加上私有属性的年龄" + o);
        System.out.println("通过 o 获取：" + priAge.get(o));
        System.out.println("因为静态，所以对象部分写null也可获取：" + priAge.get(null));
    }
}

class User {
    public String name;
    private static int age;

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

方法

根据方法名和参数列表获取 Method 方法对象：Method m = clazz.getDeclaredMethod(方法名, XX.class);
- 加上 Declared 可以访问所有的，去掉就只能是 public 共有的了
获取对象：Object o = clazz.newInstance();
暴破：m.setAccessible(true);
访问：Object returnValue = m.invoke(o, 实参列表);
- 就算方法有指定返回值也无用，都是统一用 Object 接收的
注意：如果是静态方法，则 invoke 的参数 o 可以写成 null

public class test {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//        1. 得到User类对应的Class对象
        Class<?> userClass = Class.forName("com.zyz.User");
//        2. 创建对象
        Object o = userClass.newInstance(); // o 的运行类型就是 User
//        3. 调用public的hello方法
//        Method hello = userClass.getMethod("zyz, String.class");
//        3.1 得到hello方法对象
        Method hello = userClass.getDeclaredMethod("hello", String.class); // 有参的话就要加参数
//        3.2 调用
        hello.invoke(o, "zhuYaZhu");
//        4. 调用私有的静态方法
//        4.1 得到say方法对象
        Method say = userClass.getDeclaredMethod("say", String.class, int.class, char.class);
//        4.2 私有 —— 暴破
        say.setAccessible(true);
//        4.3 调用
        System.out.println(say.invoke(o, "zyz", 250, '男'));
//        因为静态所以可以用null
        Object reValue = say.invoke(null, "zhuYaZhu", 100, '男');
//        运行类型还是String(与方法定义的一致)，但返回时还是编译类型Object接收
        System.out.println("运行类型：" + reValue.getClass()); // 
    }
}

class User {
    public String name;
    private static int age;

    public User() {
    }

    private static String say(String n, int a, char c) { // 私有的静态方法
        return n + "的年龄：" + a + "————" + c;
    }

    public void hello(String name) { // 普通方法
        System.out.println("hello" + name);
    }

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

章节练习

通过反射修改私有成员变量，前提：

class PrivateTest {
    private String name = "zyz";
    public String getName(){
        return name;
    }
}

解：

public class test {
    public static void main(String[] args) throws Exception {
        Class<?> cls = Class.forName("com.zyz.PrivateTest");
        Object o = cls.newInstance();
        Method getName = cls.getDeclaredMethod("getName");
        System.out.println(getName.invoke(o));

        Field name = cls.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o, "gaiZyz");
        System.out.println(getName.invoke(o));
    }
}

利用反射和 File 完成以下功能

利用 Class 类的 forName 方法得到 File 类的 class 对象
在控制台打印 File 类的所有构造器
通过 newInstance 的方法创建 File 对象，并创建 E:\mynew.txt 文件
解

public class test {
    public static void main(String[] args) throws Exception {
        //        1. 得class对象
        Class<?> cls = Class.forName("java.io.File");
        Constructor<?>[] declaredConstructors = cls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("File 的构造器：" + declaredConstructor);
            //            getName 后就都是 java.io.File 了
        }
        //        单独的得到自己要用的构造器：public java.io.File(java.lang.String)
        //        2. 拿要用的构造器
        Constructor<?> declaredConstructor = cls.getDeclaredConstructor(String.class);
        String filePath = "E:\\mynew.txt"; // 内存
        //        3. 构造器拿到File对象
        Object file = declaredConstructor.newInstance(filePath); // 通过有参构造器进行实例化 —— 创建File对象
        //        4. 拿对象中要用的方法
        Method createNewFile = cls.getDeclaredMethod("createNewFile");
        //        5. 调用方法
        createNewFile.invoke(file);

        //        注意创建文件的正常写法：
        //        File file = new File("E:\\mynew.txt"); // 内存
        //        file.createNewFile(); // 真正创建了文件的方法
    }
}

标签：System,反射,Java,String,36,Class,println,public,name
From： https://www.cnblogs.com/zhu-ya-zhu/p/17578456.html

Java-Day-36（通过反射获取类的结构信息 + 通过反射访问类中的成员 + 章节练习）

Java-Day-36

通过反射获取类的结构信息

第一组：java.lang.Class 类

第二组：java.lang.reflect.Field 类

第三组：java.lang.reflect.Method 类

第四组：java.lang.reflect.Constructor 类

通过反射创建对象

案例

通过反射访问类中的成员

属性

方法

章节练习

相关文章

赞助商

阅读排行

Java-Day-36（ 通过反射获取类的结构信息 + 通过反射访问类中的成员 + 章节练习 ）

Java-Day-36

通过反射获取类的结构信息

第一组：java.lang.Class 类

第二组：java.lang.reflect.Field 类

第三组：java.lang.reflect.Method 类

第四组：java.lang.reflect.Constructor 类

通过反射创建对象

案例

通过反射访问类中的成员

属性

方法

章节练习

相关文章

赞助商

阅读排行

Java-Day-36（通过反射获取类的结构信息 + 通过反射访问类中的成员 + 章节练习）