Factory Pattern

Factory Pattern

Abstract Factory-Provide an interface for creating families of related or dependent objects without specifying their concrete class.

Factory Method-Define an interface for creating an object but let subclass decide which class to instantiate. Factory Method lets a class defer instantiation to the subclass.

Problem:

Duck duck;

if(picni)
    duck =new MallardDuck();
else if(hunting)
    duck = new DecoyDuck();
else
    duck = new RubberDuck(); 

 

Solution:take the creation code and move it out into another object that is only going to be concerned with creating parts.

Example:

//code

import java.lang.String;
abstract class CPU ...{

    int cache;
    int Frequency;
    int Voltage;
    String CPUName;
    public void DisplayCPUCapability()
    ...{
        System.out.println("CPU name is:"+CPUName);
        System.out.println("cache:"+cache+";Frequency:"+Frequency+";Voltage:"+Voltage);
        
    }
}
class AMD extends CPU
...{
    public AMD(int cache,int Frequency,int Voltage)
    ...{
        this.cache=cache;
        this.Frequency=Frequency;
        this.Voltage = Voltage;
        this.CPUName = "AMD";
    }
}
class Intel extends CPU
...{
    public Intel(int cache,int Frequency,int Voltage)
    ...{
        this.cache=cache;
        this.Frequency=Frequency;
        this.Voltage = Voltage;
        this.CPUName = "Intel";
    }
}
abstract class Memory
...{
    int Capacity;
    int Frequency;
    int type;
    String Name;
    public void DisplayMemoryParam()
    ...{
        System.out.println("Memory name is:"+Name);
        System.out.println("Capacity:"+Capacity+";Frequency:"+Frequency+";Type:"+type);
        
    }
}
class Kingston extends Memory
...{
    public Kingston(int cache,int Frequency,int Voltage)
    ...{
        this.Capacity=cache;
        this.Frequency=Frequency;
        this.type = Voltage;
        this.Name = "Kingston";
    }
}
class ADATA extends Memory
...{
    public ADATA(int cache,int Frequency,int Voltage)
    ...{
        this.Capacity=cache;
        this.Frequency=Frequency;
        this.type = Voltage;
        this.Name = "ADATA";
    }
}
abstract class Mainboard
...{
    int BusFrequency;
    String Name;
    public void DisplayMainboard()
    ...{
        System.out.println("Mainboard name is:"+Name);
        System.out.println("Bus frequency is:"+BusFrequency);
    
    }
}
class JingYingMainboard extends Mainboard
...{
    public JingYingMainboard(int BusFrequency)
    ...{
        this.BusFrequency = BusFrequency;
        this.Name = "JingYingMainboard";
    }
}

 

public interface TraditionHouse ...{
    public CPU CreateCPU();
    public Memory CreateMemory();
    public Mainboard CreateMainboard();

}
class QuanZhouHouse implements TraditionHouse
...{
    public CPU CreateCPU()
    ...{
        return new Intel(13,14,15);
    }
    public Memory CreateMemory()
    ...{
        return new Kingston(3,4,5);
    }
    public Mainboard CreateMainboard()
    ...{
        return new JingYingMainboard(111);
    }
}
class NanJingHouse implements TraditionHouse
...{
    public CPU CreateCPU()
    ...{
        return new AMD(15,14,15);
    }
    public Memory CreateMemory()
    ...{
        return new ADATA(13,4,5);
    }
    public Mainboard CreateMainboard()
    ...{
        return new JingYingMainboard(121);
    }
}

 

public class Computer ...{
    CPU cpu;
    Mainboard mainboard;
    Memory memory;
    TraditionHouse tranHouse;
    public void SetFactory(TraditionHouse tran)
    ...{
        tranHouse=tran;
    }
    public void prepareComputer()
    ...{
        cpu=tranHouse.CreateCPU();
        mainboard=tranHouse.CreateMainboard();
        memory=tranHouse.CreateMemory();
        
        DisplayComputerParam();
    }
    private void DisplayComputerParam()
    ...{
        cpu.DisplayCPUCapability();
        mainboard.DisplayMainboard();
        memory.DisplayMemoryParam();
    }
}

 

public class Main ...{

    /** *//**
     * @param args
     */
    public static void main(String[] args) ...{
        // TODO Auto-generated method stub
        //declare two computer factory
        TraditionHouse tran1=new QuanZhouHouse();
        TraditionHouse tran2=new NanJingHouse();
        //declare computers in setup
        Computer computer1=new Computer();
        Computer computer2=new Computer();
        //select Computer factory which user select 
        computer1.SetFactory(tran1);
        computer2.SetFactory(tran2);
        
        //setup and display results
        computer1.prepareComputer();
        computer2.prepareComputer();
        
    }

}

//if u find sth interesting,pls contact me. qq:95491590

When u see code like this, u know that when it comes time for changes or extensions, u will have to reopen this code and examine what needs to be added( or deleted). Often this kind of code ends up in several parts of the application making maintenance and  update more difficult and error-prone. So, in other words, when u have code that makes use of lots of concrete classes, u are looking for trouble because that code may have to be changed as new concrete classes are added.