设计模式-工厂模式 | 呦呵丶晓晓

简单工厂模式

使用简单工厂模式的优势

让对象的调用者和对象创建过程分离，当对象调用者需要对象时，直接向工厂请求即可。从而避免了对象的调用者与对象的实现类以硬编码方式耦合，以提高系统的可维护性，可扩展性。工厂模式也有一点缺陷：当产品修改时，工厂类也要做相应的修改。

下面实例

小张开车去东北

这里涉及到小张是乘坐什么交通工具去东北？汽车，飞机，火车…..都可以

Car类

public class Car implements Moveable{
    
    public void run() {
        System.out.println("冒着烟奔跑中car.......");
    }
}

Plane类

public class Plane implements Moveable {

    @Override
    public void run() {
        System.out.println("扇着翅膀前进中plane....");
    }

}

接口类Moveable

public interface Moveable {
    void run();
}

抽象类VehicleFactory

public abstract class VehicleFactory {
    abstract Moveable create();
}

CarFactory类

public class CarFactory extends VehicleFactory{
    public Moveable create() {
        return new Car();
    }
}

PlaneFactory类

public class PlaneFactory extends VehicleFactory{
    public Moveable create() {
        return new Plane();
    }
}

测试类

public class Test {
    public static void main(String[] args) {

        VehicleFactory factory = new CarFactory();
        Moveable m = factory.create();

        m.run();
    }
}

下图是类图之间的关系

此时如要换一种方式去东北，只需要按照上图给2个接口都添加实现即可。
由此我们可以想象，如果工厂中要产生大量的产品系列，那样的话，就需要各种添加大量的实现，容易造成工厂泛滥。

抽象工厂模式

定义及原因

因为使用简单工厂模式，使得客户端代码成功地与被调用对象的实现类分离，但却带来了另外一种耦合：客户端代码与不同的工厂类耦合，这依然是一个问题。
我们考虑在增加一个工厂类，该类不生产具体的Vehicle类，而是生产VehicleFactory实例——简而言之,该类不制造具体的被调用对象，而是制造不同的工厂对象。这就是抽象工厂模式。

如下实例

抽象工厂类：制造不同的工厂对象

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

MagicFactory类：创建系列与魔法有关的食物，交通工具，武器对象

public class MagicFactory extends AbstractFactory {

    @Override
    public Food createFood() {
        return new MushRoom();
    }

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

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

DefaultFactory类：创建默认类型的食物，交通工具，武器对象

public class DefaultFactory extends AbstractFactory{

    @Override
    public Food createFood() {
        return new Apple();
    }

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

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

Food类：生产Food

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

继承Food的两个类

Apple类

public class Apple extends Food {
    public void printName() {
        System.out.println("apple");
    }
}

MushRoom类

public class MushRoom extends Food {

    @Override
    public void printName() {
        System.out.println("mushroom");
    }

}

Vehicle类

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

继承Vehicle类的两个类

Car类

public class Car extends Vehicle {
        
    public void run() {
        System.out.println("冒着烟奔跑中car.......");
    }
}

Broom类

public class Broom  extends Vehicle{

    public void run() {
        System.out.println("一路沙尘暴飞奔而来broom.....");
    }

}

Weapon类

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

继承Weapon类的两个类

AK47类

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

MagicStick类

public class MagicStick extends Weapon {

    @Override
    public void shoot() {
        System.out.println("fire hu hu hu ...");
    }

}

下面是类图关系

可以用配置文件配置，具体用法原来已经讲过；
冒着烟奔跑中car…….
哒哒哒…
apple
在抽象工厂模式中，如要产生大量产品品种对象，容易泛滥。

本博客所有文章除特别声明外均采用CC BY-NC-SA 4.0许可。转载请注明来自https://newgr8player.com。
本文链接：https://newgr8player.com/2018/03/24/设计模式-工厂模式/