设计模式-工厂设计模式

工厂方法（FactoryMethod）模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

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

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

灵活控制生产工程
权限、修饰、日志...

简单工厂

如下代码，创建一个生产交通工具的工厂，在return之前加入要操作的事情

缺点：可扩展性差

每次生产新的交通工具都必须重新添加

public class SimpleVehicleFactory {
    public Car createCar(){
        //before processing
        return new Car();
    }

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

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

静态工厂

单例也是一种工厂，可以称之为简单工厂

工厂方法--FactoryMethod

为某一类对象创建一个工厂，称为工厂方法

创建新的交通工具时，首先得创建生产它的工厂，再去实现使用的方法，实现了可以任意定制生产过程和交通工具。

从产品维度扩展很方便。

public class CarFactory {
    public Moveable create(){
        //模拟日志操作
        System.out.println("a car created!!!");
        return new Car();
    }
}

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

抽象工厂--AbstractFactory

产品族，不同的族系。

产品一族进行扩展。

为什么不使用interface而是用abstract

语义问题，形容词用接口(interface)，名字用抽象类(abstract)

代码示例

产品

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

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

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

产品功能

现代族

public class Bread extends Food {
    public void printName(){
        System.out.println("eat ksme bread...");
    }
}

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

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

魔法族

public class MushRoom extends Food {
    public void printName(){
        System.out.println("eat dumogu...");
    }
}

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

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

抽象工厂

public abstract class AbstractFactory {
    abstract Food createFood();
    abstract Vehicle createVehicle();
    abstract Weapon createWeapon();
}

产品族工厂

现代族

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

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

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

魔法族

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

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

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

测试类

public class Main {
    public static void main(String[] args) {
        
        //现代族
        AbstractFactory factory = new ModernFactory();

        Vehicle vehicle = factory.createVehicle();
        vehicle.go();

        Food food = factory.createFood();
        food.printName();

        Weapon weapon = factory.createWeapon();
        weapon.shoot();

        //魔法族
        AbstractFactory factory1 = new MagicFactory();

        Vehicle vehicle1 = factory1.createVehicle();
        vehicle1.go();

        Food food1 = factory1.createFood();
        food1.printName();

        Weapon weapon1 = factory1.createWeapon();
        weapon1.shoot();

    }
}

来源：oschina

链接：https://my.oschina.net/u/4555009/blog/4462864

标签

java

设计模式