Java反射

                   

      有很多个小的对象，他们有很多属性相同，把他们变成一个对象。那些不同属性变成方法的参数，称之为外部的状态，那些相同的属性称为对象的内部状态。

       枚举类

       枚举（enum）就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以在编译器编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

       枚举的构造方法：1、枚举的构造方法只能是private；2、构造方法在所有列表之后；

       枚举示例：

public enum TrafficLamp
	{
		
		RED(30)
		{
			public TrafficLamp nextLamp()
			{
				return GREEN;
			}
		},
		GREEN(45)
		{
			public TrafficLamp nextLamp()
			{
				return YELLOW;
			}
		},
		YELLOW(5)
		{
			public TrafficLamp nextLamp()
			{
				return RED;
			}
		};
		
		public abstract TrafficLamp nextLamp();
		private int time;
		private TrafficLamp(int time)
		{
			this.time = time ;
		}
	
	}   

 

反射-Class类

Java类用于描述一类事物的共性，该类事物的属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性。Java程序中的各个Java类，它们是否属于同一个事物，是不是可以用一个类来描述这类事物？这个类的名字就是Class。Class类描述的信息：类的名字，类的访问属性，类所属于的包名，字段名称的列表，方法名称的列表，等等。

如何得到各个字节码对应的实例对象（Class类型）

类名.class，例如，System.class

对象.getClass（），例如，new Date（）.getClass（）

Class.forName（‘类名’），例如，Class.forName（”java.util.Date”）

反射：就是把java类中的各种成分映射成相应的java类。例如一个java类中用一个Class类的对象来表示，一个类的组成部分：成员变量，方法，构造方法，包等等也用一个个的java类来表示。表示java类的Class类需要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Filed，Method、Constructor、Package等等。

接下来给一个利用Constructor类进行new一个String对象：

import java.lang.reflect.Constructor;

public class ReflectTest
{

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{
		// TODO Auto-generated method stub
		
		
		Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
		
		String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
		
		System.out.println(str2.charAt(2));
	}

}
接下来一个关于Field的示例：
public class ReflectPoint
{
	private  int x ;
	public  int y;
	public ReflectPoint(int x, int y) 
	{
		super();
		this.x = x;
		this.y = y;
	}
	
}
public class ReflectTest
{

	/**
	 * @param args
	 */
	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");
		
		System.out.println(fieldY);
		System.out.println(fieldY.get(pt1));
		fieldX.setAccessible(true);
		System.out.println(fieldX.get(pt1));
	}

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

public class ReflectTest
{
	public static void main(String[] args) throws Exception
	{
		Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
		String str2 = (String)constructor1.newInstance(new StringBuffer("abc"));
		System.out.println(str2.charAt(2));
		
		Method methodCharAt = String.class.getMethod("charAt", int.class);
		System.out.println(methodCharAt.invoke(str2,1));
		
		String startingClassName = args[0];
		Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
		mainMethod.invoke(null,(Object)new String[] {"111","222","333"});
			
		mainMethod.invoke(null,new Object[]{new String[] {"111","222","333"}});
	}
}
class TestArguments
{
	public static void main(String[] args)
	{
		for(String arg : args)
		{
			System.out.println(arg);
		}
	}
}

 

数组的反射

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

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

public class ReflectTest
{

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{
			
		int[] a1 = new int[]{2,3,4};
		int[][] a2 = new int[4][4];
		int[][] a3 = new int[2][3];
		String[] a4 = new String[]{"a","b","c"};
		Object aObj1 = a1;
		Object aObj2 = a4;
		
		Object[] aObj4 = a3;
		Object[] aObj5 = a4;
		
		System.out.println(a1);
		System.out.println(a4);
		
		System.out.println(Arrays.asList(a1));
		System.out.println(Arrays.asList(a4));
}
}

反射的作用实现框架功能
框架与框架要解决的核心问题
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

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

       示例1：

首先建立一个文件：文件名：config.properfies. 内容为：className=java.util.ArrayList;
	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 
{

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception
	{
		// TODO Auto-generated method stub\
		InputStream ips = new FileInputStream("config.properties");
		Properties props = new Properties();
		props.load(ips);
		ips.close();
		String className = props.getProperty("className");
		Collection collections = (Collection)Class.forName(className).newInstance();
		
		//Collection collections = new HashSet();
		
		ReflectPoint pt1 = new ReflectPoint(3,3);
		ReflectPoint pt2 = new ReflectPoint(5,5);
		ReflectPoint pt3 = new ReflectPoint(3,3);
		
		collections.add(pt1);
		collections.add(pt2);
		collections.add(pt3);
		collections.add(pt1);
	
		
		System.out.println(collections.size());

	}

}