Class的使用

在java里万事万物皆对象，但是在java里有两个不是对象，静态的成员，和普通的数据类型不是。而类是对象，是java.lang.Class类的实例对象

例如：一个Person类的实例 Person person1 = new Person();

而且Person也是一个实类对象（任何一个类都是Class类的实例对象），但Class类的实类对象不能通过new出来，因为：Class类是一个私有的对象只有java的虚拟机可以创建Class实类对象，而想要new出一个Class类的对象，有三种方法：

1.Class person2 = Person.class；（说明任何一个类都有一个隐含的静态成员变量class）类名.class

2.Class person3 = person1.getClass(); 对象.getClass()

**person2,person3都是Person类的类类型（class type）类也是对象，是Class类的实例对象，在这个对象是该例的类类型

person2==person3不管person2，person3，都代表了Person类的类类型，一个类只可能是Class类的一个实类对象

3.Class person4 = null; person4.forName("类的全称包含包名");Class.forName("");

可以通过类的类类型创建该类的对象实类（通过person2，person3，person4创建Person的实例）

Person person5 = (Person) person2.newInstance();(前提是要有无参数的构造方法)

动态加载类

Class.forName("类的全名")

表示了类的类类型，动态加载类

编译时刻加载类是静态加载类，运行时刻加载类是动态加载类

new创建新对象是静态加载类，编译时就加载所有可能用到的类（通过动态加载类就可解决这种问题）

Person类

public class Person {
	public static void main(String[] args) {
		try {
			Class c =Class.forName("args");//运行时加载
			try {
				Food fd = (Food) c.newInstance();//通过类类型创建对象
				fd.start();//调用类的对象
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}	
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

Food接口

public interface Food {
	public void start();
}

Apple类

public class Apple implements Food {
	public void start() {
		System.out.println("Apple...start");
	}
}

编译：javac Person.java

javac Apple.java

执行;java Person Apple 这样就可以

当想要执行:java Person Rice，就可以写一个Rice类实现接口Food，并编译Rice不用重新编译Person类。

比如升级某些软件的时候就是动态加载一些新的东西

获取方法信息

public void getMethodMessage(Object obj) {
		Class c = obj.getClass();//首先获取类的类类型
		String className = c.getName();//获取类名
		
		Method[] methods1 = c.getMethods();//获取所有public方法，包括父类继承来的
		Method[] methods2 = c.getDeclaredMethods();//获取所有方法，不限访问权限
		
		Class type = methods1[1].getReturnType();//得到方法返回值类型的类类型
		String typeName = type.getName();//得到返回值类型的名字
		Class[] ParamsList = methods1[1].getParameterTypes();//得到参数列表的类类型	
	}

获取成员变量信息

成员变量也是对象

在java.lang.reflect.Field封装了关于成员变量的操作

getFields();获取所有成员变量的信息

getDeclaredFields();获取该类自己声明的成员变量信息

getType();得到成员变量的类类型

获取构造函数信息

c.getConstructors();获取所有public构造函数类类型

方法反射

方法反射的操作：method.invoke(对象，参数列表)

Method m = c.getMethod("方法名"，参数.class....)

m.invoke(Person,参数列表)；相当于Person.方法名(参数)；

public static void main(String[] args) {
		ArrayList list = new ArrayList();
		
		ArrayList<String> list1 = new ArrayList<String>();
		list1.add("hello");
		//list1.add(20);错误的
		Class c1 = list.getClass();
		Class c2 = list1.getClass();
		System.out.println(c1 == c2);
		//反射的操作都是编译之后的操作
		
		/*
		 * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
		 * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，
		 * 绕过编译就无效了
		 * 验证：我们可以通过方法的反射来操作，绕过编译
		 */
		try {
			Method m = c2.getMethod("add", Object.class);
			m.invoke(list1, 20);//绕过编译操作就绕过了泛型
			System.out.println(list1.size());
			System.out.println(list1);
			/*for (String string : list1) {
				System.out.println(string);
			}*///现在不能这样遍历
		} catch (Exception e) {
		  e.printStackTrace();
		}
	}

复习java的反射机制