简单工厂，工厂方法与抽象工厂模式的实现

通过对简单工厂，工厂方法，抽象工厂模式的学习之后，三种模式的详细了解

---

使用Java对其进行了简单的实现。

简单工厂

手机基类

public abstract class AbstractPhone {
    public abstract void call();
}

手机产品类

public class Oppo extends AbstractPhone{
    @Override
    public void call() {
        System.out.println("Oppo 正在为你接通");
    }
}

手机工厂

public class PhoneFactory {
    public AbstractPhone crate(String phoneType){
        if ("oppo".equals(phoneType)){
            return new Oppo();
        }
        return null;
    }
}

生产手机，并调用其实例方法

public class SimpleFactory {
    public static void main(String[] args) {
        new PhoneFactory().crate("oppo").call();
    }
}

实现效果

Oppo 正在为你接通

---

工厂方法模式

抽象工厂类

public abstract class AbstractFactory {
    //生产
    public abstract AbstractProduct create();
}

抽象产品类

public abstract class AbstractProduct {
    //产品使用
    public abstract void use();
}

Car产品类

public class CarProduct extends AbstractProduct{
    @Override
    public void use() {
        System.out.println("奥迪A6生产完成");
    }
}

Car生产类

public class CarFactory extends AbstractFactory{
    @Override
    public AbstractProduct create() {
        return new CarProduct();
    }
}

Zoom产品类

public class ZoomProduct extends AbstractProduct{
    @Override
    public void use() {
        System.out.println("zoom 生产完成");
    }
}

Zoom工厂类

public class ZoomFactory extends AbstractFactory{
    @Override
    public AbstractProduct create() {
        return new ZoomProduct();
    }
}

生产代码

public class FactoryMethod {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        carFactory.create().use();

        ZoomFactory zoomFactory = new ZoomFactory();
        zoomFactory.create().use();
    }
}

实现效果

奥迪A6生产完成
zoom 生产完成

---

抽象工厂模式

创建手机，电脑与工厂枚举

public enum PhoneEnum {
    IPHONE,OPPO
}

public enum PhoneEnum {
    IPHONE,OPPO
}

public enum FactoryEnum {
    COMPUTER, PHONE
}

抽象工厂

public abstract class AbstractFactory {
    public abstract IPhone getPhone(PhoneEnum phoneType);
    public abstract IComputer getComputer(ComputerEnum computerType);
}

电脑工厂实现

public class ComputerFactory extends AbstractFactory{
    @Override
    public IPhone getPhone(PhoneEnum phoneType) {
        return null;
    }

    @Override
    public IComputer getComputer(ComputerEnum computerType) {
        switch (computerType){
            case HUAWEI:
                return new HuaweiProductImpl();
            case MACBOOK:
                return new MacbookProductImpl();
        }
        return null;
    }
}

手机工厂实现

public class PhoneFactory extends AbstractFactory {

    @Override
    public IPhone getPhone(PhoneEnum phoneType) {
        switch (phoneType) {
            case OPPO:
                return new OppoPhoneImpl();
            case IPHONE:
                return new IphonePhoneImpl();
        }
        return null;
    }

    @Override
    public IComputer getComputer(ComputerEnum computerType) {
        return null;
    }
}

获得具体生产工厂

public class ProducerFactory {
    public AbstractFactory getFactory(FactoryEnum factoryName) {
        switch (factoryName) {
            case PHONE:
                return new PhoneFactory();
            case COMPUTER:
                return new ComputerFactory();
        }
        return null;
    }
}

手机接口

public interface IPhone {
    void call();
}

手机接口具体实现

public class OppoPhoneImpl implements IPhone{
    @Override
    public void call() {
        System.out.println("oppo 手机为你拨通电话");
    }
}

public class IphonePhoneImpl implements IPhone{
    @Override
    public void call() {
        System.out.println("iphone 已为你拨通电话");
    }
}

电脑接口

public interface IComputer{
    void use();
}

电脑接口具体实现

public class MacbookProductImpl implements IComputer {

    @Override
    public void use() {
        System.out.println("你正在使用的电脑是MacBook");
    }
}

public class HuaweiProductImpl implements IComputer{
    @Override
    public void use() {
        System.out.println("你正在使用的是huawei");
    }
}

生产产品

public class AbstractFactoryMethod {
    public static void main(String[] args) {
        ProducerFactory producerFactory = new ProducerFactory();
        AbstractFactory phoneFactory = producerFactory.getFactory(FactoryEnum.PHONE);
        phoneFactory.getPhone(PhoneEnum.IPHONE).call();
        producerFactory.getFactory(FactoryEnum.COMPUTER).getComputer(ComputerEnum.MACBOOK).use();
    }
}

实现效果

iphone 已为你拨通电话
你正在使用的电脑是MacBook

---

以上便是对简单工厂，工厂方法，抽象工厂的简单实现。