class ProgramConfiguration{
    public ProgramConfiguraiton(){
        //default constructor code
    }
}

class ProgramConfiguration{
    private ProgramConfiguration(){
        //default private constructor code
    }
}

class ProgramConfiguration{
    private static ProgramConfiguration _configObject;
    private ProgramConfiguration(){
        //default private constructor code
    }
    public getInstance(){
        /*
        if an instance exist return that instance otherwise
        call the constructor to create an instance and return it.
        */
        if(_configObject == null){
            _configObject = ProgramConfiguration();
        }
    return _configObject;
    }
}

public static void main(String[] args){
    /*
    no access to default constructor. so if you did
    ProgramConfiguration pc = new ProgramConfiguration();
    you will get compilation error.
    */
    ProgramConfiguration pc = ProgramConfiguration.getInstance();
    ProgramConfiguration newpc = ProgramConfiguration.getInstance();
    /*
    in the above code pc and newpc both point to the same static object. when
    getinstance() is called for the second time, it finds that _configObject is not null
    anymore, so it doesn't call the constructor to create any new instance.
    */
}

1. When working on a large software, numerous instances of classes are created continuously at the runtime. The programmer cannot predict what the user is going to do. So at any given time, the programmer doesn’t know what object is create. For example, To create a new document, the user might click new text document or new spreadsheet document. There would several possibilities about what the user is going to do. So, a factory class is assigned to do all these repetitive work of creating a new instance of what the user wants. By separating these repetitive object creations into a factory class, when new classes are added, only the factory class need to be updated.
2. To create object without knowing its class name. When using the concrete classes, the developer has to remember the class names. In factory pattern, choosing what type of object to be created is delegated to the factory class. Usually this is done by sending a parameter. Based on the parameter passed to the factory, the factory creates an instance of a certain type/class.

public final class DocumentFactory {
   XDocument document;
   XDocument getDocument(String type){
      if(type.equals("text"){
         document = new TextDocument();
      }
      else if(type.equals("sheet"){
         document = new SpreadSheet();
      }
   return document;
   }
}

public interface XDocument{
   open();
}

public class TextDocument implements XDocument{
   //concrete class for Text documents
   open(){
      //method to open text document
      System.out.println("opening a text document...");
   }
}

public class SpreadSheet implements XDocument{
   //concrete class for spreadsheet documents
   open(){
      //method to open spreadsheet document
      System.out.println("opening a spreadsheet document...");
   }
}

class DocumentProgram{
   public static void main(String[] args){
   //this just created an instance of TextDocument without knowing its class name.
   XDocument doc = df.getDocument("text");
   doc.open();
   }
}