｛学习笔记｝［反射］

反射

基本概念

定义：

反射就是加载累，并解刨出泪的各个组成部分（如成员变量，方法，构造方法等）

组成：

分为两部分：加载类 解剖类
加载类:（三种方法）
1.Class clazz=Class.forName(“/day01/src/reflact/Demo1.java”);
2.class clazz1=new Person().getClass();
3.Class clazz2=Person.class;
解剖类：
Class对象提供了各种方法 解剖出的成员分别使用Constructor (构造函数) Method(方法） Field(成员变量)对象表示

解剖出来干什么？

去使用！
构造函数——创建对象
字段——数据
方法——调用

反射

反射的构造方法:

被反射的类：
public class Person {
String name;
public Person(){
System.out.println(“person”);
name=”创建成功”;
}
public Person(String name){
System.out.println(“person name”);
}
private Person(List list){
System.out.println(“person list”);
}

        public void aa1(){
            System.out.println("aa1");
        }
        public void aa1(String name,int password){
            System.out.println(name+":"+password);
        }
        public Class[] aa1(String name,int[] password){
            return new Class[](String.class);

        }
        private void aa1(InputStream in){
            System.out.println(in);
        }
        public void aa1(int num){
            System.out.println(num);
        }

    }

反射的构造方法：
public class Demo2 {

    @Test
    public void test1() throws Exception{
        Class clazz=Class.forName("reflact.Person");//加载类
        Constructor c=clazz.getConstructor(null);//获取类的无参构造函数
        Person p = (Person)c.newInstance(null);//利用获取到的构造函数创建对象
        System.out.println(p.name);
    }



    @Test
    public void test2() throws Exception{
        Class clazz = Class.forName("reflact.Person");
        Constructor c= clazz.getConstructor(String.class);
        Person p = (Person)c.newInstance("xxxx");

    }
    //如果构造函数是私有的，可以采用暴力破解
    @Test
    public void test4() throws Exception{
        Class clazz =Class.forName("reflact.Person");
        Constructor c = clazz.getDeclaredConstructor(List.class);
        c.setAccessible(true);//暴力反射
        Person p =(Person)c.newInstance(new ArrayList());
        System.out.println(p.name);

    }

    @Test
    public void test5() throws Exception{
        Class clazz = Class.forName("reflact.Person");
        Person p = (Person)clazz.newInstance();//构建对象的第二种方法
    }
}

构造方法总结：

public 方法 包访问方法可以用getConstructor来获取，但是private 只能用getDeclaredConstructor来访问

反射的方法：

import java.lang.reflect.Method;

import org.junit.Test;

public class Demo3 {

    //反射类的方法：public  void aa1（）
    @Test
    public void test1() throws Exception{
        Person p =new Person();
        Class clazz=Class.forName("reflact.Person");
        Method method =clazz.getMethod("aa1",null);
        method.invoke(p, null);// 调用方法 p_对象,方法的参数 

    }
    //反射类的方法：public  void aa1（String name,int password）
        @Test
        public void test2() throws Exception{
            Person p =new Person();
            Class clazz=Class.forName("reflact.Person");
            Method method =clazz.getMethod("aa1",String.class,int .class);
            method.invoke(p, "zxx",99);// 调用方法 p_对象,方法的参数 

        }
/*不会！
        //反射类的方法：public  Class[] aa1（String name,int password）
        @Test
        public void test3() throws Exception{
            Person p =new Person();
            Class clazz=Class.forName("reflact.Person");
            Method method =clazz.getMethod("aa1",String.class,int .class);
            method.invoke(p, "zxx",99);// 调用方法 p_对象,方法的参数 

        }
*/
        //反射类的方法：public  void aa1（Inputstream in）
                @Test
                public void test4() throws Exception{
                    Person p =new Person();
                    Class clazz=Class.forName("reflact.Person");
                    Method method =clazz.getMethod("aa1",String.class,int .class);
                    method.invoke(p, "zxx",99);// 调用方法 p_对象,方法的参数 

                }
}

静态方法的反射

public void test5() throws Exception{
    //Person p = new Person();静态方法不需要对象
    Class class =Class.forName("类名");//加载类
    Method method =clazz.getMethod("aa1",int.class);
    method.invoke(nul,23);
    }       

main的反射

残留问题＝ ＝！

反射类的字段

反射代码

import java.lang.reflect.Field;

public class Demo5 {
        //反射字段 public String name = "aaaa";
    public void test1() throws Exception{
        Person p = new Person();//为了传递一个对象
        Class clazz = Class.forName("reflact.Person");
        Field f = clazz.getField("name");
        String name=(String)f.getName();
        System.out.println(name);
        Class type = f.getType();
        System.out.println(type);//获取字段的类型
    }
}

可以自行判断字段类型

if(type.equals（String.class))

字段赋值

f.set(对象，“”);

静态字段的反射

居然也需要传入一个对象进去