设计模式——抽象工厂模式

前言

抽象工厂模式和工厂模式都属于创建型模式。不同的是：工厂方法模式，每个工厂只生产一种类型的产品。而抽象工厂模式能够生产多种类型的产品。下面以工厂生产电脑为例来说一下抽象工厂模式的实现：

抽象工厂模式的实现

(1)创建抽象产品类

public abstract class CPU {
       public abstract void showCPU();
}

public abstract class Memory {
    public abstract void showMemory();
}

public abstract class HD {
    public abstract void showHD();
}

（2）创建具体产品类

public class AmdCpu extends CPU {
    @Override
    public void showCPU() {
        Log.e("========","AmdCpu");
    }
}

public class IntelCpu extends CPU {
    @Override
    public void showCPU() {
        Log.e("========","IntelCpu");
    }
}

public class KingstonMemory extends Memory {
    @Override
    public void showMemory() {
        Log.e("========","KingstonMemory");
    }
}

public class SamsungMemory extends Memory {
    @Override
    public void showMemory() {
        Log.e("========","SamsungMemory");
    }
}

public class SeagateHD extends HD {
    @Override
    public void showHD() {
        Log.e("========","SeagateHD");
    }
}

public class WdHD extends HD {
    @Override
    public void showHD() {
        Log.e("========","WdHD");
    }
}

（3）创建抽象工厂类

public abstract class ComputerFactory {
    public abstract CPU createCpu();

    public abstract Memory createMemory();

    public abstract HD createHD();
}

（4）创建具体工厂类

public class HuaWeiFactory extends ComputerFactory {
    @Override
    public CPU createCpu() {
        return new AmdCpu();
    }

    @Override
    public Memory createMemory() {
        return new KingstonMemory();
    }

    @Override
    public HD createHD() {
        return new WdHD();
    }
}

public class LenovoFactory extends ComputerFactory {
    @Override
    public CPU createCpu() {
        return new IntelCpu();
    }

    @Override
    public Memory createMemory() {
        return new SamsungMemory();
    }

    @Override
    public HD createHD() {
        return new SeagateHD();
    }
}

测试

    /**
     * 抽象工厂模式
     */
    private void testAbstractFactory() {
        ComputerFactory lenovoFactory=new LenovoFactory();
        lenovoFactory.createCpu().showCPU();
        lenovoFactory.createMemory().showMemory();
        lenovoFactory.createHD().showHD();

        Log.e("==============","=============");

        ComputerFactory huaweiFactory=new  HuaWeiFactory();
        huaweiFactory.createCpu().showCPU();
        huaweiFactory.createMemory().showMemory();
        huaweiFactory.createHD().showHD();
    }

打印结果：

2020-03-10 11:45:59.003 10087-10087/com.she.javaprojectdemo E/========: IntelCpu
2020-03-10 11:45:59.004 10087-10087/com.she.javaprojectdemo E/========: SamsungMemory
2020-03-10 11:45:59.004 10087-10087/com.she.javaprojectdemo E/========: SeagateHD
2020-03-10 11:45:59.004 10087-10087/com.she.javaprojectdemo E/==============: =============
2020-03-10 11:45:59.004 10087-10087/com.she.javaprojectdemo E/========: AmdCpu
2020-03-10 11:45:59.004 10087-10087/com.she.javaprojectdemo E/========: KingstonMemory
2020-03-10 11:45:59.004 10087-10087/com.she.javaprojectdemo E/========: WdHD

优点

解耦：创建实例的工作与使用实例的工作分开，使用者不必关心类对象如何创建。

缺点

如果增加新的产品，则需要修改抽象工厂和所有的具体工厂，违反了开放封闭原则。