设计模式-工厂模式

Author Avatar
晓晓Sama 3月 24, 2018

简单工厂模式

使用简单工厂模式的优势

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

下面实例

小张开车去东北

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

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();
    }
}

下图是类图之间的关系

类图之间的关系.png

此时如要换一种方式去东北,只需要按照上图给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 ...");
    }

}

下面是类图关系

类图关系.png

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