day23---反射，工厂模式，单例模式

反射

概述

用一个对象，来表示一个类(Class)
用一个对象，来表示一个方法(Method)
用一个对象，来表示一个构造器(Constructor)
用一个对象，来表示一个成员变量(Field)
用一个对象，来表示一个包(Package)
…

实操

获取类中的信息(类名、方法、构造器、成员变量)
包扫描
根据类对象，创建一个此类的实例
根据一个构造器，创建一个此类的实例

设计模式

工厂模式

工厂方法模式

在工厂类中，有一个方法，调用此方法，就能创建一个产品
定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类

抽象工厂模式

依赖于工厂方法模式。既: 在工厂类中，有多个工厂方法。这一些工厂方法，所生产出产品，是配套的，或者说一系列的。
提供一个创建一系列相关或相互依赖对象的接口。而无需指定它们具体的类。

简单工厂

单例模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点。
分为饿汉式和懒汉式

饿汉式: 在静态成员的初始化时，就创建好。饿汉式单例天生线程安全
懒汉式: 在第一次静态方法被调用时。懒汉式单例天生线程不安全

为了保证懒汉式的线程安全
有3个解决方案:

1. 同步代码块
2. 双重检查锁
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();
    }