好的设计模式重用性
工厂设计与反射之间的联系
第一种实现单个接口的工厂设计模式,通过 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 变量,那么对该变量的写操作必须在读操作之前执行(禁止重排序),并且写操作的结果对读操作可见(强缓存一致性)
欢迎来到这里!
我们正在构建一个小众社区,大家在这里相互信任,以平等 • 自由 • 奔放的价值观进行分享交流。最终,希望大家能够找到与自己志同道合的伙伴,共同成长。
注册 关于