静态工厂方法

一、对象的创建
       第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、与其他静态方法没有任何区别，静态工厂方法代表了一种对规范的背离

 

类可以提供一个公有的静态工厂方法，它用来返回这个类的实例，从而可以构造这个类的对象。 静态工厂方法的好处： 它与构造函数不同，静态工厂方法具有名字。这个好处可以帮助我们摆脱一个类只能有一个原型相同的构造函数的限制。举个例子来说： public class A { pubilc int sum=0; public int div=0; public A(int a,int b) { sum=a+b; // 利用 a 和 b 在这里初始化 A 的实例 } public A(int a,int b)          // 明显的错误 { div=a/b; } } 就像上面代码所示，这么做是绝对不可能的，构造函数的签名只在参数上进行区分，如果我们想用同一种参数实现不同的构造函数，那么构造函数的局限性就肯定了它是做不到的。但是我们可以利用静态工厂方法来轻松解决这个问题： public class A { public int sum=0; public int div=0; public static A Sum(int a,int b) { A a1=new A(); a1.sum=a+b; return a1; } public static A Div(int a,int b) { A a1=new A(); a1.div=a/b; return a1; } } 很明显，我们可以用相同的参数来构造不同的对象了，如： A a1=A.Sum(5,5); A a2=A.Div(5,5); 我们做了什么一幕了然。当然这个例子可能有些不伦不类，但是在这里仅仅想说明这个问题，很极端但是很明确。 静态工厂方法每次被调用的时候，不要求非得创建一个新的对象。有的时候我们仅仅需要这个类所表示某些项，但是不需要这个类的实例，那么静态工厂方法可以很好的满足这个要求。 静态工厂方法可以返回一个原返回类型的子类型的对象。 静态工厂方法的缺点： 类如果不含公有的或者受保护的构造函数，就不能被子类化。对于公有的静态工厂所返回的非公有类，也是同样的。如果一个类没有共有的或者受保护的构造函数，那么这个类就不能被继承。 静态工厂方法与其他的静态方法没有任何区别。 在 API 文档中，它们不会像构造函数那样被明确标识出来。 所谓静态工厂方法,就是返回类的一个实例的静态方法. 静态工厂方法的优点是: 1.静态工厂方法具有名字 2.每次被调用的时候不要求非得创建一个新的对象. 3.可以返回一个原返回类型的子类型的对象 静态工厂方法的缺点是: 1.类如果不含公有的或者受保护的构造函数就不能被子类化 2.比其他静态方法没有区别,不能标志它们的特殊性 闲话少叙,我们来看看静态工厂方法怎么来实现.我们来举个例子: public class Cat{ private String name; private String color; private String host; /* ...... getter/setter方法 */ public Cat(){ } public Cat(String name,String color,String host){ this.name = name; this.color = color; this.host = host; }        //知道名字,颜色和主人名字的时候调用的静态方法 public static Cat getCatwithFullinfo(String name,String color,String host){ return new Cat(name,color,host); } //不知道任何信息的时候调用的静态方法 public static Cat getCat(){ return new Cat(); } //只知道名字的时候调用的静态方法 public static Cat getCatwithName(String name){ return new Cat(name,"",""); } //只知道颜色的时候调用的静态方法 public static Cat getCatwithColor(String color){ return new Cat("",color,""); } //只知道主人名字的时候调用的静态方法 public static Cat getCatwithHost(String host){ return new Cat("","",host); } //知道名字和颜色的时候调用的静态方法 public static Cat getCatwithNameColor(String name,String color){ return new Cat(name,color,""); } //知道名字和主人名字的时候调用的静态方法 public static Cat getCatwithNameHost(String name,String host){ return new Cat(name,"",host); } //知道颜色和主人名字的时候调用的静态方法 public static Cat getCatwithColorHost(String color,String host){ return new Cat("",color,host); } } 使用静态工厂方法时,可以在知道的信息不完整的情况下,找到适合的构造方法.