Java基础-反射

反射就是把Java类中的各种成分映射成相应的java类。

例如，一个java类中用一个Class类的对象来表示，一个类中的组成部分：

成员变量，方法，构造方法，包等等信息也用一个个的java类来表示。

一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，

通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后

有什么用呢？怎么用呢？这就是反射的要点。

1.Constructor类

得到某个类所有的构造方法:

Constructor[] constructors = Class.forName(“java.lang.String”).getConstructors();

得到某一个构造方法：

Constructor constructor = Class.forName(“java.lang.String”).getConstuctor(StringBuffer.class);

创建实例对象：

通常方式：String str = new String(new StringBuffer(“abc”));

反射方式：String str = (String)constructor.newInstance(new StringBuffer(“abc”));

代码演示：

[code]/*
 * 通过反射获取构造方法并使用。
 */
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");

        // 获取构造方法
        // public Constructor[] getConstructors():所有公共构造方法
        // public Constructor[] getDeclaredConstructors():所有构造方法
        // Constructor[] cons = c.getDeclaredConstructors();
        // for (Constructor con : cons) {
        // System.out.println(con);
        // }

        // 获取单个构造方法
        // public Constructor<T> getConstructor(Class<?>... parameterTypes)
        // 参数表示的是：你要获取的构造方法的构造参数个数及数据类型的class字节码文件对象
        Constructor con = c.getConstructor();// 返回的是构造方法对象

        // Person p = new Person();
        // System.out.println(p);
        // public T newInstance(Object... initargs)
        // 使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
        Object obj = con.newInstance();
        System.out.println(obj);

        // Person p = (Person)obj;
        // p.show();
    }
}

代码演示2：

[code]/*
 * 需求：通过反射去获取该构造方法并使用：
 * public Person(String name, int age, String address)
 * 
 * Person p = new Person("林青霞",27,"北京");
 * System.out.println(p);
 */
public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");

        // 获取带参构造方法对象
        // public Constructor<T> getConstructor(Class<?>... parameterTypes)
        Constructor con = c.getConstructor(String.class, int.class,
                String.class);

        // 通过带参构造方法对象创建对象
        // public T newInstance(Object... initargs)
        Object obj = con.newInstance("林青霞", 27, "北京");

        System.out.println(obj);
    }
}

2.Field类

Filed类代表某个类中的一个成员变量

得到某个类的成员变量并打印

ReflectPoint point = new ReflectPoint(1,7);

Field x = point.getClass().getField(“x”);

System.out.println(x.get(point));

代码演示：

[code]/*
 * 通过发生获取成员变量并使用
 */
public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 获取字节码文件对象
        Class c = Class.forName("cn.itcast_01.Person");

        // 获取所有的成员变量
        // Field[] fields = c.getFields();
        // Field[] fields = c.getDeclaredFields();
        // for (Field field : fields) {
        // System.out.println(field);
        // }

        /*
         * Person p = new Person(); p.address = "北京"; System.out.println(p);
         */

        // 通过无参构造方法创建对象
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();
        System.out.println(obj);

        // 获取单个的成员变量
        // 获取address并对其赋值
        Field addressField = c.getField("address");
        // public void set(Object obj,Object value)
        // 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
        addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
        System.out.println(obj);

        // 获取name并对其赋值
        // NoSuchFieldException
        Field nameField = c.getDeclaredField("name");
        // IllegalAccessException
        nameField.setAccessible(true);
        nameField.set(obj, "林青霞");
        System.out.println(obj);

        // 获取age并对其赋值
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj, 27);
        System.out.println(obj);
    }
}

如果成员变量是私有的可以用getDeclaredField()和setAccessible(true);

Field y = point.getClass().getDeclaredField(“y”);

y.setAccessible(true);

System.out.println(y.get(point));

3.Method类

Method类代表某个类中的方法

得到类中的某一个方法：

Method charAt = Class.forName(“java.lang.String”).getMethod(“charAt”,int.class);

调用方法：

String str = “abc”;

通常方法：System.out.println(str.charAt(1));

反射方法：System.out.println(charAt.invoke(str,1));运行结果b

如果invoke(null,1) 代表调用的是一个静态的方法

框架要解决的核心问题

我在写框架时，并不知道用户以后会写什么类。就比如：盖房子时不知道用户要安装什么样的门窗。

因为在写程序时无法知道要被调用的类名，所以在程序中无法直接new某个类的对象，所有要用发射方式来做。