黑马程序员__JAVA基础加强__高新技术(二)

------------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

1.Class类(反射的基石)

    Java程序在运行时，系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是Class类。Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建。其实例对象是对应各个类在内存中的字节码。

    虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类（型）都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。
    基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也都对应一个 Class 对象。
    每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
    一般某个类的Class对象被载入内存，它就用来创建这个类的所有对象。

 

    各个字节码对应的实例对象(Class类型)获取方法：

    1.类名.class，例如，System.class;

    2.对象.getClass()，例如，new Date().getClass();

    3.Class.forName("类名")，例如，Class.forName("java.util.Date");

 

    九个预定义Class对象 

    基本的Java类型(boolean、byte、char、short、int、long、float和double)和关键字void，每一个都对应一个Class对象

    涉及到的方法：isPrimitive():判定指定的Class对象是否表示一个基本类型。

    包装类型各有各的常量代表其基本类型，如：int.class == Integer.TYPE 

    判定是否为数组类型的Class实例对象:Class.isArray()(如：int[].class.isArray())

代码示例：

String str1="abc";

//获取str1的字节码文件
Class cls1=str1.getClass();

//获取String的字节码文件
Class cls2=String.class;

//返回与带有给定字符串名的类或接口相关联的 Class 对象
Class cls3=Class.forName("java.lang.String");
System.out.println(cls1==cls2);//true
System.out.println(cls1==cls3);//true

//isPrimitive()cls1是不是基本类型(字符串不是基本类型)
System.out.println(cls1.isPrimitive());

//判断int是不是基本类型.true
System.out.println(int.class.isPrimitive());

//判断int和Integer两个类的字节码是否相同false
System.out.println(int.class == Integer.class);

//TYPE表示基本类型 int 的 Class 实例。 true
System.out.println(int.class == Integer.TYPE);

//数组不是基本类型false
System.out.println(int[].class.isPrimitive());

//判断是否是一个数组类.isArray();true
System.out.println(int[].class.isArray());

 

2.反射

    概念

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

    反射是java中的一种运行机制，是在运行状态中：

    对于任意一个类，都能够获取到这个类的所有属性和方法；

    对于任意一个对象，都能够调用它的任意一个方法；

    这种动态获取的以及动态调用对象的方法的功能称为java语言的反射机制。

    反射作用：

    1.在运行时判定任意一个类所具有的成员变量和方法；

    2.在运行时构造任意一个类的对象；
    3.在运行时判定任意一个对象所属的类；
    4.在运行时调用任意一个对象的方法；
    5.生成动态代理。

    Constructor类

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

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

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

    得到某一个构造方法：

        Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);//获得方法时要用到类型

    创建实例对象：

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

    2.反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));//调用获得的方法时要用到上面相同类型的实例对象

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

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

    该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。

代码示例：

//用字节码获取获取Stirng的StringBuffer构造方法.返回Constructor类型
Constructor constructor1 = String.class.getConstructor(StringBuffer.class);

//再用Constructor类中的newInstance方法给构造方法实例化.
String str2=(String)constructor1.newInstance(new StringBuffer("abc"));

//打印返回的字符串角标位置上的字符
System.out.println(str2.charAt(2));

    Filed类

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

//成员变量的反射
ReflectPoint pt1 = new ReflectPoint(3, 6);
//成员变量时公有的可以正常反射
Field filedY = pt1.getClass().getField("y"); 
System.out.println(filedY.get(pt1));


//如果成员变量是私有的要进行暴力反射getDeclaredField
Field fieldX = pt1.getClass().getDeclaredField("x");
//调用逆转方法setAccessible(true);
fieldX.setAccessible(true);
//获取
System.out.println(fieldX.get(pt1));

 

练习：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"

import java.lang.reflect.Field;
public class Reflectest {
	public static void main(String[] args) throws Exception {
		ReflectPoint pt1=new ReflectPoint();
		changeStringValue(pt1);
		System.out.println(pt1);
	}

	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);//获取obj的String类型的成员变量
			String newValue=oldValue.replace('b', 'a');//将b换成a
			field.set(obj, newValue);//将此 Field表示的字段设置为指定的新值
		}
		}
	}
}
class ReflectPoint {
	public String str1="ball";
	public String str2="basketball";
	public String str3="itcast";
	//重写toString方法
	public String toString(){
		return str1+"  "+str2+"  "+str3+"  ";
	}
}

    Method类   

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

    得到类中的某一个方法：Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);

    调用方法：

        1.通常方式：System.out.println(str.charAt(1));
        2.反射方式： System.out.println(charAt.invoke(str, 1)); 
        如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！
    jdk1.4和jdk1.5的invoke方法的区别：

        jdk1.5：public Object invoke(Object obj,Object... args)(可变参数)

        jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。

 

    用反射的方式执行某个类的main方法

    首先要明白，为什么要用反射调用一个类中的main方法？

    答：在程序的运行过程中，用户可能会指定调用哪个类的main方法，那么我们写代码的时候，就不能知道用户要调用哪个类的main方法，这个时候只有用反射，将用户传入进来的类名，进行反射调用那个类的main方法。

    问题：

        启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。

    解决办法：
        1.mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});

       2.mainMethod.invoke(null,(Object)new String[]{"xxx"}); 编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了。

 

    数组的反射

    具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。

    代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。

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

代码示例：

int[] a1=new int[]{1,2,3};

int[] a2=new int[4];

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

String[] a4=new String[]{"aaa","bbb","ccc"};
System.out.println(a1.getClass()==a2.getClass());//true
System.out.println(a1.getClass()==a3.getClass());//false
System.out.println(a1.getClass()==a4.getClass());//false
 
printObject(a1);

private static void printObject(Object obj) 
{
	//判断传入参数类型是否为数组
	if(obj.getClass().isArray())
	{
		//获取数组的长度用所遍历使用
		int len = Array.getLength(obj);
		//然后遍历obj并打印数组中的元素
		for(int i=0;i<len;i++) 
		{
			System.out.println(Array.get(obj, i));
		}
	} 
	else 
	{
		//如果不是数组直接打印
		System.out.println(obj);
	}
 }

3.反射的作用--实现框架功能

    框架
    我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

    框架要解决的核心问题

    我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。

示例代码: 

 

package cn.itcast.day01;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
public class ReflectTest2 {

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

	//加载配置文件
		InputStream is = ReflectTest2.class.getResourceAsStream("config.properties");

		Properties prop=new Properties();
		prop.load(is);

		is.close();//关闭流

		String className = prop.getProperty("className");//得到类名

		Collection pt1=(Collection)Class.forName(className).newInstance();//调用空参数构造方法新建对象

		ConstrucPoint cons1=new ConstrucPoint(3,3);
		ConstrucPoint cons2=new ConstrucPoint(5,5);
		ConstrucPoint cons3=new ConstrucPoint(3,3);

		pt1.add(cons1);
		pt1.add(cons2);
		pt1.add(cons3);
		pt1.add(cons1);
		System.err.println(pt1.size());
	}

}

个人总结

    反射给我们带来了不少的好处，在程序的运行过程中直接可以可以反射机制得到某些类的方法，成员变量，构造函数等等，还可以利用这些进行自己想要的操作，特别要记忆的就是反射有一个实现框架的功能。

 

 

 

暴力