工廠：故名思議，就是用來制造各種產品的，在程序中主要是用來創建對象。
- 首先介紹下簡單工廠（也稱靜態工廠）
class Car{
public void run(){
System.out.println("小車正在跑。。");
}
}
public class SampleFactoryTest {
public static void main(String[] args) {
//調用者創建一個Car
Car car = new Car();
//調用者調用run方法
car.run();
}
}
通過以上代碼，你有沒有發現一個問題。就是調用者（main方法）在調用小車的run()之前還需要創建一個Car對象，就好比你想要開車，你會不會自己先做一輛車然后再去開？我想你不會的。所以為了讓調用者和創建者分離，工廠設計模式應允而生。
class Car{
public void run(){
System.out.println("小車正在跑。。");
}
}
/**
* 汽車工廠
*
*/
class CarFactory{
//加上static方便調用，也稱靜態工廠
public static Car createCar(){
return new Car();
}
}
public class SampleFactoryTest {
public static void main(String[] args) {
//通過工廠創建一個Car
Car car = CarFactory.createCar();
//調用者調用run方法
car.run();
}
}
實際應用當然不止才一個類型的車，下面是一個詳細的例子：
interface Car{
public void run();
}
class Benz implements Car{
@Override
public void run() {
System.out.println("奔馳在跑...");
}
}
class Bmw implements Car{
@Override
public void run() {
System.out.println("寶馬在跑...");
}
}
/**
* 汽車工廠
*
*/
class CarFactory{
/**
* 簡單工廠一般加上static方便訪問
* 通過不同類型獲得不同的車
* @param type 類型
* @return 車
*/
public static Car createCar(String type){
Car car = null;
if(type.equals("benz")){
car = new Benz();
} else if(type.equals("bmw")){
car = new Bmw();
}
return car;
}
}
/**
* 也可以為每一種汽車寫一個單獨的方法
*/
class CarFactory2{
/**
* 簡單工廠一般加上static方便訪問
* 通過不同類型獲得不同的車
* @param type 類型
* @return 車
*/
public static Car createBenz(){
return new Benz();
}
public static Car createBmw(){
return new Bmw();
}
}
public class SampleFactoryTest {
public static void main(String[] args) {
//通過工廠創建一個Benz
//Car benz = CarFactory.createCar("benz");
//Car bmw = CarFactory.createCar("bmw");
Car benz = CarFactory2.createBenz();
Car bmw = CarFactory2.createBmw();
//調用者調用run方法
benz.run();
bmw.run();
}
}
到這里一個簡單工廠的實現已經完成，但是現在會有一個新的問題，當你要新增Car的時候，勢必要去修改工廠方法來適應新的需求，這樣便破壞了Open-closed Principle，下面是修改后的：
interface Car{
public void run();
}
class Benz implements Car{
@Override
public void run() {
System.out.println("奔馳在跑...");
}
}
class Bmw implements Car{
@Override
public void run() {
System.out.println("寶馬在跑...");
}
}
/**
* 將工廠抽象為接口
*
*/
interface CarFactory{
Car createCar();
}
/**
* 奔馳工廠
*
*/
class BenzFactory implements CarFactory{
@Override
public Car createCar() {
return new Benz();
}
}
/**
* 寶馬工廠
*
*/
class BmwFactory implements CarFactory{
@Override
public Car createCar() {
return new Bmw();
}
}
public class SampleFactoryTest {
public static void main(String[] args) {
//通過工廠創建對象
Car benz = new BenzFactory().createCar();
Car bmw = new BmwFactory().createCar();
//調用者調用run方法
benz.run();
bmw.run();
}
}
以上就是工廠方法模式，和簡單工廠略有不同，通過抽象工廠為接口解決了OCP，現在的這個工廠變得更好擴展了，但其實這種寫法復雜了很多，還是看你怎么取舍了吧。
