java反射的学习

初步感受反射—Class类

1、 java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同实例对象有不同的属性值。java程序中的各个java类，它们是否属于同一类事物，是不是可以用一个类来描述这类事物呢？这个类的名字就是Class，要注意与小写class关键字区别，Class类描述了哪些方面的信息呢？类的名字，类的访问属性，类所属于的包名，字段名称的列表，方法名称的列表，等等。学习反射，首选要明白Class这个类。

2、 得到类字节码的方式：

（1）对象.Class.getClass():Class cls1 = str1.getClass(); //得到字节码方式1

(2)类名.Class:Class cls2 = String.class; //得到字节码方式2

(3)Class.forName("类名全路径"):

Class cls3=Class.forName(cls3=Class.forName("java.lang.String"); //得到字节码方式3

Class.forName()方法有两个作用：a、当jvm中存在这个类的字节码时，直接返因字节码；b、如果这份字节码不存在内存中，就用类加载器到存储设备上(如硬盘)把这个类的字节码加载到jvm中来；

3、 九个定义Class实像对象：

基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象 ,另外：数组的Class实像对象,不是一个基本数据类型

Class bl = boolean.class;

Class bt = byte.class;

.

.

.

Class db = double.class;

Class vo = void.class;

数组类型的Class实例对象：

总结，只要在源程序中出现的类型，都有各自的Class实例对象，如：int[],void...

Class.isArray();

int[].class.isPrimitive()是否为基本数据类型

int[].class.isArray()是否为数组类型

代码：

public class ReflectTest {

public static void main(String[] args) throws ClassNotFoundException {

       String str1 = "abc";

       String str2 = "cde";

       

       Class cls1 = str1.getClass(); //得到字节码方式1

       Class cls2 = String.class; //得到字节码方式2

       Class cls3 = Class.forName("java.lang.String"); //得到字节码方式3

       System.out.println("cls1 == cls2: " + (cls1 == cls2));

       System.out.println("cls1 == cls3: " + (cls1 == cls3));

       

       System.out.println("cls1对象是否为基础数据类型：" + cls1.isPrimitive());

       System.out.println("int.class返回的是否为基础数据类型：" + int.class.isPrimitive());

       System.out.println("int.class == Integer.class: " + (int.class == Integer.class));

       System.out.println("int.class == Integer.TYPE: " + (int.class == Integer.TYPE));

       System.out.println("int[].class返回的是否为基础数据类型: " + int[].class.isPrimitive());

       System.out.println("int[].class: " + int[].class.isArray());

    }

}

运行结果：

cls1 == cls2: true

cls1 == cls3: true

cls1对象是否为基础数据类型：false

int.class返回的是否为基础数据类型：true

int.class == Integer.class: false

int.class == Integer.TYPE: true

int[].class返回的是否为基础数据类型: false

int[].class: true

反射

反射就是把java类中的各种成分映射成相应的java类。例如，一个java类中用一个Class尖的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等信息也用一个个的java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Fileld(成员变量)，Method(方法)
，Contructor(构造方法)，Package（包）等等。

一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法，可以得到这些实像对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。

1、Constructor类

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

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

b：得到某一个构造方法

Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);

c：创建实像对象

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

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

d: Class.newInstance()方法：

String obj = (String) Class.forName("java.lang.String").newInstance();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

方法用到了缓存机制来保存默认构造方法的实例对象。

例：

import java.lang.reflect.Constructor;

public class ConstructorTest {

    public static void main(String[] args) throws Exception {

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

       //获得所有的构造方法

       for (int i = 0; i < constructors.length; i++) {

           System.out.println(constructors[i].getName());

       }

       Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);

       //获得参数类型为StringBuffer类型的构造方法的实例

//     String str = new String(new StringBuffer("abc"));

       String str = (String) constructor.newInstance(new StringBuffer("abc")); //通过反射创建的对象

       String obj = (String) Class.forName("java.lang.String").newInstance();

//     该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象

    }

}

Field类

Field类的一个对象代表某个类中的一个成员变量的统称，也就是说，如果我用ReflectPoint类创建了多个对象，ReflectPoint类中有属性x,y，通过反射
ReflectPoint pt1 = new ReflectPoint(3, 5);Field fieldY = pt1.getClass().getField("y"); 我拿到了它对应的Field的一个对象 fieldY，那么，我可以通过fieldY这个对象访问ReflectPoint类中所有对象的y属性。具体见例子代码：

下面是一个综合案例：

 

public class ReflectPoint {

    private int x;

    public int y;

    public String str1 = "ball";

    public String str2 = "basketball";

    public String str3 = "itcast";

    

    public ReflectPoint(int x, int y) {

       this.x = x;

       this.y = y;   

    }

    @Override

    public String toString() {

       return str1 +" " + str2 + " " + str3;

    }

}

 

import java.lang.reflect.Field;

public class ReflectPointTest {

    public static void main(String[] args) throws Exception { //异常暂先作抛出处理

       ReflectPoint pt1 = new ReflectPoint(3, 5);

       Field fieldY = pt1.getClass().getField("y");

       Field fieldX = pt1.getClass().getDeclaredField("x");

       fieldX.setAccessible(true); //很暴力，允许获得私有成员

       System.out.println(fieldY.get(pt1));

       System.out.println(fieldX.get(pt1));

       changeStringValue(pt1);

       System.out.println(pt1);

    }

    //将String类中的所有对象中字符串中含有字符b全部替换为a

    private static void changeStringValue(Object obj) throws Exception {

       Field[] fields = obj.getClass().getFields();

       for (Field field: fields) {

           if (field.getType() == String.class) {

              String oldValue = (String) field.get(obj); //获得ReflectPoint类中成员变更的值

              String newValue = oldValue.replace('b', 'a'); //替换

              field.set(obj, newValue); //

           }

       }

    }

}