静态语言和动态语言

动态语言，在运行时可以改变其结构的语言，主要的动态语言有：JavaScript、Python、Object-C、C#。

静态语言，在运行时不可以变其结构的语言，主要有：C、C++、Java。

Java不是动态语言，但可以称之为“准动态语言”，即：Java有一定的动态性，利用Java反射机制获得类似动态语言的特性，让写程序时更加灵活。

Java反射（Reflection）

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

JVM加载完类之后，在堆内存的方法区（元数据区）会产生一个Class类型的对象（一个类有且只有一个Class对象），这个对象包含了完整的类的结构信息，通过这个对象可以创建一个或者多个实例对象。

优点VS缺点

优点：可以实现动态创建对象和编译，体现出很大的灵活性。

缺点：对性能有影响，使用反射基本上是一种解释型操作，这类操作效率低于直接执行相同的操作。

反射机制主要提供的功能：

1、在运行时判断任意一个对象所属的类；2、在运行时构造任意一个类的对象；3、在运行时判断任意一个类所具有的成员变量和方法；4、在运行时调用任意一个对象的方法；5、生成动态代理。

反射相关的主要API：

1、java.lang.Class: 代表一个类。

2、java.lang.reflect.Constructor: 代表类的构造器。

3、java.lang.reflect.Field: 代表类的成员变量。

4、java.lang.reflect.Method: 代表类的方法。

代码案例

package com.what21.demo.demo10;

import lombok.Data;

import java.util.Date;

@Data
public class User {

    private Integer id;

    private String name;

    private int age;

    String email;

    protected String phone;

    public String desc;

    public Date createTime;

    public User() {
        this.createTime = new Date();
    }

    public User(Integer id, String name) {
        this.id = id;
        this.name = name;
        this.createTime = new Date();
    }

    public User(Integer id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.createTime = new Date();
    }

}

Java反射机制，构造方法：

import java.lang.reflect.Constructor;

/**
 * Java反射机制
 */
public class ReflectionTest01 {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        String className = "com.what21.demo.demo10.User";
        reflectConstructor(className);
        reflectDeclaredConstructor(className);
    }

    /**
     * 反射构造方法
     *
     * @param className
     * @throws Exception
     */
    public static void reflectConstructor(String className) throws Exception {
        // 构造方法信息
        Class<?> clazz = Class.forName(className);
        System.out.println("------------------------------------------------------------");
        Constructor<?>[] constructors = clazz.getConstructors();
        System.out.println("构造方法的数量为： " + constructors.length);
        for (Constructor<?> constructor : constructors) {
            Class<?>[] paramClazzs = constructor.getParameterTypes();
            System.out.print("构造方法的参数个数： " + paramClazzs.length + "    ");
            System.out.print("构造方法的参数类型： ");
            for (Class<?> paramClazz : paramClazzs) {
                System.out.print(paramClazz.getName() + "    ");
            }
            System.out.println();
        }
        System.out.println("------------------------------------------------------------");
        // 调用public修饰符修饰的构造方法
        Constructor<?> threeParam = clazz.getConstructor(Integer.class, String.class, int.class);
        Object object = threeParam.newInstance(1001, "张三", 25);
        System.out.println("根据构造方法创建对象：" + object);
    }

    /**
     * 反射声明的构造方法
     */
    public static void reflectDeclaredConstructor(String className) throws Exception {
        // 构造方法信息
        Class<?> clazz = Class.forName(className);
        System.out.println("------------------------------------------------------------");
        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
        System.out.println("构造方法的数量为： " + constructors.length);
        for (Constructor<?> constructor : constructors) {
            Class<?>[] paramClazzs = constructor.getParameterTypes();
            System.out.print("构造方法的参数个数： " + paramClazzs.length + "    ");
            System.out.print("构造方法的参数类型： ");
            for (Class<?> paramClazz : paramClazzs) {
                System.out.print(paramClazz.getName() + "    ");
            }
            System.out.println();
        }
        System.out.println("------------------------------------------------------------");
        // 调用没有修饰符修饰的构造方法
        Constructor<?> zeroParam = clazz.getDeclaredConstructor();
        Object zeroParamObj = zeroParam.newInstance();
        System.out.println("根据构造方法创建对象：" + zeroParamObj);
        // 调用protected修饰符修饰的构造方法
        Constructor<?> towParam = clazz.getDeclaredConstructor(Integer.class, String.class);
        Object towParamObj = towParam.newInstance(1001, "张三");
        System.out.println("根据构造方法创建对象：" + towParamObj);
        // 调用public修饰符修饰的构造方法
        Constructor<?> threeParam = clazz.getDeclaredConstructor(Integer.class, String.class, int.class);
        Object object = threeParam.newInstance(1002, "李四", 25);
        System.out.println("根据构造方法创建对象：" + object);
        System.out.println("------------------------------------------------------------");
    }

}

Java反射机制，操作属性：

import java.lang.reflect.Field;
import java.util.Date;

/**
 * Java反射机制
 */
public class ReflectionTest02 {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        String className = "com.what21.demo.demo10.User";
        reflectFiled(className);
        reflectDeclaredFiled(className);
    }

    /**
     * 反射声明的类属性
     */
    public static void reflectFiled(String className) throws Exception {
        // 属性信息
        Class<?> clazz = Class.forName(className);
        System.out.println("------------------------------------------------------------");
        Field[] fields = clazz.getFields();
        System.out.println("属性的个数为： " + fields.length);
        for (Field field : fields) {
            System.out.println("属性的类型： " + field.getType() + "    属性的名称：" + field.getName());
        }
        Object object = clazz.newInstance();
        // 赋值并输出父类public修饰的属性
        Field superField = clazz.getField("createTime");
        superField.setAccessible(true);
        superField.set(object, new Date());
        System.out.println(superField.get(object));
        // 赋值并输出public修饰的属性
        Field field = clazz.getField("desc");
        field.setAccessible(true);
        field.set(object, "描述");
        System.out.println(field.get(object));
    }

    /**
     * 反射声明类属性
     */
    public static void reflectDeclaredFiled(String className) throws Exception {
        // 属性信息
        Class<?> clazz = Class.forName(className);
        System.out.println("------------------------------------------------------------");
        Field[] fields = clazz.getDeclaredFields();
        System.out.println("属性的个数为： " + fields.length);
        for (Field field : fields) {
            System.out.println("属性的类型： " + field.getType() + "    属性的名称：" + field.getName());
        }
        Object object = clazz.newInstance();
        // 赋值并输出没有修饰符修饰的属性
        Field defaultField = clazz.getDeclaredField("email");
        defaultField.setAccessible(true);
        defaultField.set(object, "demo@what21.com");
        System.out.println("email=" + defaultField.get(object));
        // 赋值并输出protected修饰的属性
        Field protectedField = clazz.getDeclaredField("phone");
        protectedField.setAccessible(true);
        protectedField.set(object, "13800000000");
        System.out.println("phone=" + protectedField.get(object));
        // 赋值并输出public修饰的属性
        Field field = clazz.getDeclaredField("desc");
        field.setAccessible(true);
        field.set(object, "描述");
        System.out.println("desc=" + field.get(object));
        System.out.println("------------------------------------------------------------");
    }

}

Java反射机制，操作方法：

import java.lang.reflect.Method;
import java.util.Date;

/**
 * Java反射机制
 */
public class ReflectionTest03 {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        String className = "com.what21.demo.demo10.User";
        reflectMethod(className);
        reflectDeclaredMethod(className);
    }

    /**
     * 反射方法
     *
     * @param className
     * @throws Exception
     */
    public static void reflectMethod(String className) throws Exception {
        // 属性信息
        Class<?> clazz = Class.forName(className);
        Method[] mothods = clazz.getMethods();
        for (Method method : mothods) {
            System.out.print("方法的名称： " + method.getName() + "，属性的返回值类型：" + method.getReturnType() + "  ");
            Class<?>[] paramClazzs = method.getParameterTypes();
            System.out.print("方法的参数个数： " + paramClazzs.length + "   ");
            for (Class<?> paramClazz : paramClazzs) {
                System.out.print(paramClazz.getName() + "    ");
            }
            System.out.println();
        }
        Object object = clazz.newInstance();
        // 调用父类public修饰的方法
        Method superSetMethod = clazz.getMethod("setCreateTime", Date.class);
        superSetMethod.invoke(object, new Date());
        Method superGetMethod = clazz.getMethod("getCreateTime");
        System.out.println(superGetMethod.invoke(object));
        // 调用public修饰的方法
        Method setMethod = clazz.getMethod("setDesc", String.class);
        setMethod.invoke(object, "描述");
        Method getMethod = clazz.getMethod("getDesc");
        System.out.println("getDesc()=" + getMethod.invoke(object));
    }

    /**
     * 反射声明的方法
     *
     * @param className
     * @throws Exception
     */
    public static void reflectDeclaredMethod(String className) throws Exception {
        // 属性信息
        Class<?> clazz = Class.forName(className);
        Method[] mothods = clazz.getDeclaredMethods();
        for (Method method : mothods) {
            System.out.print("方法的名称： " + method.getName() + "，属性的返回值类型：" + method.getReturnType() + "  ");
            Class<?>[] paramClazzs = method.getParameterTypes();
            System.out.print("方法的参数个数： " + paramClazzs.length + "   ");
            for (Class<?> paramClazz : paramClazzs) {
                System.out.print(paramClazz.getName() + "    ");
            }
            System.out.println();
        }
        Object object = clazz.newInstance();
        // 调用没有修饰符修饰的方法
        Method defaultSetMethod = clazz.getDeclaredMethod("setEmail", String.class);
        defaultSetMethod.setAccessible(true);
        defaultSetMethod.invoke(object, "demo@what21.com");
        Method defaultGetMethod = clazz.getDeclaredMethod("getEmail");
        System.out.println("getEmail()=" + defaultGetMethod.invoke(object));
        // 调用protected修饰的方法
        Method protectedSetMethod = clazz.getDeclaredMethod("setPhone", String.class);
        protectedSetMethod.setAccessible(true);
        protectedSetMethod.invoke(object, "13800000000");
        Method protectedGetMethod = clazz.getDeclaredMethod("getPhone");
        System.out.println("getPhone()=" + protectedGetMethod.invoke(object));
        // 调用public修饰的方法
        Method publicSetMethod = clazz.getMethod("setDesc", String.class);
        publicSetMethod.invoke(object, "描述");
        Method publicGetMethod = clazz.getMethod("getDesc");
        System.out.println("getDesc()=" + publicGetMethod.invoke(object));
    }

}