← 返回学习路线

SYSTEM

获取元素

Java基础获取元素system
src/content/notes/system/获取元素.md

获取元素

获取类

反射技术的第一步是先得到 Class 类对象,有三种方式获取:

  • 类名.class
  • 类的对象.getClass()
  • Class.forName(“类的全限名”):public static Class<?> forName(String className)

Class 类下的方法:

方法 作用
String getSimpleName() 获得类名字符串:类名
String getName() 获得类全名:包名+类名
T newInstance() 创建 Class 对象关联类的对象,底层是调用无参数构造器,已经被淘汰
public class ReflectDemo{
    public static void main(String[] args) throws Exception {
        // 反射的第一步永远是先得到类的Class文件对象: 字节码文件。
        // 1.类名.class
        Class c1 = Student.class;
        System.out.println(c1);//class _03反射_获取Class类对象.Student

        // 2.对象.getClass()
        Student swk = new Student();
        Class c2 = swk.getClass();
        System.out.println(c2);

        // 3.Class.forName("类的全限名")
        // 直接去加载该类的class文件。
        Class c3 = Class.forName("_03反射_获取Class类对象.Student");
        System.out.println(c3);

        System.out.println(c1.getSimpleName()); // 获取类名本身(简名)Student
        System.out.println(c1.getName()); //获取类的全限名_03反射_获取Class类对象.Student
    }
}
class Student{}

获取构造

获取构造器的 API:

  • Constructor getConstructor(Class… parameterTypes):根据参数匹配获取某个构造器,只能拿 public 修饰的构造器
  • Constructor getDeclaredConstructor(Class… parameterTypes):根据参数匹配获取某个构造器,只要申明就可以定位,不关心权限修饰符
  • Constructor[] getConstructors():获取所有的构造器,只能拿 public 修饰的构造器
  • Constructor[] getDeclaredConstructors():获取所有构造器,只要申明就可以定位,不关心权限修饰符

Constructor 的常用 API:

方法 作用
T newInstance(Object… initargs) 创建对象,注入构造器需要的数据
void setAccessible(true) 修改访问权限,true 攻破权限(暴力反射)
String getName() 以字符串形式返回此构造函数的名称
int getParameterCount() 返回参数数量
Class<?>[] getParameterTypes 返回参数类型数组
public class TestStudent01 {
    @Test
    public void getDeclaredConstructors(){
        // a.反射第一步先得到Class类对象
        Class c = Student.class ;
        // b.定位全部构造器,只要申明了就可以拿到
        Constructor[] cons = c.getDeclaredConstructors();
        // c.遍历这些构造器
        for (Constructor con : cons) {
            System.out.println(con.getName()+"->"+con.getParameterCount());
        }
    }
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.反射第一步先得到Class类对象
        Class c = Student.class ;
        // b.定位某个构造器,根据参数匹配,只要申明了就可以获取
        //Constructor con = c.getDeclaredConstructor(); // 可以拿到!定位无参数构造器!
        Constructor con = c.getDeclaredConstructor(String.class, int.class); //有参数的!!
        // c.构造器名称和参数
        System.out.println(con.getName()+"->"+con.getParameterCount());
    }
}
public class Student {
    private String name ;
    private int age ;
    private Student(){
        System.out.println("无参数构造器被执行~~~~");
    }
    public Student(String name, int age) {
        System.out.println("有参数构造器被执行~~~~");
        this.name = name;
        this.age = age;
    }
}
//测试方法
public class TestStudent02 {
    // 1.调用无参数构造器得到一个类的对象返回。
    @Test
    public void createObj01() throws Exception {
        // a.反射第一步是先得到Class类对象
        Class c = Student.class ;
        // b.定位无参数构造器对象
        Constructor constructor = c.getDeclaredConstructor();
        // c.暴力打开私有构造器的访问权限
        constructor.setAccessible(true);
        // d.通过无参数构造器初始化对象返回
        Student swk = (Student) constructor.newInstance(); // 最终还是调用无参数构造器的!
        System.out.println(swk);//Student{name='null', age=0}
    }

    // 2.调用有参数构造器得到一个类的对象返回。
    @Test
    public void createObj02() throws Exception {
        // a.反射第一步是先得到Class类对象
        Class c = Student.class ;
        // b.定位有参数构造器对象
        Constructor constructor = c.getDeclaredConstructor(String.class , int.class);
        // c.通过无参数构造器初始化对象返回
        Student swk = (Student) constructor.newInstance("孙悟空",500); // 最终还是调用有参数构造器的!
        System.out.println(swk);//Student{name='孙悟空', age=500}
    }
}


获取变量

获取 Field 成员变量 API:

  • Field getField(String name):根据成员变量名获得对应 Field 对象,只能获得 public 修饰
  • Field getDeclaredField(String name):根据成员变量名获得对应 Field 对象,所有申明的变量
  • Field[] getFields():获得所有的成员变量对应的 Field 对象,只能获得 public 的
  • Field[] getDeclaredFields():获得所有的成员变量对应的 Field 对象,只要申明了就可以得到

Field 的方法:给成员变量赋值和取值

方法 作用
void set(Object obj, Object value) 给对象注入某个成员变量数据,obj 是对象,value 是值
Object get(Object obj) 获取指定对象的成员变量的值,obj 是对象,没有对象为 null
void setAccessible(true) 暴力反射,设置为可以直接访问私有类型的属性
Class getType() 获取属性的类型,返回 Class 对象
String getName() 获取属性的名称
public class FieldDemo {
    //获取全部成员变量
    @Test
    public void getDeclaredFields(){
        // a.先获取class类对象
        Class c = Dog.class;
        // b.获取全部申明的成员变量对象
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName()+"->"+field.getType());
        }
    }
    //获取某个成员变量
    @Test
    public void getDeclaredField() throws Exception {
        // a.先获取class类对象
        Class c = Dog.class;
        // b.定位某个成员变量对象 :根据名称定位!!
        Field ageF = c.getDeclaredField("age");
        System.out.println(ageF.getName()+"->"+ageF.getType());
    }
}
public class Dog {
    private String name;
    private int age ;
    private String color ;
    public static String school;
    public static final String SCHOOL_1 = "宠物学校";

    public Dog() {
    }

    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
}
//测试方法
public class FieldDemo02 {
    @Test
    public void setField() throws Exception {
        // a.反射的第一步获取Class类对象
        Class c = Dog.class ;
        // b.定位name成员变量
        Field name = c.getDeclaredField("name");
        // c.为这个成员变量赋值!
        Dog d = new Dog();
        name.setAccessible(true);
        name.set(d,"泰迪");
        System.out.println(d);//Dog{name='泰迪', age=0, color='null'}
        // d.获取成员变量的值
        String value = name.get(d)+"";
        System.out.println(value);//泰迪
    }
}

获取方法

获取 Method 方法 API:

  • Method getMethod(String name,Class…args):根据方法名和参数类型获得方法对象,public 修饰
  • Method getDeclaredMethod(String name,Class…args):根据方法名和参数类型获得方法对象,包括 private
  • Method[] getMethods():获得类中的所有成员方法对象返回数组,只能获得 public 修饰且包含父类的
  • Method[] getDeclaredMethods():获得类中的所有成员方法对象,返回数组,只获得本类申明的方法

Method 常用 API:

  • public Object invoke(Object obj, Object… args):使用指定的参数调用由此方法对象,obj 对象名
public class MethodDemo{
    //获得类中的所有成员方法对象
    @Test
    public void getDeclaredMethods(){
        // a.先获取class类对象
        Class c = Dog.class ;
        // b.获取全部申明的方法!
        Method[] methods = c.getDeclaredMethods();
        // c.遍历这些方法
        for (Method method : methods) {
            System.out.println(method.getName()+"->"
                    + method.getParameterCount()+"->" + method.getReturnType());
        }
    }
    @Test
    public void getDeclardMethod() throws Exception {
        Class c = Dog.class;
        Method run = c.getDeclaredMethod("run");
        // c.触发方法执行!
        Dog d = new Dog();
        Object o = run.invoke(d);
        System.out.println(o);// 如果方法没有返回值,结果是null
        
		//参数一:方法名称   参数二:方法的参数个数和类型(可变参数!)
        Method eat = c.getDeclaredMethod("eat",String.class);
        eat.setAccessible(true); // 暴力反射!
        
       	//参数一:被触发方法所在的对象  参数二:方法需要的入参值
        Object o1 = eat.invoke(d,"肉");
        System.out.println(o1);// 如果方法没有返回值,结果是null
    }
}

public class Dog {
    private String name ;
    public Dog(){
    }
    public void run(){System.out.println("狗跑的贼快~~");}
	private void eat(){System.out.println("狗吃骨头");}
	private void eat(String name){System.out.println("狗吃"+name);}
	public static void inAddr(){System.out.println("在吉山区有一只单身狗!");}
}

暴力攻击

泛型只能工作在编译阶段,运行阶段泛型就消失了,反射工作在运行时阶段

  1. 反射可以破坏面向对象的封装性(暴力反射)
  2. 同时可以破坏泛型的约束性
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        List<Double> scores = new ArrayList<>();
        scores.add(99.3);
        scores.add(199.3);
        scores.add(89.5);
        // 拓展:通过反射暴力的注入一个其他类型的数据进去。
        // a.先得到集合对象的Class文件对象
        Class c = scores.getClass();
        // b.从ArrayList的Class对象中定位add方法
        Method add = c.getDeclaredMethod("add", Object.class);
        // c.触发scores集合对象中的add执行(运行阶段,泛型不能约束了)
        add.invoke(scores, "字符串");
        System.out.println(scores);
    }
}