单例模式和工厂方法模式

//单例模式
/**
 *饿汉式的单例模式
 * 程序初始化时就建立好了
 * @author luthor21
 */
class Singletone{
    private static final Singletone s = new Singletone();
    private Singletone(){}
    public static Singletone getInstance(){
        return s;
    }
}

/**
 *懒汉式的单例模式
 * 在使用到的时候才会创建实例
 * @author luthor21
 */

class Singletonl{
    private static Singletonl s = null;

    public Singletonl() {
    }

    public static Singletonl getInstance(){
        if (null==s){
            s = new Singletonl();
        }
        return s;
    }
}


/**
 * 多线程环境下的懒汉式单例模式(DCL，双检锁+volatile实现)
 * 加入了volatile变量来禁止指令重排序
 * @author luthor21
 */

class Singleton{
    private static volatile Singleton s = null;

    public Singleton() {
    }
    public static Singleton getInstance(){
        if (null==s){
            synchronized (Singleton.class){
                if (null==s){
                    s = new Singleton();
                }
            }
        }
        return s;
    }
}

//单例模式的优点：单例模式保证了一个类在一个系统中有且只有一个对象实例，减少了系统内存和性能的开销。
//
//单例模式的使用场景：创建一个对象需要消耗太多的资源或者在一个系统中不适合创建多个对象实例的情况下，我们可以采用单例模式设计实现。







//工厂方法模式
//工厂方法模式定义了一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。
public class FactoryMethodTest {
    public static void main(String[] args) {
        // 创建具体的创建类对象
        Creator creator = new ConcreteCreator();
        // 通过传入指定的产品类对象，来创建对应的产品
        Product product1 = creator.createProduct(ConcreteProduct1.class);
        product1.method1();
        product1.method2();

        Product product2 = creator.createProduct(ConcreteProduct2.class);
        product2.method1();
        product2.method2();
    }
}

//定义抽象产品类
abstract class Product{
    //产品类的公共方法
    public void method1(){
        //公共的业务逻辑
        System.out.println("产品类的公共方法");
    }
    //抽象方法
    public abstract void method2();
}

//定义具体产品类
class ConcreteProduct1 extends Product{

    @Override
    public void method2() {
        // 具体产品类1的业务逻辑处理
        System.out.println("ConcreteProduct1的method2()");
    }
}

class ConcreteProduct2 extends Product{

    @Override
    public void method2() {
        // 具体产品类2的业务逻辑处理
        System.out.println("ConcreteProduct2的method2()");
    }
}

//定义抽象创建类
abstract class Creator{
    // 创建对象的抽象方法
    public abstract <T extends Product> T createProduct(Class<T> c);
}

// 定义具体的创建类，真正来创建所需的对象
class ConcreteCreator extends Creator{

    @Override
    public <T extends Product> T createProduct(Class<T> c) {
        Product product = null;
        try {
            // 通过反射技术来创建对象
            product = c.newInstance();
//            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
        }
        return (T) product;
    }
}