单例模式Singleton Pattern
    确保类只有一个实例，而且自行实例化并向整个系统提供这个实例
    public class Singleton{
        private static final Singleton singleton = new Singleton();
        private Singleton(){}
        public static Singleton getSingleton(){
            return singleton;
        }
    }
    节省内存开支，减少性能开销，应用启动产生单例对象，永久驻留内存
    单例模式与单一职责原则冲突，把“需要单例”功能和业务逻辑融合在一个类
    私有构造函数的对象仍然可以被复制，单例模式类不应该实现Cloneable接口
    单例模式拓展，多个实例的单例模式
        public class MoreSingleton{
            private static final int maxNum=2;
            private static ArrayList<MoreSingleton> singletonList = new ArrayList<MoreSingleton>();
            ArrayList<MoreSingleton>(String value){
                valueList.add(value);
            }
            private static ArrayList<String> valueList = new ArrayList<String>();
            //产生所有对象
            static{
                for(int i=0;i<maxNum;i++){
                    singletonList.add(new MoreSingleton(value));
                }
            }
            private MoreSingleton(){}
            public static MoreSingleton getMoreSingleton(int index){
                return singletonList.get(index);
            }
        }
工厂方法模式Factory Pattern 
    定义一个用于创建对象的接口，让子类决定实例化哪一个类
    //定义抽象产品类
    public abstract class Product{
        public abstract void method();
    }
    //定义具体产品类
    public class ConProduct extends Product{
        public void method(){}
    }
    //定义抽象工厂类
    public abstract class Factory{
        public abstract <T extends Product> T createProduct(Class<T> c);
        //泛型，所有继承Product的类
    }
    //具体工厂类
    public class ConFactory extends Factory{
        public <T extends Product> T createProduct(Class<T> c){//工厂函数
            Product product=null;
            try{
                product=(Product)Class.forName(c.getName()).newInstance();//内省
            }catch(Exception e){//异常处理}
            return (T)product;
        }
    }
    工厂方法模式封装良好，结构清晰，易于扩展。是典型的解耦框架，高层模块只需要知道产品的抽象类，符合迪米特法则和依赖倒置原则，只依赖产品类的抽象，也符合里氏替换原则。
    工厂方法模式扩展
        简单工厂模式Simple Factory Pattern,去除抽象工厂类，将工厂函数设为static。
        多工厂模式，每个具体产品对应一个共产类，类职责清晰，结构简单，但增加了扩展难度。
        替代单例模式
            public class Singleton{
                private Singleton();
            }
            public class SingletonFactory{
                private static Singleton singleton;
                static{
                    try{
                        //通过反射方式创建单例类
                        Class cl = Class.forName(Singleton.class.getName());
                        //获得无参构造
                        Constructor con = c1.getDeclaredConstructor();
                        //设置无参构造可访问
                        con.setAccessible(true);
                        //产生实例
                        singleton = (Singleton)con.newInstance();
                    }catch(Exception e){//异常处理}
                }
                public static Singleton getSingleton(){
                    return singleton;
                }
            }
        延迟初始化，对象创建后在类内保存引用，在下次创建对象时查找类内是否存在，有则直接取出返回，如在ProductFactory类内定义private static final Map<String,Product> prMap = new HashMap();
抽象工厂模式Abstract Factory Pattern
    为一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
    抽象工厂模式是工厂方法模式的升级版本，当有多个业务品种，业务分类时，通过抽象工厂模式解决。
    //抽象产品类A
    public abstract class AbstractProductA{
        public abstract void method();
    }
    //A系列产品A1实现类
    public class ProductA1 extends AbstractProductA{
        public void method(){}
    }
    //A系列产品A2实现类
    public class ProductA2 extends AbstractProductA{
        public void method(){}
    }
    //抽象产品类B
    public abstract class AbstractProductB{
        public abstract void method();
    }
    //B系列产品B1实现类
    public class ProductB1 extends AbstractProductB{
        public void method(){}
    }
    //B系列产品B2实现类
    public class ProductB2 extends AbstractProductB{
        public void method(){}
    }
    //抽象工厂类
    public abstract class AbstractFactory{
        public abstract AbstractProductA createProductA();
        public abstract AbstractProductB createProductB();
    }
    //产品1工厂类
    public class Factory1 extends AbstractFactory{
        public AbstractProductA createProductA(){
            return new ProductA1();
        }
        public AbstractProductB createProductB(){
            return new ProductB1();
        }
    }
    //产品2工厂类
    public class Factory2 extends AbstractFactory{
        public AbstractProductA createProductA(){
            return new ProductA2();
        }
        public AbstractProductB createProductB(){
            return new ProductB2();
        }
    }
    抽象工厂模式产品族扩展复杂