反射

马上就到了一个我自以为很会，但其实拿过来一个新的代码就完全不知道怎么回事儿的，知识点了。

先写另外一个重要的点。

（1）当编译器运行时，还未知要加载的类，那么这时通过反射的方式来获取类中的属性，方法，构造方法

（2）适用场合：java中的三大框架

（3）反射应用：给定一个java文件的完整路径，进而获取该文件中的信息//连接数据库重点讲解

（4）反射的实现：（java.lang.reflect.*)

//1、获取Class类对象

//2、通过Class对象调取Field，Method，等对象的方法

//3、对属性或方法进行操作

（5）获取class对象的方法

<1>对象名.getClass();

示例：Student stu = new Student();

Class cla = stu.getClass();

<2>类名.class

示例：Class cla = User.class

<3>Class.forName("类的完整路径“）

示例：class cla = Class.forName("test.User");

(6)

Field[] f =cla.getDeclaredFields();//获取属性

Method[] m= cla.getDeclaredMethods();//获取方法

Constructor[] cons = cla.getConstructors();//获取构造方法

(7)通过Class 对象创建类的对象

<1>Class 类的对象调用无参构造

Object obj=cla.newInstance();

<2>调用有参构造

Constructor c = cla.getConstructor(new Class[] {int.class});

注：调用哪个有参构造，就把该构造的van书类型.class传入该方法

Object o = c.newInstance(new Object[]{12});

注：将对应构造需要的实参传入

（8）获取属性值：

Object get(对象名);//获取引用数据类型的值

XXX getXXX(对象名);//获取基本数据类型的值

示例：Class cla = Class.forName("a.User");

cla.getField("属性名");

F.get(class.newInstance());//获取引用数据类型

（9）修改属性的访问权限：

setAccessible(true);//利用这个可修改私有成员。但是这个方法不可以被用户调用

（10）反射获取方法

步骤：<1>获取Method对象

//调用无参方法，cla表示Class的对象名,s表示方法名

Method m = cla.getDeclaredMethod(String s);

//调用有参方法

Method m1 = cla.getDeclaredMethod(s,new Class[]{});

<2>执行对应方法

//无参方法,obj表示被反射类的对象名

M.invoke(obj)；

//有参方法

M1.invoke(obj,new Object[]{});

注：invoke方法会返回Object类型值，如果被执行的方法是有返回值的，那么需要进行接收并，强转

示例：String s = (String ) m2.invoke(obj);//无参有返回值的方法

呃，本来是想直接放大招儿的，还是老实点儿吧，

但是确实自己写的例子太水了，而且没什么意义跟营养。。。

package ReflectionPart;

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

public class ReflectionDemo {
    public static void main(String[] args) {
        
        //为了实现这个事儿，得有一个用于反射的类。
        //印象中有三种可以得到当前类对象的方式。
        
        try {
            Class<Teacher> c = (Class<Teacher>) Class.forName("ReflectionPart.Teacher");//握草，竟然不是 com.letben.Teacher
            Teacher teacher = c.newInstance();
            //这种属性因为是 private 的所以 要用方法来设置
            teacher.setTeacherName("letben");
            System.out.println(teacher);
            teacher.numberOfArms=2;
            System.out.println("胳膊的数量是可以看见的，所以 写成共有的了，公有的属性就是可以直接操作的了");
            //得到方法们
            Method[] declaredMethods = c.getDeclaredMethods();//这个是 部分方法。涵盖了当前类的各种方法。
            for (Method method : declaredMethods) {
                System.out.println(method);
            }
            System.out.println("--------------");
            //开始 看了半天还没看懂，一看返回值就基本明白了，就是 根据
            Method method = c.getMethod("getTeacherId",new Class[]{});//如果没有参数 后面这里 不写也行，但是 还是 建议写上这么一个 东西
            System.out.println(method);
            Method method2 = c.getMethod("setTeacherId", new Class[]{int.class});//这里面 注意下，int.class 跟 Integer.class 是不一样的
            System.out.println(method2);
            //得到方法 以后 调用方法。
            method2.invoke(teacher, 32);
            
            System.out.println(teacher);
            
            
            System.out.println("=================");
            Method[] methods = c.getMethods();//这个 是所有的方法。包括好多从父类继承过来的各种方法。object 那一级的
            for (Method method3 : methods) {
                System.out.println(method3);
            }
            System.out.println("++++++++++++++++");
            
            Field[] fields = c.getFields();
            for (Field field : fields) {
                System.out.println(field);
            }
            System.out.println("________________");
            Field[] declaredFields = c.getDeclaredFields();
            for (Field field : declaredFields) {
                System.out.println(field);
            }
            
            
            
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

}

老师类：

package ReflectionPart;

public class Teacher {
    private int teacherId;
    private int teacherAge;
    private String teacherName;
    public int numberOfArms;
    public int getTeacherId() {
        return teacherId;
    }
    public void setTeacherId(int teacherId) {
        this.teacherId = teacherId;
    }
    public int getTeacherAge() {
        return teacherAge;
    }
    public void setTeacherAge(int teacherAge) {
        this.teacherAge = teacherAge;
    }
    public String getTeacherName() {
        return teacherName;
    }
    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }
    @Override
    public String toString() {
        return "Teacher [teacherId=" + teacherId + ", teacherAge=" + teacherAge + ", teacherName=" + teacherName
                + ", numberOfArms=" + numberOfArms + "]";
    }
    public Teacher(int teacherId, int teacherAge, String teacherName, int numberOfArms) {
        super();
        this.teacherId = teacherId;
        this.teacherAge = teacherAge;
        this.teacherName = teacherName;
        this.numberOfArms = numberOfArms;
    }
    public Teacher() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    

}

运行结果：

Teacher [teacherId=0, teacherAge=0, teacherName=letben, numberOfArms=0]
胳膊的数量是可以看见的，所以写成共有的了，公有的属性就是可以直接操作的了
public java.lang.String ReflectionPart.Teacher.toString()
public void ReflectionPart.Teacher.setTeacherName(java.lang.String)
public int ReflectionPart.Teacher.getTeacherId()
public void ReflectionPart.Teacher.setTeacherId(int)
public int ReflectionPart.Teacher.getTeacherAge()
public void ReflectionPart.Teacher.setTeacherAge(int)
public java.lang.String ReflectionPart.Teacher.getTeacherName()
--------------
public int ReflectionPart.Teacher.getTeacherId()
public void ReflectionPart.Teacher.setTeacherId(int)
Teacher [teacherId=32, teacherAge=0, teacherName=letben, numberOfArms=2]
=================
public java.lang.String ReflectionPart.Teacher.toString()
public void ReflectionPart.Teacher.setTeacherName(java.lang.String)
public int ReflectionPart.Teacher.getTeacherId()
public void ReflectionPart.Teacher.setTeacherId(int)
public int ReflectionPart.Teacher.getTeacherAge()
public void ReflectionPart.Teacher.setTeacherAge(int)
public java.lang.String ReflectionPart.Teacher.getTeacherName()
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
++++++++++++++++
public int ReflectionPart.Teacher.numberOfArms
________________
private int ReflectionPart.Teacher.teacherId
private int ReflectionPart.Teacher.teacherAge
private java.lang.String ReflectionPart.Teacher.teacherName
public int ReflectionPart.Teacher.numberOfArms