设计模式学习工厂模式

一：简单工厂模式

1：使用简单工厂模式的优势

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

2：下面实例

• 小张开车去东北

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

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

3：下图是类图之间的关系

此时如要换一种方式去东北，只需要按照上图给2个接口都添加实现即可。

由此我们可以想象，如果工厂中要产生大量的产品系列，那样的话，就需要各种添加大量的实现，容易造成工厂泛滥。

二：抽象工厂模式

1：定义及原因：

因为使用简单工厂模式，使得客户端代码成功地与被调用对象的实现类分离，但却带来了另外一种耦合：客户端代码与不同的工厂类耦合，这依然是一个问题。

我们考虑在增加一个工厂类，该类不生产具体的Vehicle类，而是生产VehicleFactory实例------简而言之，该类不制造具体的被调用对象，而是制造不同的工厂对象。这就是抽象工厂模式。

2：如下实例：

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

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 ...");
    }

}

3：下面是类图关系

可以用配置文件配置，具体用法原来已经讲过；

冒着烟奔跑中car.......
哒哒哒...
apple

在抽象工厂模式中，如要产生大量产品品种对象，容易泛滥。