(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);

//以下为返回结果

    

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

package relfect_field;




import org.junit.Test;

import java.lang.reflect.Field;

public class FieldDemo01 {
    
    @Test
    public void getDeclaredFields(){

        Class c=Student.class;

        Field[]fields=c.getDeclaredFields();

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


    }

    
    @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方法对象
    


    
    @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());
        }

    }


    
    @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{

        ArrayListlist1=new ArrayList<>();
        ArrayListlist2=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);
        



    }
}