KLam's Tech life

Software Design Patterns - Creational Patterns

Deals with object creation mechanisms

• Singleton
• Builder
• Prototype
• Factory
• Abstract Factory

Singleton Pattern

A class of which only a single instance can exist
Application needs one, and only one, instance of an object.

Applicable when

• Ownership of the single instance cannot be reasonably assigned
• Lazy initialization is desirable
• Global access is not otherwise provided for

Basic version

public final class singleton{
    private static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

Lazy initialization version(Thread-Safe)

• Pros: Initialised on first call to avoid memory wastage.

• Cons: locks must be added to ensure thread safety, and adding locks will affect performance.

public class Singleton {  
    private static Singleton instance = null;  
    private Singleton() {  

    }    

    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
          }  
        return instance;  
    }  
}

Initialiation-on-demand Holder Idiom

public class  Singleton {
    private Singleton() {}
    
    private static class LazyHolder {
        static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }

}

Builder Pattern

Complex objects can be created directly without the user knowing the construction process and details of the object.
Solves the Telescoping Problem.

CSDN Bloger「Carson_Ho」

Main parts of GoF’s Builder Pattern

1. Product object

public class Computer{
    
    //电脑组件的集合
    private List<String> parts = new ArrayList<String>()；
     
    //用于将组件组装到电脑里
    public void Add(String part){
    parts.add(part);
}
    
    public void Show(){
          for (int i = 0;i<parts.size();i++){    
          System.out.println(“组件”+parts.get(i)+“装好了”);
          }
          System.out.println(“电脑组装完成，请验收”);
          
 
}
}

2. A Builder(interface or abstract class)

public  abstract class Builder {  

//第一步：装CPU
//声明为抽象方法，具体由子类实现 
    public abstract void  BuildCPU()；

//第二步：装主板
//声明为抽象方法，具体由子类实现 
    public abstract void BuildMainboard（）；

//第三步：装硬盘
//声明为抽象方法，具体由子类实现 
    public abstract void BuildHD（）；

//返回产品的方法：获得组装好的电脑
    public abstract Computer GetComputer（）；
}

3. Concrete Builder(extend the Builder)

//装机人员1
  public class ConcreteBuilder extend  Builder{
    //创建产品实例
    Computer computer = new Computer();

    //组装产品
    @Override
    public void  BuildCPU(){  
       computer.Add("组装CPU")
    }  

    @Override
    public void  BuildMainboard（）{  
       computer.Add("组装主板")
    }  

    @Override
    public void  BuildHD（）{  
       computer.Add("组装主板")
    }  

    //返回组装成功的电脑
     @Override
      public  Computer GetComputer（）{  
      return computer
    }  
}

4. Director object

public class Director{
    //指挥装机人员组装电脑
     public void Construct(Builder builder){
                                
    builder.BuildCPU();
    builder.BuildMainboard（）;
    builder.BuildHD（）;
            }
 }

Prototype Pattern

Creating duplicate object while keeping performance in mind. The operation will directly clone a object in the ram. RAM’s I/O is much faster than storage.

1. Creator
2. Prototype
3. ConcretePrototype

Factory Pattern

In the factory pattern, we create objects without exposing the creation logic to the public and by using a common interface to point to the newly created object.

There’re two type of Factory Pattern

1. Simple Factory
   • Simple Factory create products(object)

public interface Dog{
    public void speak();
};
public class Poodle implements Dog {
    public void speak(){System.out.println("Poodle says \"arf\"")};
}
public class Rottweiler implements Dog {
    public void speak(){System.out.println("Poodle says \"arf\"")};
}

public class DogFactory{
    public static Dog getDog(String criteria) {
        switch (criteria.toLowerCase()){
            case "small": return new Poodle();
            case "big": return new Rottweiler();
            ...
            default: throw new RuntimeException("Unsupported dog type: " + criteria);
        }
    }
}

public class TestFactory {
    public static void main(String[] args) {
        //create a small dog
        Dog dog = Dogfactory.getDog("small";);
        dog.speak();
        
        ...
    }
}

3. Abstract Factory Pattern
   • Abstract Factory create Factory

…write later…