反射(二)
概述
用一个对象,来表示一个类(Class)
用一个对象,来表示一个方法(Method)
用一个对象,来表示一个构造器(Constructor)
用一个对象,来表示一个成员变量(Field)
用一个对象,来表示一个包(Package)
…
实操
获取类中的信息(类名、方法、构造器、成员变量)
包扫描
根据类对象,创建一个此类的实例
根据一个构造器,创建一个此类的实例
设计模式
工厂模式
工厂方法模式
在工厂类中,有一个方法,调用此方法,就能创建一个产品
定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类
抽象工厂模式
依赖于工厂方法模式。既: 在工厂类中,有多个工厂方法。这一些工厂方法,所生产出产品,是配套的,或者说一系列的。
提供一个创建一系列相关或相互依赖对象的接口。而无需指定它们具体的类。
简单工厂
单例模式
保证一个类仅有一个实例,并提供一个访问它的全局访问点。
分为饿汉式和懒汉式
饿汉式: 在静态成员的初始化时,就创建好。饿汉式单例天生线程安全
懒汉式: 在第一次静态方法被调用时。懒汉式单例天生线程不安全
为了保证懒汉式的线程安全
有3个解决方案:
- 同步代码块
- 双重检查锁
- 静态内部类【了解】
public class HungryBoss {
private String name;
private String gender;
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
// 2. 别人修改不了
private static HungryBoss boss = new HungryBoss();
// 保证一个类仅有一个实例,并提供一个访问它的唯一全局访问点。
// 1. 不允许别人来创建Boss
// 既: 构造器不允许别人使用
private HungryBoss() {
}
// 3. 别人能来访问
public static HungryBoss getInstance() {
return boss;
}
}
public static void main(String[] args) {
HungryBoss instance = HungryBoss.sharedInstance();
HungryBoss instance1 = HungryBoss.sharedInstance();
instance.setName("张三");
instance1.setGender("f");
instance.setEmail("zhangsan@1000beauty.com");
System.out.println();
}
同步代码块懒汉式
public class LazyBoss {
private String name;
private String gender;
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
private static LazyBoss instance;
private LazyBoss() {}
public synchronized static LazyBoss sharedInstance() {
// 第一次被访问时才创建
if (instance == null) {
instance = new LazyBoss();
}
return instance;
}
}
双重检查锁懒汉式
public class LazyBoss {
private String name;
private String gender;
private String email;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
private static LazyBoss instance;
private LazyBoss() {}
public static LazyBoss sharedInstance() {
// 第一次被访问时才创建
if (instance == null) {
synchronized (LazyBoss.class) {
if (instance == null) {
instance = new LazyBoss();
}
}
}
return instance;
}
}
懒汉式测试类
public class BossGetter implements Callable<LazyBoss> {
@Override
public LazyBoss call() throws Exception {
LazyBoss lazyBoss = LazyBoss.sharedInstance();
return lazyBoss;
}
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService pool = Executors.newFixedThreadPool(5);
BossGetter bossGetter1 = new BossGetter();
BossGetter bossGetter2 = new BossGetter();
BossGetter bossGetter3 = new BossGetter();
Future<LazyBoss> submit1 = pool.submit(bossGetter1);
Future<LazyBoss> submit2 = pool.submit(bossGetter2);
Future<LazyBoss> submit3 = pool.submit(bossGetter3);
LazyBoss lazyBoss1 = submit1.get();
LazyBoss lazyBoss2 = submit2.get();
LazyBoss lazyBoss3 = submit3.get();
System.out.println(lazyBoss1);
System.out.println(lazyBoss2);
System.out.println(lazyBoss3);
pool.shutdown();
}