【设计模式】抽象工厂模式——003

抽象工厂模式

简介

定义

• 抽象工厂模式是一种创建类模式，相比较于工厂模式，抽象工厂模式将工厂抽象为一个抽象类，各个工厂继承于这个抽象类，通过创建一个超级工厂，这个超级工厂能创建其他工厂。
• 在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

好处

1. 在一个工厂里聚合多个同类产品。
2. 当需要将一个产品族中的多个对象设计成一起工作时，通过一个工厂能保证只使用同一个产品族中的对象。

缺点

不便于扩展，同工厂模式缺点类似。

实例

创建一个超级工厂，该工厂能得到手机工厂和电脑工厂，通过手机工厂可以得到不同品牌的手机，电脑工厂类似。

创建手机接口与电脑接口

手机接口有call方法，电脑接口有display方法。

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

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

创建实现接口的实体类

创建HuawiePhone和OppoPhone的实体类实现手机接口

//HuaweiPhone.java
public class HuaweiPhone implements Phone {

    @Override
    public void call() {
        System.out.println("This is Huawei Phone");
    }
}

//OppoPhone.java
public class OppoPhone implements Phone {

    @Override
    public void call() {
        System.out.println("This is Oppo Phone");
    }
}

创建HuawieComputer和DellComputer的实体类实现电脑接口

//HuaweiComputer.java
public class HuaweiComputer implements Computer {

    @Override
    public void display() {
        System.out.println("This is Huawei Computer");
    }
}

//DellComputer.java
public class DellComputer implements Computer{

    @Override
    public void display() {
        System.out.println("This is Dell Computer");
    }
}

创建抽象的工厂类

为 Phone 和 Computer 对象创建抽象类来各自获取对应的工厂。

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

创建扩展了抽象工厂类的工厂类

通过给定信息的生成基于给定信息的实体类的对象，如给“huawei”则返回一个“HuaweiPhone”对象。

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

    @Override
    public Phone getPhone(String phone) {
        if(phone==null){
            return null;
        }
        if (phone.equalsIgnoreCase("huawei")){
            return new HuaweiPhone();
        }else if (phone.equalsIgnoreCase("oppo")){
            return new OppoPhone();
        }
        return null;
    }
}

//ComputerFactory.java
public class ComputerFactory extends AbstractFactory {
    @Override
    public Computer getComputer(String computer) {
        if(computer==null){
            return null;
        }
        if (computer.equalsIgnoreCase("huawei")){
            return new HuaweiComputer();
        }else if (computer.equalsIgnoreCase("dell")){
            return new DellComputer();
        }
        return null;
    }

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

创建一个工厂创造器类

通过传递手机或者电脑信息来获取工厂。

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

使用该工厂

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory phoneFactory=FactoryProducer.getFactory("Phone");
        AbstractFactory computerFactory=FactoryProducer.getFactory("Computer");

        Phone phone1=phoneFactory.getPhone("huawei");
        phone1.call();
        Phone phone2=phoneFactory.getPhone("oppo");
        phone2.call();

        Computer computer1=computerFactory.getComputer("Dell");
        computer1.display();
        Computer computer2=computerFactory.getComputer("huawei");
        computer2.display();

    }
}

运行结果

总结

抽象工厂模式是工厂模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

关注博主，一起来学习设计模式吧