设计模式-工厂模式，抽象工厂模式

工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

 

为什么要使用工厂模式

1、一个调用者想创建一个对象，只要知道其名称就可以了，不需要知道实现类。

2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3、屏蔽产品的具体实现，调用者只关心产品的接口。

 

调用图

 

 

演示用例

1、有猫和狗两种动物，都需要做一件事：说话

2、抽象出动物接口，包含说话功能

3、编写Cat类、Dog类，实现动物接口（Animal）

4、编写动物工厂，可以根据客户端传递的动物名称，实例具体动物

5、调用者只需要调用接口即可，不需要关心实现类

 

代码清单

1、动物接口

public interface Animal {
    void say(String speak);
}

2、猫 实现动物接口

public class Cat implements Animal {
    @Override
    public void say(String speak) {
        System.out.println("猫说：" + speak);
    }
}

3、狗 实现动物接口

public class Dog implements Animal {
    @Override
    public void say(String speak) {
        System.out.println("狗说：" + speak);
    }
}

4、工厂 根据名字返回具体实例

public class AnimalFactory {
    public static Animal getAnimal(String animalType){
        switch (animalType){
            case "cat":
                return new Cat();
            case "dog":
                return new Dog();
            default:
                System.out.println("类型错误");
                return new Dog();
        }
    }
}

5、调用者

public static void main(String[] args) {
    Animal animal = AnimalFactory.getAnimal("cat");
    animal.say("你好");  // 输出 猫：你好
}

 

 

 

抽象工厂模式

 

工厂方法模式和抽象工厂模式不好分清楚，他们的区别如下：

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品。

 

调用图

 

演示用例

以动物为例，从大类上可分为哺乳类、爬行类、家禽类等。

1、有猫、狗、蛇、蜥蜴四种动物

2、抽象出哺乳类动物接口Mammal、爬行类动物接口Reptile

3、编写Cat、Dog、Lizard、Snake类，分别实现Mammal接口，Reptile接口

4、根据Mammal、Reptile两个接口，可以抽象出动物抽象工厂AnimalAbstractFactory

5、创建动物种类工厂MammalFactory、ReptileFactory，继承AnimalAbstractFactory，根据客户端传过来的名字返回具体实例

6、创建生产者，从动物抽象类AnimalAbstractFactory中选取动物种类工厂

7、调用者调用生产者，传递动物种类工厂名字，获取动物种类工厂。再从动物种类工厂中中获取指定动物实例

 

应用场景

QQ秀套餐替换/面试

 

代码清单

1、哺乳动物接口

public interface Mammal {
    void say(String speak);
}

2、爬行动物接口

public interface Reptile {
    void say(String speak);
}

3、猫 实现哺乳类动物接口

public class Cat implements Mammal {
    @Override
    public void say(String speak) {
        System.out.println("猫说：" + speak);
    }
}

4、狗 实现哺乳类动物接口

public class Dog implements Mammal {
    @Override
    public void say(String speak) {
        System.out.println("狗说：" + speak);
    }
}

5、蛇 实现爬行类动物接口

public class Snake implements Reptile {
    @Override
    public void say(String speak) {
        System.out.println("蛇说：" + speak);
    }
}

6、蜥蜴 实现爬行类动物接口

public class Lizard implements Reptile {
    @Override
    public void say(String speak) {
        System.out.println("蜥蜴说：" + speak);
    }
}

7、哺乳动物、爬行动物。两个接口可以再次进行抽象，抽象出抽象工厂

public abstract class AnimalAbstractFactory {
    public abstract Mammal getMammal(String mammal);
    public abstract Reptile getReptile(String reptile);
}

8、创建哺乳动物工厂、爬行动物工厂分别实现抽象工厂

public class MammalFactory extends AnimalAbstractFactory {
    @Override
    public Mammal getMammal(String mamal) {
        switch (mamal){
            case "cat":
                return new Cat();
            case "dog":
                return new Dog();
            default:
                return new Dog();
        }
    }

    @Override
    public Reptile getReptile(String reptile) {
        return null;
    }
}

public class ReptileFactory extends AnimalAbstractFactory {
    @Override
    public Mammal getMammal(String mamal) {
        return null;
    }

    @Override
    public Reptile getReptile(String reptile) {
        switch (reptile){
            case "lizard":
                return new Lizard();
            case "snake":
                return new Snake();
            default:
                return new Snake();
        }
    }
}

 

9、创建生产者，从抽象工厂中返回工厂实例

public class AnimalProducer {
    public static AnimalAbstractFactory getFactory(String type){
        switch (type){
            case "mammal":
                return new MammalFactory();
            case "reptile":
                return new ReptileFactory();
            default:
                return new ReptileFactory();
        }
    }
}

 

10、测试类

public class AbstractFactoryTest {
    public static void main(String[] args) {
        // 1、根据动物种类 从动物抽象工厂中 取动物种类工厂
        AnimalAbstractFactory animalAbstractFactory = AnimalProducer.getFactory("mammal");
        // 2、根据动物名字 从动物种类工厂中 获取指定动物
        Mammal mammal = animalAbstractFactory.getMammal("cat");
        // 3、执行方法
        mammal.say("你好"); // 猫说：你好

        animalAbstractFactory.getMammal("dog").say("你好"); // 狗说：你好

        AnimalAbstractFactory factory = AnimalProducer.getFactory("reptile");
        factory.getReptile("lizard").say("你好"); // 蜥蜴说：你好
        factory.getReptile("sanke").say("你好"); // 蛇说：你好
    }
}

 

 

源码git地址：https://gitee.com/11230595/gof

 

 

更多精彩内容，请关注公众号。

博客文章每周从公众号同步一次。