java设计模式：三个工厂模式对比

java设计模式：三个工厂模式对比

简单工厂模式

实现一个基础工厂类，根据这个工厂类的不同入参，匹配到不同的具体产品类。代码如下

public class AnimalFactory {
    public Animal getAnimal(String name)
    {
        switch(name.toLowerCase())
        {
            case "cow":
                return new Cow();
            case "horse":
                return new Horse();
            case "dog":
                return new Dog();
        }
        return null;
    }

        public static void main(String args[])
        {
            AnimalFactory f = new AnimalFactory();
            Animal c =  f.getAnimal("cow");
            Animal h =  f.getAnimal("horse");
            Dog d = (Dog)f.getAnimal("dog");
            c.eat();
            h.eat();
            d.eat();

#### 特点：
1. 新增一个产品需要的步骤
* 增加一个具体产品类继承抽象产品类
* 产品工厂类需要新增加一个case，来匹配新增的产品

好处：客户端在引用的时候，不需要改动，只需要知道新增产品的name就可以

1. 具体产品新增一个业务的步骤（改动有点麻烦）：
   
   • 如果不改变抽象类或者接口的情况下：1.在具体实现类加上新方法，客户端实现需要把抽象对象强制转换为具体对象类
   • 改动抽象类或接口：1.所有继承该类或接口的具体实现类都要加上这个方法，违背初衷

工厂方法模式

写一个工厂抽象类或接口，在由具体的业务工厂去继承，
业务变动直接在业务工厂里修改，分散了父类接口的压力。
代码如下：

public interface AnimalFactory1 {
    public Animal getAnimal();
}

public class DogFactory implements AnimalFactory1{
    @Override
    public Dog getAnimal() {
        return new Dog();
    }
}

public static void main(String[] args) {
   DogFactory dogFactory = new DogFactory();
   Dog d = dogFactory.getAnimal();
   d.eat();
}

#### 特点：
1. 新增一个产品需要的步骤
* 增加一个具体产品类继承抽象产品类
* 增加一个具体工厂类继承抽象工厂类
* 客户端引用：实例化新工厂类，然后调用对应的方法

1. 具体产品新增一个业务的步骤（简单）：

   • 直接在对应产品实现类下 增加新业务方法即可

2. 增加一个别的类型的工厂：比如Color

   • 实现Color抽象类，以及下面具体的压颜色类
   • 增加一个ColorFactory，然后在DogFactory里继承ColorFactory这个接口，
     反正接口可以继承多个
   • 然后在通过DogFactory去分别实现两个产品的get就可以了

3. 如果是直接实例化业务工厂类的话，为什么不直接实例化产品类？

   • 解耦，客户端只需要关注工厂的方法的结果，不用关心后面的业务实现，
     可以保障在业务更新的时候，不影响适用方的改动

抽象工厂模式

个人理解，抽象工厂和工厂方法模式差不多，这里就写一下两个模式的对比。
抽象工厂是为了解决一个对象存在多个属性工厂的情况。

下面我就以Pet为例子，Pet有不同的种类，包括dog，cat等，Pet还有不同的颜色，包括黑，白，灰。

---

1. 工厂方法模式

public interface PetFactory {
    public Pet getAnimal();
}
public interface ColorFactory {
    public Color getColor();
}

public class DogFactory implements PetFactory,ColorFactory{
    @Override
    public Dog getAnimal() {
        return new Dog();
    }
    @Override
    public Color getColor() {
        return new Red();
    }
}

public class MainApp {
    public static void main(String[] args) {
        DogFactory dogFactory = new DogFactory();
        Dog d = dogFactory.getAnimal();
        d.eat();
        Color color = dogFactory.getColor();
        color.color();
    }
}

1. 抽象工厂模式

public interface AbstractFactory {
    public Pet getPet();
    public Color getColor();
}

public class DogFactory implements AbstractFactory {
    @Override
    public Pet getPet() {
        return new Dog();
    }
    @Override
    public Color getColor() {
        return new Red();
    }
}

public class MainApp {
    public static void main(String[] args) {
        DogFactory dogFactory = new DogFactory();
        Dog d = dogFactory.getPet();
        d.eat();
        Color c = dogFactory.getColor();
        c.color();
    }
}

区别应该很明显，工厂方法是业务实现工厂继承多个抽象工厂，每个抽象工厂里生产一类对象。

而抽象工厂方法是一个总的抽象工厂，然后有多个抽象方法，一个方法对应一类对象，然后业务实现工厂去实现这些方法。

• 举的例子不知道对不对，是不是工厂方法模式继承两个抽象类就是抽象工厂模式了？感觉两个模式差不多~

---

新手上路，还望多多指正！感谢阅读