黑马程序员java之反射


　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

反射技术：动态加载一个指定的类，并获取该类中的所有的内容。而且将字节码文件封装成对象，并将字节码文件中的内容都封装成对象，这样便于操作这些成员。就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。
反射的好处：大大的增强了程序的扩展性。

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

获取这个Class对象，有三种方式：
1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。
2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。
3：使用的Class类中的方法，静态的forName方法。

  指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。

package cn.itcast_01;

/*
* 反射：就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。
*
* Person p = new Person();
* p.使用
*
* 要想这样使用，首先你必须得到class文件对象，其实也就是得到Class类的对象。
* Class类：
* 成员变量 Field
* 构造方法 Constructor
* 成员方法 Method

* 一般我们到底使用谁呢?
* A:自己玩 任选一种，第二种比较方便
* B:开发 第三种
* 为什么呢?因为第三种是一个字符串，而不是一个具体的类名。这样我们就可以把这样的字符串配置到配置文件中。
*/
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// 方式1
Person p = new Person();
Class c = p.getClass();

Person p2 = new Person();
Class c2 = p2.getClass();

System.out.println(p == p2);// false
System.out.println(c == c2);// true
//可以证明，p和p2不是同一个文件对象，却有相同的字节码文件也就是。class文件

// 方式2
Class c3 = Person.class;;
System.out.println(c == c3);//true

// 方式3
Class c4 = Class.forName("cn.itcast_01.Person");
System.out.println(c == c4);//true
//通过实验可以证明，有三种方式可以获得文件的字节码文件。
}
}


反射都需要获取字节码文件，获取了字节码文件对象后，最终都需要创建指定类的对象：
获取所有构造器。
    Constructor[] constructors =clazz.getConstructors();//只包含公共的
    constructors =clazz.getDeclaredConstructors();//本类公有，包含私有的
    for(Constructorcon : constructors) {
      
System.out.println(con);
    }
我们一般只需要获取一个带参数的构造器。
      Constructorconstructor = clazz.getConstructor(String.class,int.class);
想要对对象进行初始化，使用构造器的方法newInstance();
      Objectobj = constructor.newInstance("zhagnsan",30);
package cn.itcast_02;

import java.lang.reflect.Constructor;

/*
* 需求：通过反射去获取该构造方法并使用：
* 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");

// 获取带参构造方法对象可以叫构造器
Constructor con = c.getConstructor(String.class, int.class,
String.class);

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

System.out.println(obj);
}
}

package cn.itcast_02;

import java.lang.reflect.Constructor;

/*
* 需求：通过反射获取私有构造方法并使用
* private Person(String name){}
*
* Person p = new Person("风清扬");
* System.out.println(p);
*/
public class ReflectDemo3 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

// 获取私有构造方法对象
// NoSuchMethodException：出现了这个方法异常
// 原因是一开始我们使用的方法只能获取公共的构造函数，private修饰的需要特殊构造器
//getDeclaredConstructor可以访问所有构造函数包括私有构造函数
Constructor con = c.getDeclaredConstructor(String.class);

// 用该私有构造方法创建对象
// IllegalAccessException:会出现非法的访问异常。
// 因为对象私有，我们需要强制访问，这种方式称为暴力访问
con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
Object obj = con.newInstance("风清扬");

System.out.println(obj);
}

package cn.itcast_03;

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

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

// 获取所有的成员变量
// Field[] fields = c.getFields();
// Field[] fiel
d577
ds = 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();

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

// 获取name并对其赋值访问私有成员变量
// NoSuchFieldException
Field nameField = c.getDeclaredField("name");
// IllegalAccessException
nameField.setAccessible(true);//暴力访问
nameField.set(obj, "林青霞");
System.out.println(obj);

}
}

获取类中所有的方法
      //获取字节码文件对象
    Class c = Class.forName("cn.itcast_01.Person")
    //获取所有的方法
    // Method[]
methods =c.getMethods(); //获取自己的包括父亲的公共方法
    // Method[]
methods =c.getDeclaredMethods(); //获取自己的所有的方法
    // for
(Method method :methods) {
    //System.out.println(method);
    // }

package cn.itcast_04;

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

public class ReflectDemo {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class c = Class.forName("cn.itcast_01.Person");

Constructor con = c.getConstructor();
Object obj = con.newInstance();

// 获取单个方法并使用
Method m1 = c.getMethod("show");

m1.invoke(obj); // 调用obj对象的m1方法
// 第一个参数表示的方法名，如果有传入参数，表示的是方法的参数的class类型
Method m2 = c.getMethod("method", String.class);
m2.invoke(obj, "hello");;

//获取private成员函数，想要获取私有方法。必须用getDeclearMethod();
Method m4 = c.getDeclaredMethod("function");
m4.setAccessible(true);//暴力访问
m4.invoke(obj);
}
}

ArrayList<Integer>的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？

package cn.itcast.test;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class ArrayListDemo {
/*
* ArrayList<Integer>的一个对象，我想在这个集合中添加一个字符串数据，如何实现呢？
*/
public static void main(String[] args) throws NoSuchMethodException,
SecurityException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException {
// 创建集合对象
ArrayList<Integer> array = new ArrayList<Integer>();

// array.add("hello");
// array.add(10);

Class c = array.getClass(); // 集合ArrayList的class文件对象
Method m = c.getMethod("add", Object.class);

m.invoke(array, "hello"); // 调用array的add方法，传入的值是hello
m.invoke(array, "world");
m.invoke(array, "java");

System.out.println(array);
}
}


数组的反射。

具有相同维数和元素类型的数组属于同一类型。即具有相同的Class实例对象。

例如：int[] a=new
int[]{1,2,3};

         int[] a1=new int[5];

         int[][] a2=new int[4][3];

         String[] s=new String[2];

a和a1是相同的维数和元素类型，所以他们具有相同的字节码。

而其他的都不相同，或因维数不同，或因类型不同。

 

代表数据的Class实例对象的getSuperclass()方法返回的是父类的Object类对应的
Class.

所以基本数据类型的一维数组可以被当做Object类型使用，不能当做Object[]数组类型使用。

 非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]数组类型使用。

从上面例子中，引用到这里可以写成：

Object o1=a;     

Object o2=a1;   

Object o3[]=a2;

Object o4[]=s;

而Object o5[]=a
是编译不通过的。