Java--反射--创建实例&操作属性&操作方法

放射爆破操作实例对象：

通过反射创建对象的两种方式：

创建对象实例的案例　　

package com.model.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/29 21:51
 *
 * 演示 反射机制创建实例对象：
 *
 */
public class ReflectionDemo05 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
//        1.拿到类的Class类对象
        Class<?> aClass = Class.forName("com.model.reflection.Dog");
//        2.通过public类型的无参构造函数创建实例对象
        Object o = aClass.newInstance();
        Dog dog= (Dog) o;
        System.out.println(dog.toString());
//        3.通过public类型的有参构造函数
        Constructor<?> constructor = aClass.getConstructor(String.class);
        Object o1 = constructor.newInstance("张三");
        Dog dog1= (Dog) o1;
        System.out.println(dog1.toString());
//        4.通过private类型的有参构造函数
//        Constructor<?> constructor1 = aClass.getConstructor(String.class,int.class); 一定会报错，因为getConstructor是获取public类型的构造方法
        Constructor<?> constructor1 = aClass.getDeclaredConstructor(String.class,int.class);//要想获取private类型的构造器使用必须使用：getDeclaredConstructor()
        constructor1.setAccessible(true); //爆破{暴力破解}： 使用反射也能访问private类型的构造器
        Object o2 = constructor1.newInstance("李四", 18);
        Dog dog2= (Dog) o2;
        System.out.println(dog2.toString());

//      System.out.println(o2);

    }
}
class Dog{
    private String name;
    private int age;

    public Dog() {
    }

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

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

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

反射爆破操作属性：

package com.model.reflection;

import java.lang.reflect.Field;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/29 22:31
 *
 * 反射爆破操作属性
 */
public class ReflectionDemo06 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {

        Class<?> aClass = Class.forName("com.model.reflection.Student");
        Object o = aClass.newInstance();
        System.out.println(o.getClass()); //运行类型就是Student
//        1.获取操作类的public类型的属性
        Field hobby = aClass.getField("hobby");
        hobby.set(o, "打篮球");
        System.out.println(hobby.get(o));
//      2.获取操作类的private类型的属性
        Field nameField = aClass.getDeclaredField("name");
        Field ageField = aClass.getDeclaredField("age");
        nameField.setAccessible(true); //爆破，只有对私有属性进行爆破操作才能进行操作
        ageField.setAccessible(true); //爆破，使私有属性也能访问
        //设置私有属性的值
        nameField.set(o, "张三");
        ageField.set(o, 18);
        System.out.println(nameField.get(o));
        System.out.println(ageField.get(o));
//        3.获取静态私有属性
        Field school = aClass.getDeclaredField("school");
        school.setAccessible(true);
        school.set(null, "河北经贸大学");  //因为属性使静态的它是属于类的，可以不传入对象
//        System.out.println(school.get(o));
        System.out.println(school.get(null)); //获取属性值，要求使静态的属性
    }
}
class Student{
    private String name;
    private int age;

    public String hobby;
    private static String school;
    public String getName() {
        return name;
    }

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

    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }

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

反射爆破操作方法：

package com.model.reflection;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/29 22:53
 *
 * 演示反射操作调用方法
 */
public class ReflectionDemo07 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        Class<?> aClass = Class.forName("com.model.reflection.Boss");
        Object o = aClass.newInstance();
//        1.获取public类型的方法
        Method hi = aClass.getMethod("hi",String.class); //当方法中又参数时，反射获取方法的对象时我们要传入其对应的参数类型
        hi.invoke(o,"张紫韩");
//        2.获取private类型的方法
        Method hello = aClass.getDeclaredMethod("hello",String.class,int.class);
        hello.setAccessible(true);//进行爆破，才能进行访问
        hello.invoke(o,"张紫韩",18);
//        3.获取静态的方法
        Method say = aClass.getDeclaredMethod("say",String.class);
        say.setAccessible(true);
        say.invoke(o,"张紫韩");
//        在反射中，如果方法的又返回值，那么统一返回Object类型的，但是他的运行类型和返回类型一致即（String）
        Object result= say.invoke(null, "张紫韩"); //编译阶段 Object类型
        System.out.println(result.getClass());  //String类型
    }
}
class Boss{
    public int age;
    private static String name;

    @Override
    public String toString() {
        return "Boss{" +
                "age=" + age +
                '}';
    }
    private static String say(String name){
        System.out.println(name+"say,boss");
        return name+"";
    }
    private void hello(String name,int age){
        System.out.println(name+"hello,boss"+age);
    }
    public void hi(String name){
        System.out.println(name+"hi,boss");
    }
}

posted @ 2021-06-29 23:22 张紫韩阅读(283) 评论(0) 编辑收藏举报

刷新页面返回顶部

张紫韩

Java--反射--创建实例&操作属性&操作方法

公告