黑马程序员_java反射

——- android培训、java培训、期待与您交流！ ———-
反射

主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。
反射本质就是把一个java类中所有的成分封装成对象,然后对这些对象进行操作。

反射的作用：
用来搭建框架，降低程序的耦合性，提高代码的复用性。

反射技术

就是动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。

简单的说：反射技术可以对一个类进行解剖。
反射的好处：增强了程序的扩展性。

反射的基本步骤：
1. 获取Class对象，就是获取到指定名称的字节码文件对象。
2. 实例化对象，获取类的属性、方法或构造函数。
3. 访问属性、调用方法、调用构造函数创建对象。

反射的基石：Class类

java程序中的各个java类属于同一类事物，描述这类事物的java类名就是Class,Class类是java反射的基础。

获取Class对象的三种方式：
1. 通过每个对象都具备的方法getClass来获取。
弊端：必须要创建该类对象才可以调用getClass方法。

1. 每一个数据类型(基本数据类型和引用数据类型)都有一个静态属性class。
   弊端：必须要先明确该类。
   注意：这两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。

2. 使用的Class类中的方法，静态的forName方法。
   指定什么类名就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。

forName的作用：
1.返回字节码 返回方式有两种：
(1).这份字节码曾被加载过，已经在java虚拟机里面了，直接返回
(2).java虚拟机里还没有这份字节码则用类加载去加载，把加载进来的字节码缓存在虚拟机里,反射时主要用这个方法。
1).根据给定类名来获取，用于类的加载。
String classname = “test.reflect.Person”;//来自配置文件
Class clazz = Class.forName(classname);//此对象代表Person.class
2).如果拿到对象，不知道是什么类型，用于获取对象的类型。
Object obj = new Person();
Class clazz1 = obj.getClass();//获取对象具体的类型
(3).如果是明确的获取某个类的Class对象，主要用于传参。
Class clazz2 = Person.class;

九个预定义Class实例对象：
boolean,byte,char,short,int,long,float,double,void

Constructor(构造器)类

Constructor类代表某个类中的构造方法。

1. 得到某个类中所有的构造方法：
   例子：Constructor[] constructors = Class.forName(“java.lang.String”).getConstructors(StringBuffer.class);

2. 得到某个类中某一个构造方法：
   例子：Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
   注意：getConstructor()与getConstructors()只能获取public修饰的构造方法，getDeclaredConstructor()与getDeclaredConstructors()可以获取非public修饰的构造方法。

3. 创建实例对象：
   一般方式：String str = new String(new StringBuffer(“abc”));
   反射方式：String str = (String)constructor.newInstance(new StringBuffer(“abc”));
   注意：newInstance方法一定要与获取的构造器匹配，如果构造器有参数，在newInstance也要传递参数。我们也可以通过Class对象直接调用newInstance()方法，它默认使用的是无参构造函数。

Field类
Field类代表某个类中的属性(成员变量)。

1. 获取Filed:
   Field ClassgetField(String name);
   Field[] ClassgetFields();
   Class getDeclaredField(String name);
   Class getDeclaredFields();

2. Filed操作：
   赋值：set(Object obj,Object value);
   obj:代表的是这个属性所属的对象。value:代表的是属性值。
   取值：get(Object obj);
   obj:代表的是这个属性所属的对象。

Method类

Method类代表某个类中的成员方法。

1. 得到类中的某一个方法：
   Class getMethod(String name,Class… obj);
   Class getDeclaredMethod(String name,Class… obj);

Class getMethods();//获取的方法中包含父类的方法
Class getDeclaredMethods();//只获取子类中的方法

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

调用方法：
   Method类中有一个invoke方法。作用：是让Method代表的方法执行。
   Object invoke(Object obj,Object… args)
   参数1 obj:调用该方法的对象。
   参数2 args:用于方法调用的参数。
 返回值：得到的是该Method对象代表的方法执行后结果。

   一般方式：System.out.println(str.charAt(1));
   反射方式：System.out.println(charAt.invoke(str,1));

注意：如果传递给Method对象的invoke()方法的第一个参数为null,说明该Method对象对应的是一个静态方法。

数组的反射

Array工具类用于完成对数组的反射操作。
Arrays.asList()：返回一个受指定数组支持的固定大小的列表。

如果Method代表的方法参数是一个数组类型怎样处理?
可变参数在接收非基本类型数组时会把数组内容作为一个个单参数传入可变参数封装的数组.如果参数类型是个基本类型数组,我们直接把这个数组作为一个参数传递就会出现传入的参数不符合的异常抛出。
这种情况出现的原因？
这种情况的原因是JDK兼容1.4和1.5造成的，可变参数是1.5的新特性,而1.4之前传入多参数都是使用的Object数组，为了兼容1.4，所以在1.5接收可变参数是优先调用1.4语法处理,而不是直接把数组作为一个参数, 需要在传递时，将参数强制转换成Object或在外层在包装一层数组。

代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；
非基本类型的一维数组，即可以当做Object类型使用，又可以当做Object[]类型使用。

.isPrimitive():这份字节码是否是原始类型
.isArray():这份字节码是否是数组数组类型的Class实例对象
只要是在源程序中出现的类型，都有各自的Class实例对象。

反射的用法

1.如果要获取java类的各个组成部分，首先要获取类的Class对象，获取Class对象的三种方式：

                       1).Class.forName("类名");                                        返回字节码，用于类的加载。
                       2).对象.getClass();                                                    用于获取对象的类型。
                       3).类名.class;                                                             用于获取指定的类型，传参用。

2.反射类的成员方法：
Class clazz = Person.class;
Method method = clazz.getMethod(methodName,new Class[]{paramClazz1,paramClazz2});
method.invoke();

3.反射类的构造函数：
Constructor con = clazz.getConstructor(new Class[]{paramClazz1,paramClazz2,…});
con.newInstance(params…);

4.反射类的属性：
Field field = clazz.getField(fieldName);
如果属性是被私有修饰的就用：clazz.getDeclaredField(fieldName);
field.setAccessible(true);
field.setObject(value);

获取了字节码文件对象后，最终都需要创建指定类的对象：

创建对象的两种方式(就是对象在进行实例化时的初始化方式):

1. 调用空参数的构造函数：使用Class类中的newInstance()方法。

2. 调用带参数的构造函数：先要获取指定参数列表的构造函数镀锡，然后通过该构造函数对象的newInstance(实际参数)进行对象的初始化。
   注意：第二种方式必须要先明确具体构造函数的参数类型，不利于扩展。所以，一般情况下，被反射的类内部通常都会提供一个公有的空参数的构造函数。

如何生成获取到字节码文件对象的实例对象？
[java] view plaincopy在CODE上查看代码片派生到我的代码片
//类加载
Class clazz = Class.forName(“com.bean.Person”);
//直接获得指定的类型
clazz = Person.class;
//根据对象获得类型
Object obj = new Person(“lisi”,22);
clazz = obj.getClass();
//该实例对象的方法调用的就是指定类中的空参数构造函数，给创建对象进行初始化。
Object obj = clazz.newInstance();
//当指定类中没有空参数构造函数时，该如何创建这个类对象呢？
public static void method_1() throws Exception{
Class clazz = Class.forName(“com.bean.Person”);
//获取一个带参数的构造器
Constructor constructor = clazz.getConstructor(String.class,int.class);
//使用构造器的newInstance()方法对对象进行初始化
Object obj = constructor.newInstance(“lisi”,21);
//获取所有构造器
Constructor[] constructors = clazz.getConstructors();//只包含公共的
Constructors = clazz.getDeclaredConstructors();//包含私有的
for(Constructor con : constructors){
System.out.println(con);
}
}

反射指定类中的方法

1).获取类中所有的方法
[java] view plaincopy在CODE上查看代码片派生到我的代码片
public static void method_1() throws Exception{
Class clazz = Class.forName(“com.bean.Person”);
//获取该类中的公有方法和父类中的公有方法
Method[] methods = clazz.getMethods();
//获取本类中的方法，包含私有方法
methods = clazz.getDeclaredMethods();
for(Method method : methods){
System.out.println(method);
}

2).获取指定方法
[java] view plaincopy在CODE上查看代码片派生到我的代码片
public static void method_2() throws Exception{
//获取指定名称的方法
Method method = clazz.getMethod(“show”, int.class,String.class);
//调用方法对象的invoke方法，但方法运行必须要明确所属对象和具体的实际参数
Object obj = clazz.newInstance();
method.invoke(obj,23, “heihei”);//执行指定参数的方法
}

3).运行私有方法
[java] view plaincopy在CODE上查看代码片派生到我的代码片
public static void method_3() throws Exception{
Class clazz = Class.forName(“com.bean.Person”);
//获取私有方法
Method method = clazz.getDeclaredMethod(“method”,null);
//私有方法不可以直接访问，如果想要访问需要通过暴力的方式
method.setAccessible(true);//一般不用，因为修饰成私有就是要隐藏起来
}
.setAccessible(true);暴力反射,field代表字节码里的变量

4).反射静态方法
[java] view plaincopy在CODE上查看代码片派生到我的代码片
public static void method_4() throws Exception{
Class clazz = Class.forName(“com.bean.Person”);
Method method = clazz.getMethod(“function”,null);
method.invoke(null,null);
}

成员变量反射示例

需求：将任意一个对象中所有String类型的成员变量所对应的字符串内容中的”b”改成’’a”。

[java] view plaincopy在CODE上查看代码片派生到我的代码片
public class ReflectPoint {
private int x;
public int y;
public String str1 = “basketball”;
public String str2 = “abstract”;
public String str3 = “dog”;

public ReflectPoint(int x, int y) {  
    super();  
    this.x = x;  
    this.y = y;  
}  
@Override  
public String toString(){  
    return str1 + ":" + str2 + ":" + str3;  
}  

}

import java.lang.reflect.Field;
public class ReflectTest {
public static void main(String[] args) throws Exception {
ReflectPoint pt1 = new ReflectPoint(5,6);
// Field fieldY = pt1.getClass().getField(“y”);
// System.out.println(fieldY.get(pt1));
// //fieldY不是对象身上的变量，而是类上的。
// Field fieldX = pt1.getClass().getDeclaredField(“x”);
// fieldX.setAccessible(true);
// System.out.println(fieldX.get(pt1));

    changeStringValue(pt1);  
    System.out.println(pt1);  
}  
//扫描ReflectPoint类中所有String类型变量  
private static void changeStringValue(Object obj) throws IllegalArgumentException, IllegalAccessException{  
    Field[] fields = obj.getClass().getFields();  
    for(Field field : fields){  
        if(field.getType()==String.class){//如果是String这种字节码  
            String oldValue = (String)field.get(obj);  
            String newValue = oldValue.replace('b', 'a') ;  
            field.set(obj, newValue);  
        }  
    }  
}  

}

总结：
反射是在java.lang.reflect包下。具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
反射主要用于工具和框架的开发。反射会导致程序性能下降。可以通过反射获取泛型的实际类型参数，反射是对于类的再抽象；通过字符串来抽象类。
字节码用==比较，因为是同一份字节码。泛型是给编译器看的，反射可以跳过编译。
反射就是把java类中的各种成分映射成相应的java类。
——- android培训、java培训、期待与您交流！ ———-