二十四、反射

1. 类的对象

I. 基于某个类new出来的对象，也称为实例对象。

2. 类对象

I. 类加载的产物
II. 封装了一个类的所有信息(类名、父类、接口、属性、方法、构造方法)
III. 一类.class文件就代表着一个类对象

3. 获取类对象

I. 通过类的对象，获取类对象
(1) . Student s = new Student(); Class c = s.getClass();
II. 通过类名获取类对象
(1) . Class c = 类名.class;
III. 通过静态方法获取类对象
(1) . Class.forName(“包名.类名”);

4. 常用方法

//获得指定类对象的包
		Package pack = c.getPackage();
		System.out.println(pack.getName());
		//获得父类的class对象
		Class superclass = c.getSuperclass();
		System.out.println(superclass.getName());
		//获得接口的Class对象
		Class[] interfaces = c.getInterfaces();
		for(Class inter : interfaces) {
			System.out.println(inter.getName());
		}
		//获取属性（public）
		Field[] fields = c.getFields();
		for(Field f : fields) {
			System.out.println(f.getName());
		}
		//获取Class自身的所有公开属性
		Field[] field2 = c.getDeclaredFields();
		for(Field f : field2) {
			System.out.println(f.getName());
		}
		System.out.println("................");
		//获取自身加父类的所有公开方法
		Method[] method = c.getMethods();
		for (Method method2 : method) {
			System.out.println(method2.getName()+":"+method2.getReturnType());
		}
		//获取构造方法
		System.out.println("------constructor--------");
		Constructor[] cs = c.getConstructors();
		for(Constructor ct : cs) {
			System.out.print(ct.getName()+":");
			Class[] param = ct.getParameterTypes();
			for(Class p:param) {
				System.out.println(p.getName());
			}
		}
		//通过反射创建对象
		Class c3 = Teacher.class;
		Teacher o = (Teacher)c3.newInstance();
		System.out.println(o);	

		//取消方法修饰符检查,可以访问私有方法
		m.setAccessible(true);

5. 工厂设计模式

I. 开发中有一个非常重要的原则：“开闭原则”。对拓展开放、对修改关闭
II. 工厂模式主要负责对象创建的问题。
III. 可通过反射进行工厂模式的设计，完成动态的对象创建。

6. 通用编程

 public static void invokeAny(Object obj,String methodName,Class[] types,Object... args) throws Exception{
		//使用反射技术得到任何方法
		//类对象
		Class c = obj.getClass();
		//获得方法的对象Method
		Method m = c.getMethod(methodName, types);
		//执行方法
		m.invoke(obj, args);
	}

7. 单例模式

I.只允许创建一个该类的对象。
II. 方式1：饿汉式(类加载时创建，天生线程安全);
III. 方式2：懒汉式(使用时创建，线程不安全，需要加锁);
IV. 方式3：懒汉式(使用时创建，线程安全。无锁);

//饿汉式 --不用也创建了对象，线程安全
class Singleton{
private static final Singleton instance = new Singleton();
private Singleton() {}
	public static Singleton getInstance() {
		return instance;
}
//懒汉式：使用时创建对象，线程不安全
class Singleton{
private static Singleton instance = null;
	
	private Singleton() {}
	
	public static synchronized Singleton getInstance() {
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}
//懒汉式：使用时创建对象，线程安全
class Singleton{
	private Singleton() {}
	
	private static class Holder{
		static final Singleton instance = new Singleton();
	}
	
	public static Singleton getInstance() {
		return Holder.instance;
	} 
}