黑马程序员----反射机制

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

JAVA反射（放射）机制：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。

java中各个java类属于同一事物，而描述着同一事物的类名就是Class。比如ClassDemo这个类就是实例对象，有不同的属性等等。

获取字节码方式：(返回Class对象)
 1、类名.class 例如：ClassDemo.class
 2、对象名.getClass()  eg：new Date().getClass();
 3、class.forName("java.util.Date");
       class.forName("java.util.Date"); 作用：1、获取date类已经编译的字节码文件  2、如果未编译，就先编译在获取字节码文件

 

九个预定义Class对象 

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

方法：isPrimitive() 判断是不是基本类型(字符串不是基本类型)   判断是否是一个数组类.isArray()

  String  s1="abc";

               Class cls1=s1.getClass();

               Class cls2=String.class;

		Class  cls3=Class.forName("java.lang.String");
		System.out.println(cls1=cls2);//true
		System.out.println(cls1=cls3);//true
		//因为以上都是获取的同一份字节码文件
		//isPrimitive() 判断是不是基本类型(字符串不是基本类型)  
		System.out.println(cls1.isPrimitive());
		System.out.println(int.class.isPrimitive());
		判断int和Integer两个类的字节码是否相同false  
		System.out.println(int.class==Integer.class);//false
		System.out.println(int.class==Integer.TYPE);//true TYPE表示基本类型int的实例
		//判断数组  false
		System.out.println(int[].class.isPrimitive());
		//判断是否是一个数组类.isArray();true  
		System.out.println(int[].class.isArray());  

什么是反射？
 反射就是把java类中各种成分映射成相应的java类(也就是说Class类中getFiled,getMethod,getConstructor三个方法分别映射成java类中成员变量、方法、构造方法)
 也就是说：对任意一个类（class文件），都能够知道这个类的属性、方法，并且都能够任意的调用。
JAVA反射机制是在 运行状态 中，对于任意一个 类 ，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

下面是对对reflect类的Contructor、Field、Method三个方法使用以及功能讲解：

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


public class ClassDemo {

	/**
	 * @param 本类对reflect类的Contructor、Field、Method三个方法使用以及功能讲解
	 */
	public static void main(String[] args) throws Exception{
		//Constructor代表某个类的构造方法 
		//得到某个类所有的构造方法：
		 Constructor[] constructor1=Class.forName("java.lang.String").getConstructors();
		 //得到某一个构造方法
	     Constructor constructor=Class.forName("java.lang.String").getConstructor(StringBuffer.class);
		 System.out.println(constructor1+"-------"+constructor);
		 //创建实例对象
		 String  str=new String(new StringBuffer("abc"));//普通创建对象方式
		 //反射创建对象  注意：调用获得的方法时要用到上面相同类型的实例对象
		 String  str1=(String) constructor.newInstance(new StringBuffer("abc")); 
		 System.out.println(str1.charAt(2));
		 //得到默认无参构造函数，直接创建对象。利用缓存机制来保存默认构造函数的实例对象
		 String  str2=String.class.newInstance();
		
		 
		 //Field类
		 
		 FieldDemo  fd1=new FieldDemo(3, 5);
		 Field  fieldy=fd1.getClass().getField("y");//获得类的成员变量，主要此处获取的fieldy值不是5
		 //通过对象获取对应的值
		 System.out.println(fieldy.get(fd1));
		 Field  fieldx=fd1.getClass().getDeclaredField("x");
		 //因为x变量是private的，所以这里用到暴力反射，设置可访问。getDeclaredField  
		 fieldx.setAccessible(true);
		 System.out.println(fieldx.get(fd1));
		 
	
       changValue(fd1);
       System.out.println(fd1);
       
       
       //Method类，代表一个某个类的成员方法
       //1、得到某个类中的一个成员方法
       Method method=String.class.getMethod("charAt", int.class);
       //调用方法
       System.out.println(method.invoke(str1, 1));
       //如果说把method.invoke(str1, 1)改成method.invoke(null, 1)那么就说明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})形式。
        */
       
	}
	 //写一个方法，通过反射改变对象string类型 成员变量的值。把a改成b
	public static void changValue(Object obj) throws Exception{
		//得到所有的成员变量，包括private
		Field[] field=obj.getClass().getDeclaredFields();
		//System.out.println("changdu:"+field.length);
		for (Field  field2: field) {
			//这个使用==不使用equals，因为只有一份字节码文件
			if(field2.getType()==String.class){
				String  oldValue=(String) field2.get(obj);//得到String类型的成员变量
				String newValue=oldValue.replace('a', 'b');
				field2.set(obj, newValue);
				
			}
		}
	}
}

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

    框架

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

    框架要解决的核心问题

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

例子：

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Collection;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;

public class CollectionsDemo {

	public static void main(String[] args) throws Exception{
		
        InputStream  is=new FileInputStream("prop.properties");
        Properties  prop=new Properties();
        prop.load(is);
        String classname=prop.getProperty("className");
        Collection collection=(Collection) Class.forName(classname).newInstance();
		//Collection collection=new HashSet();
		FieldDemo   fd1=new FieldDemo(1, 1);
		FieldDemo   fd2=new FieldDemo(2, 2);
		FieldDemo   fd3=new FieldDemo(1, 1);
	    collection.add(fd1);
	    collection.add(fd2);
	    collection.add(fd3);
	    collection.add(fd1);
	   // fd1.y=4;
	  //  collection.remove(fd1);
	    System.out.println(collection.size());    
	    String  str1=new String("zhangde");
	    String  str2=new String("zhangde");
	    System.out.println(str1==str2);//比较的是地址
	    System.out.println(str1.equals(str2));//比较对象的值
	    System.out.println(str1.hashCode());
	    System.out.println(str2.hashCode());   
	    Set   hashSet=new HashSet();
	    hashSet.add(str1);
	    hashSet.add(str2);
	    System.out.println(hashSet.size());
	    
		
	}

}

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