JAVA设计模式之工厂模式

什么是工厂模式

工厂模式是我们最常用的实例化对象模式了
工厂模式用来创建对象

设计方法

1.简单工厂 - 算不上真正意义上的工厂模式
2.工厂方法
3.抽象工厂

简单工厂

由一个工厂类根据传入的参数决定创建哪一种的产品类

• 实例

class Pizza {void cut(){}}
class CheesePizza extends Pizza {}
class ClamPizza extends Pizza {}

class SimplePizzaFactory {
    public static Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("")) {
            pizza = new CheesePizza();
        } else if (type.equals("")) {
            pizza = new ClamPizza();
        }
        return pizza;
    }
}

class PizzaStore {
    public Pizza orderPizza(String type) {
        Pizza pizza = SimplePizzaFactory.createPizza(type);
        pizza.cut();
        return pizza;
    }
}

工厂方法模式

定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个
工厂方法让类把实例化推迟到子类

• 实例

public class Test {
    public static void main(String[] args) {
        Games.GameConsumer(new CheckersFactory());
        Games.GameConsumer(new ChessFactory());
    }
}

abstract class Game {
    abstract boolean move();
}

abstract class GameFactory {
    // getGame()就是工厂方法
    // 通过重写该方法来达到创建不同对象的目的
    abstract Game getGame();
}

class Checkers extends Game {
    @Override
    public boolean move() {
        System.out.println("Checkers move");
        return true;
    }
}

class Chess extends Game {
    @Override
    public boolean move() {
        System.out.println("Chess move");
        return true;
    }
}

class CheckersFactory extends GameFactory {
    @Override
    public Game getGame() {
        return new Checkers();
    }
}

class ChessFactory extends GameFactory {
    @Override
    public Game getGame() {
        return new Chess();
    }
}

// 不同类型的游戏都可以复用这段代码
class Games {
    public static void GameConsumer(GameFactory factory) {
        Game game = factory.getGame();
        game.move();
    }
}

• 类图

• 使用内部类来实现工厂方法模式

public class Test {
    public static void main(String[] args) {
        Games.GameConsumer(Checkers.mCheckersFactory);
        Games.GameConsumer(Chess.mChessFactory);
    }
}

abstract class Game {
    abstract boolean move();
}

abstract class GameFactory {
    // getGame()就是工厂方法
    // 通过重写该方法来达到创建不同对象的目的
    abstract Game getGame();
}

class Checkers extends Game {
    private Checkers() {}

    public static GameFactory mCheckersFactory = new GameFactory() {
        @Override
        public Game getGame() {
            return new Checkers();
        }
    };

    @Override
    public boolean move() {
        System.out.println("Checkers move");
        return true;
    }
}

class Chess extends Game {
    private Chess() {}

    public static GameFactory mChessFactory = new GameFactory() {
        @Override
        public Game getGame() {
            return new Chess();
        }
    };

    @Override
    public boolean move() {
        System.out.println("Chess move");
        return true;
    }
}

// 不同类型的游戏都可以复用这段代码
class Games {
    public static void GameConsumer(GameFactory factory) {
        Game game = factory.getGame();
        game.move();
    }
}

/**
输出如下: 
Checkers move
Chess move
*/

抽象工厂模式

提供一个接口，用于创建相关或依赖的家族，而不需要明确指定具体类

• 实例

汽车专卖店会销售很多品牌汽车，当用户买宝马时，会使用宝马的零件来组装宝马，当购买大众时，会选择大众零件来组装大众。每辆车需要的组件各不相同，但是都需要基本的组件，如轮胎，引擎，导航等，因此可以使用抽象工厂来创建这一系列的对象。

abstract class Wheel {}
abstract class Engine {}
abstract class Navigation {}

class GcWheel extends Wheel {}
class JkWheel extends Wheel {}

class GcEngine extends Engine {}
class JkEngine extends Engine {}

class BaiduNavigation extends Navigation {}
class GoogleNavigation extends Navigation {}

// ComponentFactory 就是抽象工厂
// 可以是抽象类，也可以是接口
// 抽象工厂可以创建一系列相关的对象
// 工厂方法创建的是一种对象
interface ComponentFactory {
    Wheel getWheel();
    Engine getEngine();
    Navigation getNavigation();
}

class BmwComponentFactory implements ComponentFactory {
    @Override
    public Wheel getWheel() {
        return new JkWheel();
    }

    @Override
    public Engine getEngine() {
        return new JkEngine();
    }

    @Override
    public Navigation getNavigation() {
        return new GoogleNavigation();
    }
}

class VwComponentFactory implements ComponentFactory {
    @Override
    public Wheel getWheel() {
        return new GcWheel();
    }

    @Override
    public Engine getEngine() {
        return new GcEngine();
    }

    @Override
    public Navigation getNavigation() {
        return new BaiduNavigation();
    }
}

abstract class Car {
    Wheel mWheel;
    Engine mEngine;
    Navigation mNavigation;
    ComponentFactory factory;

    Car(ComponentFactory factory) {
        this.factory = factory;
    }

    void fitting() {
        mWheel = factory.getWheel();
        mEngine = factory.getEngine();
        mNavigation = factory.getNavigation();
    }
}

class BMW extends Car {
    BMW(ComponentFactory factory) {
        super(factory);
    }
}

class VW extends Car {
    VW(ComponentFactory factory) {
        super(factory);
    }
}

class Store {
    public static Car Sale(String type) {
        Car car = null;
        if (type.equals("bmw")) {
            car = new BMW(new BmwComponentFactory());
        } else if (type.equals("vw")) {
            car = new VW(new VwComponentFactory());
        }
        return car;
    }
}

• 类图

小结

所有的工厂都是用来封装对象的创建

简单工厂，虽然不是真正的设计模式，但不失为一个简单的方法，可以将客户程序从具体类解偶

工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象

抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中

工厂方法创建一类对象，抽象工厂创建一系列相关对象

所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合

工厂方法允许类将实例化延迟到子类进行

抽象工厂创建相关的对象家族，而不需要依赖他们的具体类

工厂是很有威力的技巧，帮助我们针对抽象编程，而不要针对具体类编程