What are static factory methods

Question

What s a  static factory  method

User · Answer

I thought i will add some light to this post on what i know. We used this technique extensively in our recent android project. Instead of creating objects using new operator you can also use static method to instantiate a class. Code listing:

//instantiating a class using constructor
Vinoth vin = new Vinoth(); 

//instantiating the class using static method
Class Vinoth{
  private Vinoth(){
  }
  // factory method to instantiate the class
  public static Vinoth getInstance(){
    if(someCondition)
        return new Vinoth();
  }
}

Static methods support conditional object creation: Each time you invoke a constructor an object will get created but you might not want that. suppose you want to check some condition only then you want to create a new object.You would not be creating a new instance of Vinoth each time, unless your condition is satisfied.

Another example taken from Effective Java.

public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
}

This method translates a boolean primitive value into a Boolean object reference. The Boolean.valueOf(boolean) method illustrates us, it never creates an object. The ability of static factory methods to return the same object from repeated invocations allows classes to maintain strict control over what instances exist at any time.

Static factory methods is that, unlike constructors, they can return an object of any subtype of their return type. One application of this flexibility is that an API can return objects without making their classes public. Hiding implementation classes in this fashion leads to a very compact API.

Calendar.getInstance() is a great example for the above, It creates depending on the locale a BuddhistCalendar, JapaneseImperialCalendar or by default one Georgian.

Another example which i could think is Singleton pattern, where you make your constructors private create an own getInstance method where you make sure, that there is always just one instance available.

public class Singleton{
    //initailzed during class loading
    private static final Singleton INSTANCE = new Singleton();

    //to prevent creating another instance of Singleton
    private Singleton(){}

    public static Singleton getSingleton(){
        return INSTANCE;
    }
}

User · Answer

A static factory method is good when you want to ensure that only one single instance is going to return the concrete class to be used   For example  in a database connection class  you may want to have only one class create the database connection  so that if you decide to switch from Mysql to Oracle you can just change the logic in one class  and the rest of the application will use the new connection   If you want to implement database pooling  then that would also be done without affecting the rest of the application   It protects the rest of the application from changes that you may make to the factory  which is the purpose   The reason for it to be static is if you want to keep track of some limited resource  number of socket connections or file handles  then this class can keep track of how many have been passed out and returned  so you don t exhaust the limited resource

User · Answer

static   A member declared with the keyword  static       factory methods   Methods that create and return new objects      in Java   The programming language is relevant to the meaning of  static  but not to the definition of  factory

User · Answer

A factory method a method that abstracts away the instantiation of an object   Generally factories are useful when you know that you need a new instance of a class that implements some interface but you don t know the implementing class   This is useful when working with hierarchies of related classes  a good example of this would be a GUI toolkit   You could simply hard-code calls to the constructors for concrete implementations of each widget but if you ever wanted to swap one toolkit for another you d have a lot of places to change   By using a factory you reduce the amount of code you would need to change

User · Answer

Java implementation contains utilities classes java util Arrays and java util Collections both of them contains static factory methods  examples of it and how to use     Arrays asList  1   2   3   Collections synchronizedList      Collections emptyList    Collections unmodifiableList        Only some examples  could check javadocs for mor methods examples https   docs oracle com javase 8 docs api java util Collections html    Also java lang String class have such static factory methods    String format       String valueOf      String copyValueOf

User · Answer

We avoid providing direct access to database connections because they re resource intensive  So we use a static factory method getDbConnection that creates a connection if we re below the limit   Otherwise  it tries to provide a  spare  connection  failing with an exception if there are none   public class DbConnection     private static final int MAX CONNS   100     private static int totalConnections   0      private static Set lt DbConnection gt  availableConnections   new HashSet lt DbConnection gt         private DbConnection                     totalConnections             public static DbConnection getDbConnection          if totalConnections  lt  MAX CONNS          return new DbConnection           else if availableConnections size    gt  0            DbConnection dbc   availableConnections iterator   next             availableConnections remove dbc            return dbc         else            throw new NoDbConnections                    public static void returnDbConnection DbConnection dbc        availableConnections add dbc

User · Answer

One of the advantages that stems from Static factory is that that API can return objects without making their classes public  This lead to very compact API  In java this is achieved by Collections class which hides around 32 classes which makes it collection API very compact

User · Answer

The static factory method pattern is a way to encapsulate object creation   Without a factory method  you would simply call the class s constructor directly  Foo x   new Foo     With this pattern  you would instead call the factory method   Foo x   Foo create     The constructors are marked private  so they cannot be called except from inside the class  and the factory method is marked as static so that it can be called without first having an object   There are a few advantages to this pattern   One is that the factory can choose from many subclasses  or implementers of an interface  and return that   This way the caller can specify the behavior desired via parameters  without having to know or understand a potentially complex class hierarchy   Another advantage is  as Matthew and James have pointed out  controlling access to a limited resource such as connections   This a way to implement pools of reusable objects - instead of building  using  and tearing down an object  if the construction and destruction are expensive processes it might make more sense to build them once and recycle them   The factory method can return an existing  unused instantiated object if it has one  or construct one if the object count is below some lower threshold  or throw an exception or return null if it s above the upper threshold   As per the article on Wikipedia  multiple factory methods also allow different interpretations of similar argument types   Normally the constructor has the same name as the class  which means that you can only have one constructor with a given signature   Factories are not so constrained  which means you can have two different methods that accept the same argument types    Coordinate c   Coordinate createFromCartesian double x  double y    and   Coordinate c   Coordinate createFromPolar double distance  double angle    This can also be used to improve readability  as Rasmus notes

User · Answer

have names  unlike constructors  which can clarify code    do not need to create a new object upon each invocation - objects   can be cached  and reused  if necessary    can return a subtype of their return type - in particular  can   return an object  whose implementation class is unknown to the caller    This is a very valuable and widely used feature in many frameworks   which use interfaces as the return type of static factory methods       fromhttp   www javapractices com topic TopicAction do Id 21

User · Answer

Readability can be improved by static factory methods   Compare  public class Foo    public Foo boolean withBar                              What exactly does this mean  Foo foo   new Foo true      You have to lookup the documentation to be sure     Even if you remember that the boolean has something to do with a Bar    you might not remember whether it specified withBar or withoutBar    to  public class Foo    public static Foo createWithBar                     public static Foo createWithoutBar                                This is much easier to read  Foo foo   Foo createWithBar

User · Answer

If the constructor of a class is private then you cannot create an object for class from outside of it    class Test   int x  y   private Test                                We cannot create an object for above class from outside of it  So you cannot access x  y from outside of the class  Then what is the use of this class   Here is the Answer   FACTORY method  Add the below method in above class    public static Test getObject      return new Test        So now you can create an object for this class from outside of it  Like the way     Test t   Test getObject      Hence  a static method which returns the object of the class by executing its private constructor  is called as FACTORY method

User · Answer

NOTE   The static factory method is NOT the same as the Factory Method pattern   c  Effective Java  Joshua Bloch   Factory Method   Define an interface for creating an object  but let the classes which implement the interface decide which class to instantiate  The Factory method lets a class defer instantiation to subclasses   c  GoF    Static factory method is simply a static method that returns an instance of a class    c  Effective Java  Joshua Bloch  Usually this method is inside a particular class   The difference   The key idea of static factory method is to gain control over object creation and delegate it from constructor to static method  The decision of object to be created is like in Abstract Factory made outside the method  in common case  but not always   While the key     idea of Factory Method is to delegate decision of what instance of class to create inside Factory Method  E g  classic Singleton implementation is a special case of static factory method   Example of commonly used static factory methods    valueOf   getInstance   newInstance

User · Answer

It all boils down to maintainability   The best way to put this is whenever you use the new keyword to create an object  you re coupling the code that you re writing to an implementation   The factory pattern lets you separate how you create an object from what you do with the object   When you create all of your objects using constructors  you are essentially hard-wiring the code that uses the object to that implementation   The code that uses your object is  dependent on  that object   This may not seem like a big deal on the surface  but when the object changes  think of changing the signature of the constructor  or subclassing the object  you have to go back and rewire things everywhere   Today factories have largely been brushed aside in favor of using Dependency Injection because they require a lot of boiler-plate code that turns out to be a little hard to maintain itself   Dependency Injection is basically equivalent to factories but allows you to specify how your objects get wired together declaratively  through configuration or annotations

User · Answer

One of the advantages of the static factory methods with private constructor object creation must have been restricted for external classes to ensure instances are not created externally  is that you can create instance-controlled classes  And instance-controlled classes guarantee that no two equal distinct instances exist a equals b  if and only if a  b  during your program is running that means you can check equality of objects with    operator instead of equals method  according to Effective java      The ability of static factory methods to return the same object from   repeated invocations allows classes to maintain strict control over   what instances exist at any time  Classes that do this are said to be   instance-controlled  There are several reasons to write   instance-controlled classes  Instance control allows a class to   guarantee that it is a singleton  Item 3  or noninstantiable  Item 4     Also  it allows an immutable class  Item 15  to make the guarantee   that no two equal instances exist  a equals b  if and only if a  b  If   a class makes this guarantee  then its clients can use the    operator   instead of the equals Object  method  which may result in improved   performance  Enum types  Item 30  provide this guarantee    From Effective Java  Joshua Bloch Item 1 page 6

[java] What are static factory methods?

Examples related to java

Examples related to design-patterns

Examples related to factory-method