设计模式之工厂模式

    工厂模式分为三类：

        1.简单工厂模式

        2.工厂方法模式

        3.抽象工厂模式

    这三种模式从上到下逐步抽象

1. 简单工厂模式

    简单工厂模式其实逻辑很简单，其核心思想就是根据传入的参数返回不同的对象，对象的创建过程由自定义的一个类去完成，也就是所说的工厂，这里以水果为例

    先定义一个水果类通用接口

public interface Fruit {
    //水果种类
    void category();
}

    水果实现接口

public class Apple implements Fruit {
    @Override
    public void category() {
        System.out.println("苹果");
    }
}

public class Banana implements Fruit {
    @Override
    public void category() {
        System.out.println("香蕉");
    }
}

public class Peach implements Fruit{
    @Override
    public void category() {
        System.out.println("桃子");
    }
}

    工厂类

public class FruitFactory {
    public static Fruit productFruit(String fruit) throws Exception {
        if (fruit.equalsIgnoreCase("apple")) {
            return new Apple();
        } else if (fruit.equalsIgnoreCase("banana")) {
            return new Banana();
        } else if (fruit.equalsIgnoreCase("peach")) {
            return new Peach();
        } else
            throw new Exception();
    }
}

    简单工厂模式就是这么简单，相信大家一定也发现了很多问题，这种模式下想要扩展是很不容易的，需要改动工厂类的代码，为了避免这种情况工厂方法模式应运而生了

2. 工厂方法模式

    简单工厂模式与工厂方法模式最大的区别在于简单工厂模式只有一个工厂，需要什么就传递对应的参数去取，而工厂方法模式是对不同的对象有特定的工厂，这些工厂实现了总工厂的接口，所以在总工厂中调用就可以获取到相应的产品

    先将水果工厂改造为接口

public interface FruitFactory {
    Fruit getFruit();
}

    创建Apple工厂用来生产apple，需要实现水果工厂类

public class AppleFactory implements FruitFactory {
    @Override
    public Fruit getFruit() {
        return new Apple();
    }
}

    同样的方式创建其他水果工厂

public class BananaFactory implements FruitFactory {
    @Override
    public Fruit getFruit() {
        return new Banana();
    }
}

    然后需要哪种水果直接在水果总装厂调用

public class EatFruit {
    public static void main(String[] args) {
        FruitFactory fruitFactory = new AppleFactory();
        fruitFactory .getFruit();   //苹果

        FruitFactory fruitFactory = new BananaFactory();
        fruitFactory .getFruit();  //香蕉
    }
}

    工厂方法模式在简单工厂模式上进行了一些扩展，可以适用于更多的场景，并且在后续需要添加其他子产品时只需要建立工厂去实现总工厂即可，相比简单工厂模式的扩展性要好很多

3. 抽象工厂模式

    抽象工厂模式在工厂方法模式上又进行了进一步的扩展，将同系列产品再次创建到同一个工厂，假如现在除了水果之外我们再生产一个水果汁的产品

    水果汁类的接口

public interface Juice {
    void category();
}

    苹果和香蕉都能生产水果汁，所以去实现这个水果汁接口

public class AppleJuice implements Juice {
    @Override
    public void category() {
        System.out.println("苹果汁");
    }
}

public class BananaJuice implements Juice {
    @Override
    public void category() {
        System.out.println("香蕉汁");
    }
}

    接下来创建一个生产水果渍的工厂接口

public interface JuiceFactory {
    Juice getJuice();
}

    因为我们的产品线的扩充，以前的水果装配厂已经不能满足需求了，我们除了要在建立一个生产水果汁的工厂之外，还需要由一个水果总装厂进行调度，例如给总装厂苹果就可以按需求生产苹果和苹果汁

public interface FinalFactory {
    Fruit getFruit();
    Juice getJuice();
}

    改造原来的水果厂的生产线，使其可以生产同类型的两种产品

public class AppleFactory implements FinalFactory {
    @Override
    public Fruit getFruit() {
        return new Apple();
    }

    @Override
    public Juice getJuice() {
        return new AppleJuice();
    }
}

public class BananaFactory implements FinalFactory {
    @Override
    public Fruit getFruit() {
        return new Banana();
    }

    @Override
    public Juice getJuice() {
        return new BananaJuice();
    }
}

    最后调用工厂方法

public class Eat {
    public static void main(String[] args) {
        // 苹果工厂生产
        AppleFactory appleFactory = new AppleFactory();
        appleFactory.getFruit();      //苹果
        appleFactory.getJuice();    //苹果汁
        // 香蕉工厂生产
        BananaFactory bananaFactory = new BananaFactory();
        bananaFactory.getFruit();     //香蕉
        bananaFactory.getJuice();   //香蕉汁
    }
}