Java 设计模式 — 抽象工厂模式(2)

心已赠人 2024-04-03 07:14 53阅读 0赞

## 一、谈谈抽象工厂模式 ##

**抽象工厂模式是关于一个超级工厂创建其他工厂，这个超级工厂又被称为其它工厂的工厂。显然，这种设计模式属于创建型模式，它同时也提供了创建对象的最佳方式。**

说到这里，可能就会有人有疑惑，那么这与工厂模式有什么区别呢？我们先来看看抽象工厂模式到底是什么再去进行比对~

## 二、测试代码 ##

**抽象工厂模式的逻辑图**

![a4ffe6fea3b347dd9a17927e7503c0c1.png][]

**创建测试代码的 Package 图**

![0c2ec9d337bc425ea2a3165f77ae7f5c.png][]

**1. 创建一个 Interface Package，里面创建两个接口，一个是 Car，一个是 Phone**

public interface Car {
        void bookCar();
    }

public interface Phone {
        void bookPhone();
    }

**2. 创建两个 Package，一个是 Car Package，一个是 Phone Package**

**<1> Phone Package中创建三个类，继承 Phone 接口，并实现接口中定义的方法**

public class HuaWei implements Phone {
        @Override
        public void bookPhone() {
            System.out.println("Book a Huawei Phone.");
        }
    }

public class XiaoMi implements Phone {
        @Override
        public void bookPhone() {
            System.out.println("Book a XiaoMi Phone.");
        }
    }

public class Apple implements Phone {
        @Override
        public void bookPhone() {
            System.out.println("Book a Apple Phone.");
        }
    }

**<2> Car Package中创建三个类，继承 Car 接口，并实现接口中定义的方法**

public class RedFlag implements Car {
        @Override
        public void bookCar() {
            System.out.println("Book a RedFlag Car.");
        }
    }

public class BiYa implements Car {
        @Override
        public void bookCar() {
            System.out.println("Book a BiYa Car.");
        }
    }

public class Gwm implements Car {
        @Override
        public void bookCar() {
            System.out.println("Book a Gwm Car.");
        }
    }

**<3> 创建抽象类来获取 Car 和 Phone 工厂**

public abstract class AbstractFactory {
        public abstract Car getCar(String car);
        public abstract Phone getPhone(String phone);
    }

**<4> 创建一个 Factory Package，其中 CarFactory 和 PhoneFactory 分别继承抽象类，并实现其中的方法，对于 CarFactory 来说就是创建自己的 Car 的实例对象，对于 PhoneFactory 来说就是创建自己的 Phone 的实例对象。对于 ProductFactory 说，那么就是用来生产 CarFactory 和 PhoneFactory ，也就是实例化这两个工厂的工厂。**

public class CarFactory extends AbstractFactory {
        @Override
        public Car getCar(String car) {
            switch (car) {
                case "BiYa":
                    return new BiYa();
                case "Gwm":
                    return new Gwm();
                case "RedFlag":
                    return new RedFlag();
                default:
                    return null;
            }
        }
    
        @Override
        public Phone getPhone(String phone) {
            return null;
        }
    }

public class PhoneFactory extends AbstractFactory {
        @Override
        public Car getCar(String car) {
            return null;
        }
    
        @Override
        public Phone getPhone(String phone) {
            switch (phone) {
                case "HuaWei":
                    return new HuaWei();
                case "XiaoMi":
                    return new XiaoMi();
                case "Apple":
                    return new Apple();
                default:
                    return null;
            }
        }
    }

public class ProductFactory {
        public static AbstractFactory getFactory(String product) {
            switch (product) {
                case "CarFactory":
                    return new CarFactory();
                case "PhoneFactory":
                    return new PhoneFactory();
                default:
                    return null;
            }
        }
    }

**<5> 编写测试类**

public class Test {
        public static void main(String[] args) {
            // 生产工厂的工厂实例化手机工厂
            AbstractFactory phoneFactory = ProductFactory.getFactory("PhoneFactory");
    
            // HuaWei
            Phone huaWei = Objects.requireNonNull(phoneFactory).getPhone("HuaWei");
            huaWei.bookPhone();
    
            // XiaoMi
            Phone xiaoMi = phoneFactory.getPhone("XiaoMi");
            xiaoMi.bookPhone();
    
            // Apple
            Phone apple = phoneFactory.getPhone("Apple");
            apple.bookPhone();
    
            System.out.println("<====================>");
            
            // 生产工厂的工厂加工汽车工厂
            AbstractFactory carFactory = ProductFactory.getFactory("CarFactory");
            
            // BiYa
            Car biYa = Objects.requireNonNull(carFactory).getCar("BiYa");
            biYa.bookCar();
    
            // Gwm
            Car gwm = carFactory.getCar("Gwm");
            gwm.bookCar();
    
            // RedFlag
            Car redFlag = carFactory.getCar("RedFlag");
            redFlag.bookCar();
    
        }
    }

**6. 运行结果**

Book a Huawei Phone.
    Book a XiaoMi Phone.
    Book a Apple Phone.
    <====================>
    Book a BiYa Car.
    Book a Gwm Car.
    Book a RedFlag Car.

相信，写到这里，我们可能大概对这两种设计模式的区别心里已经有了答案，**我们在这里总结一下这两种设计模式的区别和联系：**

**1、工厂模式是生产单个同种类型的不同产品。**

**2、抽象工厂模式是生产不同类型的多种不同产品。在抽象工厂模式种，存在一个产品族的概念，是指不同产品在结构中功能相关联的产品组成的家族，同一产品族的不同产品由同一工厂生产，不同的工厂，生产的方式( 方法 )不同，如下图所示~**

![d16a8d55fd1043ffb0ea7ba3b672945e.png][]

**3、抽象工厂模式是对工厂模式的进一步封装，工厂模式下，只有一个抽象的产品类，对于抽象工厂模式，存在多个工厂，也就存在着多种抽象的产品类。**

[a4ffe6fea3b347dd9a17927e7503c0c1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/4e2863d2d43e404e944c050fd4a14fc7.png
[0c2ec9d337bc425ea2a3165f77ae7f5c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/76a9ed131f604fa8a77b0ea92fc7ccbd.png
[d16a8d55fd1043ffb0ea7ba3b672945e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/9a0e8edf5faf437289c699cf6c78ab0a.png