反射（就是为了在程序运行时获取类的信息并操作）

1.为什么要有反射

反射技术对于java来讲更多的是解决未知类型和动态编程的问题，如：1.项目根据用户的选择创建一个子类，并以多态技术的父类型存在在程序中，而我想拿到具体的子类型进行操作，即未知类型2.程序在编译期并不能确认初始化对象的类型，比如程序读取文件和远程调用第三方接口时，在编译期这些都是未知的，我们如何获取这些类型，而且能保证程序不被打断正常走下去，即动态编程

2.动态编程的前置条件Class对象（此处涉及类的加载机制）

2.1什么是Class对象

在程序运行过程中，保存了某个具体类有关的类信息的一个特殊的对象

2.2Class对象的特点

1. 由系统创建，每一个加载到jvm的类都会有一个对应的Class类对象
2. 每一个具体类的Class类对象都是唯一的，并且对应一个.class文件
3. 这个Class类对象包含了类的所有结构信息
4. 上述类的概念是指类型，类、接口、枚举、数组、注解、基本数据类型等，它们都有Class类对象

2.3如何获取Class对象

1. 已知具体类：Class cs = A.class;
2. 已知具体的实例：Class cs = a.getClass();
3. 已知一个类的全类名，且该类在类路径下： Class cs = Class.forName(“java.lang.String”)
4. 通过类加载器获取(也需要全类名)： ClassLoader cl= this.getClass().getClassLoader(); Class cs = cl.loadClass(“java.lang.String”)

3. 如何使用反射

3.1 创建运行时类的实例

//前置类
@SuppressWarnings("no")
public class A {

    public boolean bln;

    public void test(String str) {
        System.out.println(str);
    }
}

class B extends A {

    public String name;

    public void hello(String str) {
        System.out.println("hello" + str);
    }
}

public class ATest {
    public static void main(String[] args) {
        try {
            B b = new B();
            //通过反射创建一个新的实例
            B b1 = b.getClass().newInstance();
            //用新的实例执行操作
            b1.hello(b1.getClass().getName());
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

3.2 获取运行时类的完整结构

public class ATest {
    public static void main(String[] args) {
        try {
            Class<B> bClass = B.class;
            //获取所有构造器
            for (Constructor<?> constructor : bClass.getConstructors()) {
                System.out.println(constructor);
            }
            //获取所有属性
            for (Field field : bClass.getFields()) {
                System.out.println(field);
            }
            //获取父类
            Class<? super B> superclass = bClass.getSuperclass();
            //获取所有方法
            for (Method method : bClass.getDeclaredMethods()) {
                System.out.println(method);
            }
            //获取所有注解
            for (Annotation annotation : bClass.getAnnotations()) {
                System.out.println(annotation);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.3 调用运行时类的指定结构

public class ATest {
    public static void main(String[] args) {
        try {
            //调用指定的方法
            Class<B> bClass = B.class;
            B b = B.class.newInstance();
            Method hello = bClass.getDeclaredMethod("hello", String.class);
            hello.setAccessible(true);
            hello.invoke(b,"测试"); //hello测试
            //调用指定的参数
            Field name = bClass.getDeclaredField("name");
            name.setAccessible(true);
            name.set(b,"TomCat");
            System.out.println(name.get(b));//TomCat
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4.反射的经典应用：动态代理（涉及到设计模式时具体阐述）

5.RTTI和反射

在java编程思想一书中，作者提到了RTTI，并描述了其与反射之间的区别：RTTI与反射真正的区别在于，对RTTI来说，编译器在编译期打开和检查.class文件，而对于反射机制来说，.class文件在编译时是不可获取的，所以是在运行时打开和检查.class文件。
我的理解是不需要关注RTTI和反射的区别，他们都是为了在程序运行时获取类的信息并操作这一目标，只是这两个名词描述了不同的阶段而已。