1.在Java中，反射是通过包 java.lang.reflect.* 来实现的。

2.对反射的理解：Reflection被视为动态语言的关键，反射机制允许程序在执行期间借助Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法

 

首先定义一个Person类

public class Person {

    public String name;
    public int age;
    public String sex;
    private int fd;

    public Person() {
        System.out.println(
                "dfdfa"
        );
    }

    public Person(String name, int age,String sex) {
        System.out.println("fdfd");
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                ", fd=" + fd +
                '}';
    }

    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;
    }

    private String show(String nation) {
        System.out.println("我是一个"+nation+"人");
        return nation;
    }

    private static void showDesc() {
        System.out.println("我爱北京天安门");
    }
}

 

 

 

 

3.获取class实例的几种方式：（Person代表一个类名）

   

1.Class<类名> clazz1 = 类名.class;

     2.Person p1 = new Person();
      Class<? extends Person> clazz2 = p1.getClass();

    
     3.Class<?> clazz3 = Class.forName("Person");

     4.ClassLoader classLoader = Reflact.class.getClassLoader();
      Class<?> clazz4 = classLoader.loadClass("Person");

 

 

 

4.获取运行时类的完整结构：

    1）获取（操作）某个类（Person）的指定属性：

 

Class clazz = Person.class;
                      Person o = (Person) clazz.newInstance();//生成一个当前类（Person）的对象实例
                      Field name = clazz.getDeclaredField("name");//获取class实例中的所有字段，不包括所继承的类中的字段
                      name.setAccessible(true);//让运行时类中的非public方法可以进行修改
                      name.set(o,"王虎");
                      System.out.println(name.get(o));

 

 

 

    2）获取（操作）某个类（Person）的方法(非静态方法，需要创建类的对象实例)：


Class clazz = Person.class;
                        //创建运行时类的对象
                        Person o = (Person) clazz.newInstance();
                        //获取指定的某个方法
                        //getDeclaredMethod() :参数一：指定获取的方法的名称 参数二：指定获取的方法的形参列表
                        Method show = clazz.getDeclaredMethod("show", String.class);
                        show.setAccessible(true);
                        //invoke() 参数一：方法调用者 参数二：给方法形参赋值的实参
                        //invoke()方法返回的值即为方法返回值的类型
                        String returns = (String) show.invoke(o, "中国");

 

 

 

3）获取（操作）某个类（Person）的方法(静态方法，不需要创建类的对象实例)：

 

Class clazz = Person.class;
                                                Method showDesc = clazz.getDeclaredMethod("showDesc");//该静态方法是无参的
                                                showDesc.setAccessible(true);
                                                //由于此时showDesc()就是clazz类中的方法（静态方法时属于类的，而非静态方法属于对象，需要知道那个对象），
                                                // 因此方法调用者可以写null或者Person.class,并且invoke()返回值为null
                                                Object invoke = showDesc.invoke(null);

 

 

 

 

4）获取（操作）某个类（Person）的构造器(有参数的)：
Class clazz = Class.forName("Person");
Person o =(Person) clazz.getConstructor(String.class,int.class,String.class).newInstance("A",1,"B");

 其他知识了解

1.反射机制和面向对象中的封装性是不是矛盾的？
  答：不矛盾。封装性提供了公有方法和私有方法，只是建议去使用公有方法。反射机制可以调用私有方法，但是一般调用公有方法更好
 
 2.类的加载过程：程序经过javac.exe命令之后，生成一个或多个字节码文件（.class文件），接着java.exe对某个字节码文件进行解释运行，相当于某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，就称为运行时类，此运行时类，
   就作为Class的一个实例
 
 3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类
 
  4.对Class的理解：
                Class实例对应着加载到内存中的一个运行时类
创建运行时类对象时应该注意的几个点：
1.运行时类中必须要有空参构造器
2.该空参构造器一般是public，可以供外部反射器创造对象，不可以是private

* javaBean一般都要有一个空参构造器
* 一是让外部反射器调用，二是让它的子类进行super()时可以调用空参构造器