静态工厂方法的问题！

Question

in this site it says that a new object isnt being created each time , which leads to efficiency, but by what i can see an object is being created each time in the static method..

do not need to create a new object upon each invocation - objects can be cached and reused, if necessary.

http://www.javapractices.com/topic/TopicAction.do?Id=21

so why are the static factory methods are so efficient?

isnt writing something like this : Object obj=new Object is same as if i did Object obj=Someclass.GetObj();

class Someclass
{
   public static Object GetObj()
   {
     return new Object
   }
}

There is caching, but a new object is created either way...

Answer 1

Objects can be cached and reused. They aren't always. There are a number of other advantages, like:

• better naming of the method
• returning subclasses

There is an item in Effective Java for that, so go ahead and read it. The book is a must-read anyway.

Update: as I said, object can be cached. But it depends on the implementation. The one you show does not cache them. The one shown by Peter caches them. You have that option. With a constructor - you don't.

Answer 2

When you use new Object() , a new Object has to be created.

If you use a static factory, it can optionally create a new object, or it can reuse an existing one.

A simple example is using Integer.valueOf(int) instead of new Integer(int) . The static factory has a cache of small integers and can save to the creation of a significant portion of integers. For some use cases this can be all the integers used. The later case will always create a new object which is relatively inefficient.

Answer 3

They are more flexible - for example if the input parameters for new object are not valid, you can return null or some null object implementation (=instance, which does nothing, but will not break your code by NullPointerException), or, as previously mentioned by others, you can cache created instances. There is another benefit from using factory methods over constructors - you can name them whatever you like, which can be more readable, if there are multiple constructors with lots of optional parameters.

EDIT: if you want to use only one instance, you can use this simple factory:

class Someclass{
  private static Object o=new Object();

  public static Object getObj(){
    return o;
  }
}

Answer 4

The link you presented provides very different explanation of a Factory Pattern. Generally factory pattern is used to obtain instances of classes whcih implement same interface but provide different behavior for the same contract. It allows us to choose different implementation at run time. Check out the example here:

http://www.allapplabs.com/java_design_patterns/factory_pattern.htm

Factory pattern is not generally used for caching objects. Singleton pattern is defined to ensure only one instance of the object is created.

Answer 5

The idea is that you use them as a strategy. If later you want to implement caching, you just change that method and add it in there. Compare this with having "new Bla()" scattered all over the code, and trying to implement caching for the Bla class.

Since the method is static, and usually just a few lines of code, it means it can be resolved at compile time, and even inlined.

Thus there is no advantage of using "new Bla()" instead of factory methods at all.

Answer 6

Using factory in some situations you could make your code more flexible, faster and also better readable.

For example, imagine, you have to write class which download some data from url

public class WavAudio {
      private byte[] raw;
      private static HashMap<String,WavAudio> cache;
      private WavAudio(byte[] raw){
          this.raw=raw;
      }
      public static loadFromUrl(String someUrl){
          //If data has been loaded previously we don't have to do this more (faster..)
          if (cache.containsKey(someUrl))
               return cache.get(someUrl);
          //Else we'll load data (that would take some time)
          InputStream ires=(new URL(someUrl)).openStream();    
          ByteArrayOutputStream baos=new ByteArrayOutputStream();
          byte[] raw = new byte[4096];          
          int nBytesRead;
          while ((nBytesRead = ires.read(raw, 0, raw.length))>0)
          baos.write(raw, 0, raw); 
          byte[] downloaded=baos.toByteArray();
          WavAudio curr=new WavAudio(raw);
          cache.put(someUrl,raw);
          return raw;
      }      

      public static void main(String[] args){
          WavAudio wav=WavAudio.loadFromUrl("http://someUrl_1");
          SomePlayer.play(wav); //the first melody is playing
          WavAudio wav=WavAudio.loadFromUrl("http://someUrl_2");
          SomePlayer.play(wav); //the second melody is playing
          //won't be downloaded twice
          WavAudio wav=WavAudio.loadFromUrl("http://someUrl_1");
          SomePlayer.play(wav);
      }
}