(java反射 学生简单的笔记)

先创建Student对象

package reflect;

public class Student {
    private String name;
    private int age;

    private Student(){

        System.out.println("The no-argument constructor executes");
    }

    public Student(String name, int age) {
        System.out.println("The parameter constructor executes");
        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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2.利用两个重要的反射然后获取其中的对象个数

该方法可以无关对象里面是私有还是公共都可以直接获取
@Test
        public void getDeclaredConstructors(){

            //a.第一步:获取类对象
            Class c=Student.class;

            //b.提前类中的全部构造器对象
            Constructor[]constructors=c.getDeclaredConstructors();

            //c.遍历构造器
            for (Constructor constructor : constructors) {
                System.out.println(constructor.getName()+"===>"+constructor.getParameterCount());
            }
        }

   //获取单个对象里面的某个构造器   
     @Test
        public void getDeclaredConstructor() throws Exception {

            //a.第一步:获取类对象
            Class c=Student.class;

            //b.提前类中的全部构造器对象
            Constructor cons=c.getDeclaredConstructor(String.class,int.class );//里面的参数以及对应要找的参数个数所寻找的构造器



            System.out.println(cons.getName()+"===>"+cons.getParameterCount());

        }

3.获取参数里面所有信息的反射方法

        //a.第一步:获取类对象
        Class c=Student.class;

        Constructor cons=c.getDeclaredConstructor( );//定义无参构造器
        System.out.println(cons.getName()+"===>"+cons.getParameterCount());

        cons.setAccessible(true);

        Student s = (Student) cons.newInstance();
        System.out.println(s);

        System.out.println("=======================================================");

        Constructor cons1=c.getDeclaredConstructor(String.class,int.class );//定义有参构造器
        System.out.println(cons1.getName()+"===>"+cons1.getParameterCount());

        Student s1= (Student) cons1.newInstance("Animal",1000);
        System.out.println(s1);

//以下为返回结果

    /*reflect.Student===>0
The no-argument constructor executes
Student{name='null', age=0}
=======================================================
reflect.Student===>2
The parameter constructor executes
Student{name='Animal', age=1000}

Process finished with exit code 0*/

4.Filed获取对象名对应的类型

package relfect_field;

/*
* 反射第一步是得到Class对象
*
* 1.Field getField(String name);
*        根据成员变量名获的对应Field对象,只能获得public修饰
*
* 2.Field getDeclareField(String name);
*        根据成员变量名获的对应Field对象,只要申明就可以得到
*
* 3.Field[]getFields();
*        获得所有的成员变量对应的Field对象,只能获得Public的
*
* 4.Field[] getDeclaredFields();
*        获得所有的成员变量对应的Filed对象,只要申明了就可以得到
*
* 小结:
*        获取全部的成员变量:getDeclaredFields();
*        获取某个成员变量:getDeclaredField
*
* */


import org.junit.Test;

import java.lang.reflect.Field;

public class FieldDemo01 {
    /*
    * 获取全部的成员变量
    * Field[]getDeclareFields()
    * 获取所有的成员变量对于的Field对象,只要申明了就可以得到
    * */
    @Test
    public void getDeclaredFields(){

        Class c=Student.class;

        Field[]fields=c.getDeclaredFields();

        for (Field field : fields) {
            System.out.println(field.getName()+"===>"+field.getType());
        }


    }

    /* Field getDeclareField(String name);
       获取某个成员变量
     * */
    @Test
    public void getDeclaredField() throws NoSuchFieldException {

        Class c=Student.class;

        //根据某个名称获取成员变量
        Field f=c.getDeclaredField("age");
        System.out.println(f.getName()+"====>"+f.getType());

        //赋值


    }
}

5.利用反射对其取值和赋值

package relfect_field;

import org.junit.Test;

import java.lang.reflect.Field;

public class FieldDome02 {

    @Test
    public void setField() throws Exception {
        Class c=Student.class;
        //提取某个成员变量
        Field ageF=c.getDeclaredField("age");

        ageF.setAccessible(true);

        //赋值
        Student s=new Student();
        ageF.set(s,18);
        System.out.println(s);

        //取值
        int age= (int) ageF.get(s);

        System.out.println(age);
    }


}

6.Method反射

package relfect_Method;

public class Dog {
    private String name;
    public Dog(){

    }

    public Dog(String name) { this.name = name; }
    public void run(){
        System.out.println("run");
    }
    public void eat(){
        System.out.println("eat");
    }
    private String eat(String name){
        System.out.println("猪神吃"+name);
        return "吃的很开心";
    };
    public static void inAddr(){
        System.out.println("猪神爱吃屎");
    }
    public String getName(){return name;}
    public void setName(String name){this.name=name ;}


}

package relfect_Method;

import org.junit.Test;

import java.lang.reflect.Method;

public class MethodDome01 {

    //反射获取类得到Method方法对象
    /*
    * 1. Method getMethod(String name,Class...args);
    *        根据方法名和参数类型获得对应的方法对象,只能获取public的
    *
    * 2.Method getDeclaredMethod(String name,Class...args);
    *        根据方法名和参数类型获得对应的方法对象,包括private的
    *
    * 3.Method[]getMethod();
    *        获得类中的所有成员方法对象,返回数组,只能获得public修饰的却包含父类的
    *
    * 4.method[]getDeclareMethod();
    *        获得类中的所有成员方法对象,返回数组,只获得本类申明的方法
    *
    * Method的方法执行
    *        Object invoke(Object ojc,Object...args)
    *        参数一:触发的是哪个对象的方法执行.
    *        参数二:args:调用方法时传递的实际参数
    *
    * */


    /*
    * 1.获取类中的所有成员方法对象
    *
    * */
    @Test
    public void getDeclaredMethod(){

        Class c=Dog.class;
        //提取全部方法包括私有的
        Method[]methods=c.getDeclaredMethods();

        for (Method method : methods) {
            System.out.println(method.getName()+"返回值类型 "+method.getReturnType()+"参数名称 "+method.getParameterCount());
        }

    }


    /*
    *
    * 2.获取某个方法对象
    *
    * */
    @Test
    public void GetMethod()throws Exception{

        Class c=Dog.class;
        //提取单个方法包括私有的

        Method m=c.getDeclaredMethod("eat");

        Method m2=c.getDeclaredMethod("eat",String.class);


        m.setAccessible(true);
        m2.setAccessible(true);

          Dog d=new Dog();
          Object o= m.invoke(d);//null
        System.out.println(o);

        m2.invoke(d,"骨头");



    }

}

例子反射作用:

package reflect_zuoyong;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.concurrent.ThreadPoolExecutor;

public class list {
    public static void main(String[] args) throws Exception{

        ArrayList<String>list1=new ArrayList<>();
        ArrayList<Integer>list2=new ArrayList<>();

        list2.add(1);list2.add(2);
        Class c=list2.getClass();
        Method add=c.getDeclaredMethod("add", Object.class);
        add.invoke(list2,"猪神");
        System.out.println(list2);
        



    }
}