java【反射与工厂模式】

好的设计模式重用性

工厂设计与反射之间的联系

第一种实现单个接口的工厂设计模式，通过 class 中的方法

T newInstance() 已过时。

此方法传播由 nullary 构造函数引发的任何异常，包括已检查的异常。这种方法的使用有效地绕过了编译时异常检查，否则该检查将由编译器执行。该 Constructor.newInstance 方法通过将构造函数抛出的任何异常包装在（选中）中来避免此问题 InvocationTargetException。

现在使用的是

clazz.newInstance()· 可以替换为 clazz.getDeclaredConstructor().newInstance()

静态的工厂设计模式

（避免主类中多个子类的耦合性的问题）的弊端就是在每次需要是实现一个新的子类对象的时候都要使用 new 关键字，进行一个新的对象生成，而反射实现一个对象的时候可以通过 String 类型进行实现例化一个对象

动态工厂

实现一个多个接口的，多个子类的的一个智能的工厂设计模式。这个地址使用的主要使用的泛型技术，使用泛型，主类使用传递一个 String 类型的字符串类所在地址路径，和一个接口使用 jvm 实例化反射的方法 class<T> clazz=类名.class,实现一个规定好了转型的

核心代码，实体类代码未写

package ITaljavaT3;

public class demo01 {

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

		IMessage msg = Factory.getInstance("cn.demo.NetMessage" , IMessage.class) 
		msg. send();
		IService service = Factory.getInstance("cn.demo.HouseService",IService.class) ;
		service. service(); 
	}
}
class Factory {
	private Factory() {} // 没有产生实例化对象的意义，所以构造方法私有化

	/*获取接口实例化对象
	* @param className接口的子类
	* @param clazz描述的是-个接口的类型
	* @return 如果子类存在则返回指定接口实例化对象
	*/
	@SuppressWarnings ( "unchecked")
	public static <T> T getInstance(String className,Class<T> clazz) {
		T instance = null ;
		try {
				instance = (T) Class .forName(className). getDeclaredConstructor() .newInstance() ; 
		} catch (Exception e) {
			e.printStackTrace();
		}

		return instance;
	}
}

​

反射和单例设计

设计模式问题：多线程的同步问题，以及单例的的对象应该使用 volatil 修饰成员属性

package javaApi.com;
/*
 * 用反射实现一个标准的懒汉式的单例设计模式
 */
class oneUtil{
	private static volatile oneUtil one=null;//一个实例化对象的属性
	private oneUtil() {
		System.out.println(Thread.currentThread().getName()+"实例化对象");
	}
	public static oneUtil getOneUtil() {
		if(one==null) {
			synchronized (oneUtil.class) {
				if(one==null) {
					one= new oneUtil();
				}
			}

		}
		return one;
	}
	public void print() {
		System.out.println("www.al.com");
	}
}
public class oneDemo {
	public static void main(String[] args) {
		for(int i=0;i<3;i++) {
			new Thread(()->{
					oneUtil.getOneUtil().print();
			} ,"执行线程"+i).start();  
		}
	}
}
​

静态 synchronized 方法和非静态 synchronized 方法方法区别在于静态 synchronized 方法的锁是当前类的 class 对象，而非静态 synchronized 方法的锁是当前实例对象，所有静态 synchronized 方法竞争的都是同一把锁

volatile 这个关键字很值得去研究一下，简单概括保持可见性，并没有保持原子性，

如果多个线程同时操作 volatile 变量，那么对该变量的写操作必须在读操作之前执行(禁止重排序)，并且写操作的结果对读操作可见（强缓存一致性）