反射的应用案例

反射与工厂设计模式

之前学的是静态的工厂模式

class Factory{
	public static IService getInstance(String classname) {
		if("CarService".equals(classname)) {
			return new CarService();
		}else if("ShopService".equals(classname)) {
			return new ShopService();
		}
		return null;
	}
}

Q：静态工厂设计模式耦合性很高，如果接口有很多实现类，有什么方法减少代码的重复？
.+反射

class Factory{
	public static IService getInstance(String classname) {
		IService ser=null;
		try {
			ser=(IService) Class.forName(classname).getDeclaredConstructor().newInstance();
		}catch(Exception e) {
			e.printStackTrace();
		}
		
		return ser;
	}
}

Q：如果有很多种接口，又该怎样避免重写多个接口的繁琐操作？
.+泛型

class Factory{
	private Factory() {}
	@SuppressWarnings("unchecked")//压制警告
	public static <T> T getInstance(String classname,Class<T> cla) {
		T ser=null;
		try {
			ser=(T) Class.forName(classname).getDeclaredConstructor().newInstance();
		}catch(Exception e) {
			e.printStackTrace();
		}
		
		return ser;
	}
}

（抽象）

public static <T> T getInstance(String,Class<T>){
	T;
	try
	interfacename=<T>Class.forName(String).getDeclaredConstructor().newInstance();

	return interfacename;
}

范例：

public class FactoryTest {

	public static void main(String[] args) {
		IMessage instance=Factory.getInstance("wzr.study10.reflex.QQMessage",IMessage.class);
		instance.send();
	}

}
class Factory{
	private Factory() {}
	@SuppressWarnings("unchecked")//压制警告
	public static <T> T getInstance(String classname,Class<T> cla) {
		T ser=null;
		try {
			ser=(T) Class.forName(classname).getDeclaredConstructor().newInstance();
		}catch(Exception e) {
			e.printStackTrace();
		}
		
		return ser;
	}
}
interface IService{
	public void service();
}
class CarService implements IService{
	public void service() {
		System.out.println("car");
	}
}
class ShopService implements IService{
	public void service() {
		System.out.println("shop");
	}
}
interface IMessage{
	public void send();
}
class QQMessage implements IMessage{
	public void send() {
		System.out.println("QQ message");
	}
}

反射与单例设计模式

懒汉模式下的多线程调用该对象会实例化多个对象，是因为多个线程同时访问引起的问题。
可以使用synchronized修饰getInstance方法。这是可行的

	public static synchronized SingleTom getInstance() {
		if(single==null) {
			single=new SingleTom();
		}
		return single;
	}

但是会影响效率。如何使它影响程度减小

	public static SingleTom getInstance() {
		synchronized(SingleTom.class) {//因为是静态函数，不会实例化该对象。所以要用到该类时需要通过反射完成。
			if(single==null) {
				single=new SingleTom();
			}
		}
		return single;
	}

synchronized与volatile，一个是同步代码，让他们不会同一时间访问某块。一个是对变量内存直接操作，而不是对变量的副本操作。
加volatile会影响效率，但是会规避小概率风险。

	private static volatile SingleTom single;

Q：在Java中，有那些用到了单例模式？
A：Runtime类，Class类，Pattern，Spring框架
Q：懒汉式单例模式有些什么问题呢？
A：这小节讨论的问题