Java设计模式-工厂模式

工厂模式

介绍

• 工厂模式中，创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
• 工厂模式可以分为三种方式（简单工厂模式，工厂方法模式，抽象工厂模式）
• 把对象的实例化部分抽取了出来，降低系统中代码耦合度，并且增强了系统的扩展性。

1.简单工厂模式

创建一个接口

public interface Moveable {
    public void go();
}

创建接口的实现类

public class Car implements Moveable{
    @Override
    public void go() {
        System.out.println("car ready go~");
    }
}

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

创建工厂，用来创建对象

public class VehicleSimpleFactory {
    public  Car createCar(){
        return new Car();
    }
    public  Plane createPlane(){
        return new Plane();
    }
}

测试

public class Main {
    public static void main(String[] args) {
        Moveable m = new VehicleSimpleFactory().createCar();
        m.go();
        Moveable m1 = new VehicleSimpleFactory().createPlane();
        m1.go();
    }
}

结论： 简单工厂模式的优点为对象的创建和对象的使用是分离的，把对象的创建交给专门的工厂类负责，但工厂类的灵活性不足，添加新产品时需要修改工厂类的代码，产品多时，工厂类代码会非常复杂。

2.工厂方法模式

定义抽象的核心工厂类，创建产品实例的工作交予工厂子类来完成，核心工厂类只负责工厂之类的接口定义，具体的产品对象创建交给具体工厂之类完成。这样系统新添一个产品时，只需要增加相应的产品类和工厂子类即可，无需修改系统代码，使系统符合开闭原则（ocp）。

创建一个产品类接口

public interface Moveable {
    public void go();
}

创建产品类接口的实现类

public class Car implements Moveable{
    @Override
    public void go() {
        System.out.println("car ready go~");
    }
}

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

创建抽象的核心工厂类

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

创建具体的工厂子类

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

public class PlaneFactory extends CreatVehicle{
    public Moveable create(){
        System.out.println("create a Plane!");
        return new Plane();
    }
}

测试

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

结论： 工厂方法模式是简单工厂模式的优化版，进一步抽象。工厂方法模式中，工厂类不负责产品对象的创建，将创建工作交给其之类完成，工厂类仅仅负责工厂子类所要实现的接口，不负责对象实例化这种细节。

3.抽象工厂模式

• 抽象工厂模式可以说是工厂方法模式的进一步扩展。工厂方法模式中一个工厂负责生产一种产品，为一对一的关系。但抽象工厂模式是一个工厂生产多种产品。
• 我们按人类的衣食住行为例来实现抽象工厂模式，这里为了方便只写住和行两个产品族。
  
  创建一个行类的产品类接口

public interface Moveable {
    public void go();
}

创建产品类接口的实现类

public class Car implements Moveable{
    @Override
    public void go() {
        System.out.println("car ready go~");
    }
}

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

创建一个住类的产品类接口

public interface Habitiable {
    public void live();
}

创建产品类接口的实现类

public class Vila implements Habitiable{
    public void live() {
        System.out.println("live in a vila");
    }
}

public class Apartment implements Habitiable{
    public void live() {
        System.out.println("live in an apartment");
    }
}

创建抽象工厂类为获取工厂创建产品族

public abstract class AbstractFactory {
    public abstract Moveable getVehicle(String type);
    public abstract Habitiable getHouse(String type);
}

继承抽象工厂类，实现生成产品族的对象

public class HouseFactory extends AbstractFactory{
    @Override
    public Moveable getVehicle(String type) {
        return null;
    }

    @Override
    public Habitiable getHouse(String type) {
        if(type == null){
            return null;
        }
        if(type.equalsIgnoreCase("vila")){
            return new Vila();
        } else if(type.equalsIgnoreCase("apartment")){
            return new Apartment();
        }
        return null;
    }
}

public class VehicleFactory extends AbstractFactory {
    @Override
    public Moveable getVehicle(String type) {
        if(type == null){
            return null;
        }
        if(type.equalsIgnoreCase("car")){
            return new Car();
        } else if(type.equalsIgnoreCase("plane")){
            return new Plane();
        }
        return null;
    }

    @Override
    public Habitiable getHouse(String type) {
        return null;
    }
}

创建抽象工厂类的对象生成器

public class FactoryProducer {
    public static AbstractFactory getVehicleFactory(){
        return new VehicleFactory();
    }
    public static AbstractFactory getHouseFactory(){
        return new HouseFactory();
    }
}

测试

public class Main {
    public static void main(String[] args) {
        AbstractFactory vehicleFactory = FactoryProducer.getVehicleFactory();
        Moveable moveable1 = vehicleFactory.getVehicle("car");
        moveable1.go();
        Moveable moveable2 = vehicleFactory.getVehicle("plane");
        moveable2.go();
        AbstractFactory houseFactory = FactoryProducer.getHouseFactory();
        Habitiable habitiable1 = houseFactory.getHouse("vila");
        habitiable1.live();
        Habitiable habitiable2 = houseFactory.getHouse("apartment");
        habitiable2.live();
    }
}

结论： 抽象工厂模式就是在一个产品族里定义多个产品。
将工厂抽象成两层，AbstractFactory(抽象工厂) 和 具体实现的工厂子类。根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

工厂模式小结

1. 工厂模式的意义：
   将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。
2. 三种工厂模式
   (简单工厂模式、工厂方法模式、抽象工厂模式)
3. 设计模式的依赖抽象原则
   创建对象实例时，不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中，并返回。
   不要让类继承具体类，而是继承抽象类或者是实现 interface(接口)。