抽象工厂模式，加工出不可思议的产品！

大家好，我是洪爵，今天又是设计模式的一天！

​ 之前我们有谈论过工厂模式，那么抽象工厂模式又是什么呢？其实可以简单的概括：工厂模式，是工厂加工出对应的产品；而抽象工厂模式是专门生产工厂的，每个工厂又可以制造自己的产品（有点俄罗斯套娃）。

​ 抽象工厂模式是属于创建型的模式，创建型模式即提供一种最佳的创建对象方式。

​ 抽象工厂模式其实和工厂模式有点类似，我把文章都贴出来了。大家可以对照着看下，我理解大家理解了工厂模式，那么抽象工厂模式其实就是一个模子刻出来的东西。

类图：

我们创建出一个AbstractFactory类，做抽象工厂，每一个工厂都需要去实现这个抽象工厂类，生产这个共产的是FactoryProducer类，根据你的需求返回对应的工厂，每个工厂能生产自己的产品族，这些产品族又是具体实现某一个interface。

上代码：

// AbstractFactory.java
public abstract class AbstractFactory {
    public abstract Computer getComputer(String computer);
    public abstract Phone getPhone(String phone);
}

// ComputerFactory.java
public class ComputerFactory extends AbstractFactory {
    public Computer getComputer(String computer) {
        if(null == computer) {
            return null;
        }

        if("LENOVE".equalsIgnoreCase(computer)) {
            return new LENOVE();
        } else if("ASUS".equalsIgnoreCase(computer)) {
            return new ASUS();
        }

        return null;
    }

    public Phone getPhone(String phone) {
        return null;
    }
}

// PhoneFactory.java
public class PhoneFactory extends AbstractFactory {
    public Computer getComputer(String computer) {
        return null;
    }

    public Phone getPhone(String phone) {
        if(null == phone) {
            return null;
        }

        if("HUAWEI".equalsIgnoreCase(phone)) {
            return new HUAWEI();
        } else if("ZTE".equalsIgnoreCase(phone)) {
            return new ZTE();
        }

        return null;
    }
}

// FactoryProducer.java
public class FactoryProducer {
    public static AbstractFactory getFactory(String factory) {
        if("PHONE".equalsIgnoreCase(factory)) {
            return new PhoneFactory();
        } else if("COMPUTER".equalsIgnoreCase(factory)) {
            return new ComputerFactory();
        }
        return null;
    }
}

// Phone.java
public interface Phone {
    void printPhoneName();
}

//ZTE.java
public class ZTE implements Phone {
    public void printPhoneName() {
        System.out.println("中兴手机");
    }
}

// HUAWEI.java
public class HUAWEI implements Phone {
    public void printPhoneName() {
        System.out.println("华为手机");
    }
}

// Computer.java
public interface Computer {
    void printComputerName();
}

// ASUS.java
public class ASUS implements Computer {
    public void printComputerName() {
        System.out.println("华硕电脑");
    }
}

// LENOVE.java
public class LENOVE implements Computer {
    public void printComputerName() {
        System.out.println("联想电脑");
    }
}

//Client.java
public class Client {
    public static void main(String[] args) {
        // 获取手机工厂
        AbstractFactory phoneFactory = FactoryProducer.getFactory("PHONE");

        // 手机工厂生产对应品牌手机
        Phone huawei = phoneFactory.getPhone("HUAWEI");
        huawei.printPhoneName();
        Phone zte = phoneFactory.getPhone("ZTE");
        zte.printPhoneName();

        // 获取电脑工厂
        AbstractFactory computerFactory = FactoryProducer.getFactory("COMPUTER");

        // 电脑工厂生产对应品牌电脑
        Computer lenove = computerFactory.getComputer("LENOVE");
        lenove.printComputerName();
        Computer asus = computerFactory.getComputer("ASUS");
        asus.printComputerName();
    }
}
/*
华为手机
中兴手机
联想电脑
华硕电脑
*/

本章节有关于抽象工厂模式的内容就到这里啦！希望对你有帮助哦~

愿每个人都能带着怀疑的态度去阅读文章并探究其中原理。

道阻且长，往事作序，来日为章。

期待我们下一次相遇！

标签：return,不可思议,工厂,Phone,Computer,抽象,java,public
来源： https://blog.csdn.net/KnightHONG/article/details/119296656