java反射机制

一、java类初始化

1. 初始化操作：按照源代码从上到下的顺序依次执行静态代码块和初始化静态域。在一个类被初始化前，其父类也需要被初始化。
2. 初始化的时机：
   (１)创建类的实例，比如new创建对象。
   (２)访问某个类或接口的静态变量，或者对该静态变量复制。
   (３)调用类的静态方法。
   (４)反射。
3. 如果访问一个类的用final修饰静态变量，这个变量在编译时就能确定，不会导致初始化。

package cn.wxz1997.concurrency.annotation;

/**
 * @Description: ${todo}
 * @Author: wxz1997
 * @Date 18-6-19下午2:22
 */
public class StaticDemo {
    public static void main(String[] args) {
        System.out.println(TestStatic.a);
    }
    
}

class TestStatic{
    public static final String a = "wxz1997";
    static {
        System.out.println("初始化");
    }
}

//加了final输出wxz1997
//去掉final输出初始化wxz1997

二、java反射机制

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射。

1. 获得类类型的三种方法:
   (1)Class cls = Test.class;
   (2)Class cls = Class.forName("cn.wxz1997.concurrency.reflection.Test");
   (3)Class cls = test.getClass();
   以上获得cls为同一类对象

2. 创建对象
   (1)Class对象的newInstance,比较常用的方法，缺点只能调用默认的构造方法。
   (2)Class对象getConstructor获得Constructor调用newInstance。

3. 反射的应用

package cn.wxz1997.concurrency.reflection;

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

/**
 * @Description: ${todo}
 * @Author: wxz1997
 * @Date 18-6-19下午2:42
 */
public class Test {
    int a = 9;
    private static String b = "wxz1997";

    public Test() {
    }

    public Test(int a) {
        this.a = a;
    }

    public void test(){
        System.out.println("hello");
    }

    public String test2(int a, String b){
        return "hello" + a + b;
    }
}

class TestReflection{
    public static void main(String[] args) {
        try {
            Class cls = Class.forName("cn.wxz1997.concurrency.reflection.Test");
            System.out.println(cls);
            //获取构造方法
            Constructor[] constructors = cls.getDeclaredConstructors();
            for (Constructor constructor:constructors){
                System.out.println(constructor);
            }
            //获取方法
            Method[] methods = cls.getDeclaredMethods();
            for (Method method:methods){
                System.out.println(method);
            }
            //获取参数
            Field[] fields = cls.getDeclaredFields();
            for (Field field: fields){
                System.out.println(field);
            }
            //newInstance创建对象
            Object obj = cls.newInstance();

            /**
             * 反射调用对象的方法
             */
            Method method = cls.getMethod("test2", int.class, String.class);
            String value = (String) method.invoke(obj, 1, "wxz1997");
            System.out.println(value);

            /**
             * 反射获取对象属性的值
             */
            Field field = cls.getDeclaredField("a");
            int a = (int) field.get(obj);
            System.out.println(a);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//执行结果如下：
//class cn.wxz1997.concurrency.reflection.Test
//public cn.wxz1997.concurrency.reflection.Test(int)
//public cn.wxz1997.concurrency.reflection.Test()
//public java.lang.String cn.wxz1997.concurrency.reflection.Test.test2(int,java.lang.String)
//public void cn.wxz1997.concurrency.reflection.Test.test()
//int cn.wxz1997.concurrency.reflection.Test.a
//private static java.lang.String cn.wxz1997.concurrency.reflection.Test.b
//hello1wxz1997
//9