JAVA設計模式之工廠系列（factory）

任何能夠產生對象的方法或者類，均可以稱之爲工廠。單例就是所謂的靜態工廠。

爲何jdk中有了new，還須要工廠呢？

　　a、靈活的控制生產過程

　　b、給對象加修飾、或者給對象加訪問權限，或者可以在對象生產過程當中添加一些日誌信息，再或者根據應用場景添加一些實際的業務處理等等。

一、靜態工廠

     單例模式：一種特殊的靜態工廠，請參考單例模式

二、簡單工廠

/**
 * 可移動的物體抽象接口

*/ 
public interface Moveble { }

/**
 * 食品抽象類
 */
public abstract class Food{
}

/**
 * 麪包類
 */
public class bread extends Food {
    public Bike(){ System.out.println("T am bread"); } }

/**
 * bike類
 */
public class Bike implements Moveble{
    public Bike(){
        System.out.println("T am bike");
    }
}

/**
 * car類
 */
public class Car implements Moveble{
    public Car(){
        System.out.println("I am car");
    }
}

/**
 * 簡單工廠 只要是類均可以生產
 */
public class SimplerFactory {
    public Moveble createCar(){
        return new Car();
    }
    public Moveble createBike(){
        return new Bike();
    }

　　 public Food createBread(){
        return new Bread(); }

}

/**
 * 測試類
 */
public class T {
    public static void main(String[] args) {
        //生產car
        Moveble car = new SimplerFactory().createCar();
        //生產bike
        Moveble bike = new SimplerFactory().createBike();

　　　　 //生產bike
        Food bread = new SimplerFactory().createBread();

　　}
 }

三、工廠方法

/**
 * 可移動的物體抽象接口
 */
public abstract interface Moveble {
}

/**
 * 食品抽象類
 */
public abstract  class Food {
}

/**
 * bike類
 */
public class Bike implements Moveble{
    public Bike(){
        System.out.println("T am bike");
    }
}

/**
 * car類
 */
public class Car implements Moveble{
    public Car(){
        System.out.println("I am car");
    }
}

/**
 * bread類
 */
public class Bread extends Food{
    public Bread(){
        System.out.println("T am bread");
    }
}

/**
 * bike工廠
 */
public class BikeFactory {
    public Moveble create(){
        return new Bike();
    }
}

/**
 * car工廠
 */
public class CarFactory {
    public Moveble create(){
        return new Car();
    }
}


/**
 * bread工廠
 */
public class BreadFactory {
    public Food create(){
        return new Bread();
    }
}

/**
 * 測試類 ,工廠方法 一種類一個工廠
 */
public class T {
    public static void main(String[] args) {
        //生產car
        Moveble car = new BikeFactory().create();
        //生產bike
        Moveble bike = new CarFactory().create();
        //生產bread
        Food bread = new BreadFactory().create();
    }
}

四、抽象工廠

/**
 * 食品抽象類
 */
public abstract  class Food {
}

/**
 * 交通工具抽象類
 */
public abstract class Transportation {
}

/**
 *  電子設備抽象類
 */
public abstract class Electronic {
}

/**
 * bread類
 */
public class Bread extends Food {
    public Bread(){
        System.out.println("T am bread");
    }
}

/**
 * plane類
 */
public class Plane extends Transportation{
    public Plane(){
        System.out.println("I am plane");
    }
}

/**
 * phone類
 */
public class Phone extends Electronic{
    public Phone(){
        System.out.println("I am phone");
    }
}

/**
 * 具體的工廠 能夠生產一組類
 */
public class HaierFactory extends AbstractFactory{

    Food createFood() {
        return new Bread();
    }

    Electronic createElectronic() {
        return new Phone();
    }

    Transportation createTransportation() {
        return new Plane();
    }
}

/**
 * cake類
 */
public class Cake extends Food {
    public Cake(){
        System.out.println("T am cake");
    }
}

/**
 * Tank類
 */
public class Tank extends Transportation{
    public Tank(){
        System.out.println("I am tank");
    }
}

/**
 * Computer類
 */
public class Computer extends Electronic{
    public Computer(){
        System.out.println("T am pc");
    }
}

/**
 * 具體的工廠，能夠生產一組類
 */
public class SuningFactory extends AbstractFactory{
    Food createFood() {
        return new Cake();
    }
    Electronic createElectronic() {
        return new Computer();
    }
    Transportation createTransportation() {
        return new Tank();
    }
}

/**
 * 測試類，抽象工廠能夠生產一組類，而且能夠很靈活的擴展一組類的建立過程，可是不能作到靈活擴展一種類
 */
public class T {
    public static void main(String[] args) {
        //海爾工廠能夠生產麪包 飛機 手機
        AbstractFactory haierFactory = new HaierFactory();
        Food bread = haierFactory.createFood();
        Transportation plane = haierFactory.createTransportation();
        Electronic phone = haierFactory.createElectronic();
        //蘇寧工廠能夠生產 蛋糕 坦克 pc電腦
        AbstractFactory suningFactory = new SuningFactory();
        Food cate = haierFactory.createFood();
        Transportation tank = haierFactory.createTransportation();
        Electronic computer = haierFactory.createElectronic();
    }
}

五、Spring的bean工廠

      既能夠靈活控制一組類的建立過程也能夠靈活控制一種類的建立過程，具體請去閱讀Spring源碼中的BeanFactory。