静态工厂方法

一、对象的创建
       第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 () {}
           

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();
                                    } atch(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);

我们做了什么一幕了然。当然这个例子可能有些不伦不类，但是在这里仅仅想说明这个问题，很极端但是很明确。

静态工厂方法每次被调用的时候，不要求非得创建一个新的对象