静态工场方法

静态工厂方法
它只是一个简单的静态方法,返回类的一个实例.

1. 与构造函数不同,静态工厂方法具有名字.选用适当名字的静态工厂方法可以使一个类更易于使用,并且相应的客户代码更易于阅读.

2. 与构造函数不同,不要求非得创建一个新的对象.这使得一些非可变类可以使用一个预先构造好的实例,或者把已经构造好的实例缓冲起来.同时,静态工厂方法可以为重复的调用返回同一个对象,这也可以被用来控制"在某一时刻哪些实例应该存在."   好处1:使得一个类可以保证是一个singleton.  好处2:使非可变类可以保证"不会有两个相等的实例存在",即当且仅当a==b时才有a.equals(b)为true.这可以提高性能.

3. 与构造函数不同,它们可以返回一个原返回类型的子类型的对象.特别是,能够返回实现类对于调用者隐藏的对象.这项技术非常适合于基于接口的框架结构,因为这样的框架结构中,接口成为静态工厂方法的自然返回类型.调用者只能通过接口来引用被返回的对象,而不能通过实现类来引用被返回的对象.

静态工厂方法的命名包括getInstance和valueOf,但这并不是强制要求的,只要具有明确的意义即可.

示例:
public class ComplexNumber {

  /**
  * Static factory method returns an object of this class.
  */
  public static ComplexNumber valueOf(float aReal, float aImaginary) {
    return new ComplexNumber(aReal, aImaginary);
  }

  //private constructor prevents subclassing
  private ComplexNumber (float aReal, float aImaginary) {
    fReal = aReal;
    fImaginary = aImaginary;
  }

  private float fReal;
  private float fImaginary;
}

JDK2中的示例:

LogManager.getLogManager
public static LogManager getLogManager() {
        if (manager != null) {
            manager.readPrimordialConfiguration();
        }
    return manager;
}

Pattern.compile
public static Pattern compile(String regex) {
        return new Pattern(regex, 0);
}

Collections.unmodifiableCollection, Collections.synchronizeCollection等等
public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {
    return new UnmodifiableCollection<T>(c);
}
    public static <T> Collection<T> synchronizedCollection(Collection<T> c) {
    return new SynchronizedCollection<T>(c);
}

Calendar.getInstance
public static Calendar getInstance(){
        Calendar cal = createCalendar(TimeZone.getDefaultRef(), Locale.getDefault());
    cal.sharedZone = true;
    return cal;
}

与reflection一起作用:

对象实例可以由user input,config file,或者任意来源决定.
完全支持在runtime时决定需要的对象实例.

public class Creator {

    // #1: basic static factory method
    protected static Hello createHelloer() {
        return new HelloWorld();
    }

    // #2: parameted static factory method
    protected final static int WORLD = 1;

    protected final static int CAMEL = 2;

    protected static Hello createHelloer(int id) {
        if (id == 1) {
            return new HelloWorld();
        }
        if (id == 2) {
            return new HelloCamel();
        }
        return null;
    }

    // #3: use reflection
    protected static Hello createHelloer(String name) {
        try {
            Class c = Class.forName(name);
            return (Hello) c.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) {
        /*
         * no factory method, usual codes
         */
        HelloWorld hw = new HelloWorld();
        hw.sayHello();
        HelloCamel hc = new HelloCamel();
        hc.sayHello();
        System.out.println("===========================");
       
        /*
         * basic factory method
         *
         * for different requirement, you can new different subclass and
         * override createHelloer() to get dedicated implemented class
         */
        Hello h = createHelloer();
        h.sayHello();
        System.out.println("===========================");
       
        /*
         * parameted factory method
         */
        h = createHelloer(WORLD);
        h.sayHello();
        h = createHelloer(CAMEL);
        h.sayHello();
        /*
         * parameted factory method by reflection
         */
        System.out.println("===========================");
        h = createHelloer("HelloWorld");
        h.sayHello();
        h = createHelloer("HelloCamel");
        h.sayHello();
    }
}

interface Hello {
    void sayHello();
}

class HelloWorld implements Hello {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

class HelloCamel implements Hello {
    public void sayHello() {
        System.out.println("Hello, Camel");
    }
}