浅学Java设计模式之工厂模式

以简洁的整理下自己脑海里的工厂模式，写下来加深记录。

工厂模式可以分为三类：

1. 简单工厂模式（Simple Factory）
2. 工厂方法模式（Factory Method）
3. 抽象工厂模式（Abstract Factory）

简单工厂模式（又称静态工厂方法模式）

简单来说就是由一个工厂类中带参数静态方法来加以区分实现同一接口的不同类的实例。
举例说明：
一个地主有很多地，这些地可以种植不同的水果，比如苹果、梨、香蕉等，但他。

---

• 先定义一个可以种植水果的接口

public interface Fruit{
    void grow();
}

• 接着实现所有可以种植的水果都必须实现此接口

public void Apple implements Fruit{
    @Override 
    public void grow(){
        System.out.println("种植苹果");
    };
}
public void Pear implements Fruit{
    @Override 
    public void grow(){
        System.out.println("种植梨");
    };
}
public void Banana implements Fruit{
    @Override 
    public void grow(){
        System.out.println("种植香蕉");
    };
}

• 接着就是有要建立一个工厂类，用来区分种植啥水果

public class SimpleFactory {
    public static Fruit selected(String name){
        if(name.equals("apple")){
            return new Apple();
        }else if(name.equals("pear")){
            return new Pear();
        }else if(name.equals("banana")){
            return new Banana();
        }
    }
}

• 建好了工厂类，SimpleFactory将地主的口令来决定种植什么水果了

SimpleFactory.selected("apple").grow();
SimpleFactory.selected("pear").grow();
SimpleFactory.selected("banana").grow();

以上就是简单的工厂模式，其实简单工厂的核心大脑就是一个SimpleFactory类，这个类主要做了种植何种水果的逻辑处理，地主只需告诉这个类要种植水果的类型，他就为我们种植了何种水果。看起来很简单、也很好用，但就是这个的一个类存在很多局限， 比如地主想多一个水果类型来种植，那我们不得不修改这个核心大脑，这样就违背了开闭原则 （对扩展开放，对修改封闭），虽然可以利用反射解决该问题，但如果地主再对水果做了更多层次的划分，想必也知道，这个核心大脑就要不断修改、增加复杂的逻辑判断。万一哪一天修改这个类的时候，修改一个错误，会导致这个种植水果系统瘫痪了，这个结果是地主最不看到了，我们希望的最坏的结果是如果新增一种种植水果出现问题就这种水果不能种植，其他都可以正常运作，而不是殃及整个系统，这样会大大减少损失，也利于维护，说到这，其实已经引申到工厂方法模式了，工厂方法解决了以上简单工厂模式存在的问题。

工厂方法模式

• 我们根据简单工厂模式进行重构下
  还是一样先定义一个可以种植水果的接口。

public interface Fruit{
    void grow();
}

• 接着实现所有可以种植的水果都必须实现此接口

public void Apple implements Fruit{
    @Override 
    public void grow(){
        System.out.println("种植苹果");
    };
}
public void Pear implements Fruit{
    @Override 
    public void grow(){
        System.out.println("种植梨");
    };
}
public void Banana implements Fruit{
    @Override 
    public void grow(){
        System.out.println("种植香蕉");
    };
}

*这边多了一个工厂接口，为了把各自的种植职责从简单工厂的核心类抽离出来，由各自的工厂负责种植

public interface Factory{
    Fruit selected();
}

*实现各自水果的种植工厂类

public void AppleFactory implements Factory{
    @Override
    public Fruit selected(){
        return new Apple();
    }
}
public void PearFactory implements Factory{
    @Override 
    public Fruit selected(){
        return new Pear();
    }
}
public void BananaFactory implements Factory{
    @Override 
    public Fruit selected(){
        return new Banana();
    }
}

*最后地主就可以通过各自的工厂种植各自水果了

    Factory appleFactory = new AppleFactory();
    Fruit apple = appleFactory.selected();
    apple.grow();
    ...

工厂方法解决的简单工厂的困扰，使得各个水果种植互相不受影响，以后增加一种新水果，也只需要新增一个实现水果工厂接口工厂类，就能达到，不用修改已有的代码。但工厂方法也存在其他问题，比如种植水果，现在大家对品种都要求很高了，我们这时就需要细分到各个品种，现在可以种植青苹果、红苹果、米蕉、皇帝蕉等等，如果我们再细分下，我们对不同的水果肯定要进行不同的处理，施不同的化肥、喷不同的农药、有得需要嫁接有得不需要等等。这样就产生一系列水果的生产链。如果按工厂方法来完成整个庞大的水果系统，那我们新出一种品种或者新增加一个小小的生成环节，就需要新增一大堆的类出来，最后导致类爆炸，这样后期的维护工作就难以想象了，所以就有抽象工厂模式的出现，可以解决工厂方法的问题，但是工厂方法和抽象工厂各自适用不同的场合，没有好坏之分，归根看你用在什么地方，合不合适而已。

抽象工厂模式

*我们根据不同的水果定义不同水果分类接口以及不同品种的实现类

public interface Apple{
    Apple selected();
}
public class GreenApple implements Apple{
    @Override
    public Apple selected(){
        return new GreenApple();
    }
}
public class RedApple implements Apple{
    @Override
    public Apple selected(){
        return new RedApple();
    }
}
public interface Banana{
    Banana selected();
}
public class RiceBanana implements Banana{
    @Override
    public Banana selected(){
        return new RiceBanana();
    }
}
public class GoldBanana implements Banana{
    @Override
    public Banana selected(){
        return new GoldBanana();
    }
}

*接下来需要一个抽象工厂来安排每一季度这些地需要种植什么品种的水果，假设我们每一季度这些地都有种植苹果和香蕉，这样我们就可以根据这个来创建工厂类了以及工厂实现类

public interface Factory{
       Apple selectedApple();
       Banana selectedBanana();
}
public class FactoryA implements Factory{
        @Override
        public Apple selectedApple(){
             return new GreenApple();
        }
        @Override
        public Banana selectedBanana(){
             return new RiceBanana();
        }
}
public class FactoryB implements Factory{
        @Override
        public Apple selectedApple(){
             return new RedApple();
        }
        @Override
        public Banana selectedBanana(){
             return new GoldBanana();
        }
}
...

*最后地主就可以选择每一季度种植的水果品种了

    Factory factoryA = new FactoryA();
    Apple apple = factoryA.selectedApple();
    Banana banana = factoryA.selectedBanana();
    apple.selected();
    banana.selected();
    ...