静态工厂

一、对象的创建
       第1条：考虑用静态工厂方法代替构造函数
             概念：所谓静态工厂方法（static factory method），实际上只是一个简单的静态方法，它返回的是类
                         的一 个实例。
              例子：pbulic static Boolean getBoolean()
                          {
                               return (Boolean.TRUE);
                           }
                 优点：1、与构造函数相比，静态工厂方法可以具有一个具有意义的名字
                             2、与构造函数相比，每一次调用并不一定非要创建一个新的对象
                                   例子：
                                           class SingletonFactory
                                            {   // 可以看作全局唯一的变量
                                                   private static singletonfactory=new SingletonFactory()；

                                                   private SingletonFactory()
                                                  {}

                                                  public static SingletonFactory getSingletonFactoryInstance()
                                                  {    
                                                      //这里并不是每次都返回一个新的对象，而是反复返回同一个对象
                                                         return singletonfactory;
                                                     }
                                             }
                                3、与构造函数不同，可以返回一个原返回类型的子类型的对象
                                       例子：
                                               Interface BaseInterface
                                                {
                                                        void printlns();
                                                }
                                                class BaseImp implements BaseInterface
                                                {
                                                          public BaseImp ()
                                                         {}
                                                         public void printlns()
                                                          {
                                                                  System.out.println("BaseImp's printlns method ");
                                                            }
                                                }

                                                abstract class SingletionFactory
                                                {
                                                      private static SingletionFactory singletionfactory;
                                                     private static String classname="";
                                                      private static Object object=new Object();

                                                      public static BaseInterface getBaseInterface()
                                                      {
                                                               if (singletionfactory==null)
                                                                {
                                                                    synchorinzed(obj){
                                                                          try
                                                                           {
                                                                                   singletionfactory=(SingletionFactory)Class.forNmae(
                                                                                  classname).newInstaance();
                                                                           }
                                                                           catch(ClassNotFoundException e)
                                                                          {
                                                                            
                                                                           }
                                                                      }
                                                                 }
                                                                return singletionfactory.createObject();
                                                       }
                                                        abstract BaseInterface createObject();
                                                }

                       缺点：
                          1、如果类没有public or protected 构造函数，不能子类化
                          2、与其他静态方法没有任何区别，静态工厂方法代表了一种对规范的背离