设计模式之工厂模式(Factory)

设计模式之工厂模式

简介

工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建，是一种创建型模式。

任何可以产生对象或者方法的类 ，都可以称之为工厂

单例也是工厂，可以把他当做静态工厂

为什么有了new 之后，还要有工厂

1. 可以灵活控制生产过程
2. 权限，修饰，日志。

代码准备

需求一

任意订制交通工具，例如汽车，飞机，扫把

1. 新建父类接口

public interface Moveable {
    void go();
}

2. 新建汽车,飞机,扫把类

public class Car implements  Moveable {

    @Override
    public void go() {
        System.out.println("Car is going ....");
    }
}

public class Plane implements Moveable {
    @Override
    public void go() {
        System.out.println("plane is flying....");
    }
}

public class Broom implements Moveable{

    @Override
    public void go() {
        System.out.println(" broom is jumping.....");
    }
}

3. 新建Main类, 调用以上方法

public class Main {
    public static void main(String[] args) {
        //这里应用到了java的多态, 面向接口开发,同一个接口，使用不同的实例而执行不同操作
        Moveable m = new Car();
        m.go();
    }
}

需求二

任意订制不同交通工具的生成过程, 接下来开始简单工厂

简单工厂

新建一个SimpleVehicleFactory用来生产各种交通工具

public class SimpleVehicleFactory {

    public Car createCar() {
        return new Car();
    }

    public Plane createPlane() {
        return new Plane();
    }

    public Broom createBroom() {
        return new Broom();
    }
}

但是这种方式扩展性不够好，每次新添加交通工具时，都要在里面新加一个方法。

main 方法

public class Main {
    public static void main(String[] args) {
       SimpleVehicleFactory f = new SimpleVehicleFactory();
       Car car = f.createCar();
       car.go;
    }
}

工厂方法

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂

新建一个汽车生产工厂

public class CarFactory {
    public Moveable create() {
        System.out.println("a car created!");
        return new Car();
    }
}

main方法

public class Main {
    public static void main(String[] args) {
        Moveable m = new CarFactory().create();
        m.go();
    }
}

此时, 完成了需求一和需求二

通过实现Moveable接口, 完成任意订制交通工具

通过扩展具体工厂, 完成任意订制不同交通工具的生成过程

抽象工厂

抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干。

场景描述: 一老炮，边开车边吃东西边开枪

新建一个Car,Ak47,Bread,Main

public class Car{
    public void go() {
        System.out.println("Car is going ....");
    }
}

public class AK47{
    public void shoot() {
        System.out.println("tututututu....");
    }
}

public class Bread {
    public void printName() {
        System.out.println("wdm");
    }
}

public class Main {
    public static void main(String[] args) {
        //一老炮，边开车边吃东西边开枪
        Car m = new Car();
        m.go();
        AK47 ak47 = new AK47();
        ak47.shoot();
        Bread bread = new Bread();
        bread.printName();
    }
}

需求三

任意订制产品一族

例如, 交通工具不止有汽车, 还有轮船, 武器有魔法棒, 食物有蘑菇…

1. 新建一个抽象工厂，该工厂可以生产所有产品

/**
 * 抽象工厂,可以生产各种产品
 */
public abstract class AbstractFactory {

}

2. 新建一个Food抽象类, 可以生产所有食物

public abstract class Food {
   abstract void printName();
}

新建一个Vehicle, 可以生产所有的交通工具

public abstract class Vehicle {
    abstract void go();
}

新建一个Weapon, 可以生产所有的武器

public abstract class Weapon {
    abstract void shoot();
}

2. 改造抽象工厂

public abstract class AbstractFactory {

    abstract Food createFood();
    abstract Vehicle createVehicle();
    abstract Weapon createWeapon();
}

3. 让Car继承Vehicle, AK47继承Weapon, Bread继承Food

public class Car extends Vehicle{

    @Override
    public void go() {
        System.out.println("Car is going ....");
    }
}

public class AK47 extends Weapon {
    @Override
    public void shoot() {
        System.out.println("tututututu....");
    }
}

public class Bread extends Food{
    @Override
    public void printName() {
        System.out.println("wdm");
    }
}

4 新建食物 MushRoom继承Food, 新建交通工具-轮船Broom继承Vehicle, 新建魔法棒MagicStick继承Weapon类,

public class MushRoom extends Food{
    @Override
    public void printName() {
        System.out.println("dmg");
    }
}

public class Broom extends Vehicle{
    public void go() {
        System.out.println("Car go wuwuwuwuw....");
    }
}

public class MagicStick extends Weapon{
    @Override
    public void shoot() {
        System.out.println("diandian....");
    }
}

5. 新建现代工厂生产现代产品

public class ModernFactory extends AbstractFactory {
    @Override
    Food createFood() {
        return new Bread();
    }

    @Override
    Vehicle createVehicle() {
        return new Car();
    }

    @Override
    Weapon createWeapon() {
        return new AK47();
    }
}

6. 新建魔法工厂用来生产魔法产品

public class MagicFactory extends AbstractFactory {
    @Override
    Food createFood() {
        return new MushRoom();
    }

    @Override
    Vehicle createVehicle() {
        return new Broom();
    }

    @Override
    Weapon createWeapon() {
        return new MagicStick();
    }
}

7. 此时main方法可以这样写

public class Main {
    public static void main(String[] args) {
//        //一老炮，边开车边吃东西边开枪
//        Car m = new Car();
//        m.go();
//        AK47 ak47 = new AK47();
//        ak47.shoot();
//        Bread bread = new Bread();
//        bread.printName();
        AbstractFactory a = new ModernFactory();
        Food food = a.createFood();
        food.printName();
        Vehicle vehicle = a.createVehicle();
        vehicle.go();
        Weapon weapon = a.createWeapon();
        weapon.shoot();
    }

输出结果

wdm
Car is going ....
tututututu....

总结

​ 上面介绍的三种工厂模式有各自的应用场景，实际应用时能解决问题满足需求即可，可灵活变通 。重点是掌握其中的设计思想，切勿为了设计而设计，以免像老太太裹脚布，又臭又长。