JAVA设计模式-抽象工厂模式

Bertha 。 2024-04-19 11:00 84阅读 0赞

### 一、概念 ###

先有一个抽象工厂，然后去生成其他具体工厂，然后用其他具体工厂创建对象。

> 客户类和工厂类分开。消费者任何时候需要某套产品集合时，只需向抽象工厂请求即可。抽象工厂会再向具体的工厂生产出符合产品集规格的产品。（来源于百度百科）

### 二、代码 ###

> 上例子：
> 
> 要生产一台电脑，定义一个抽象工厂（Factory），然后用该抽象工厂去创建一个生产主机的工厂（CaseFactory），再使用具体的工厂去生产零件（Cpu、Mem、Gpu、Disk、Computer），最后组装电脑。

Component：零件类

public abstract class Component {
        /**
         * 成本价
         */
        protected int cost;
    
        public Component(int cost) {
            this.cost = cost;
        }
    
        /**
         * 零件信息
         * @return
         */
        public abstract String info();
    }

Cpu：CPU类

public abstract class Cpu extends Component{
    
        public Cpu(int cost) {
            super(cost);
        }
    }

Mem：内存条类

public abstract class Mem extends Component {
        /**
         * 内存大小
         */
        protected String mem;
    
        public Mem(int cost,String mem) {
            super(cost);
            this.mem = mem;
        }
    }

Gpu：显卡类

public abstract class Gpu extends Component{
        /**
         * 显存
         */
        protected String mem;
    
        public Gpu(int cost,String mem) {
            super(cost);
            this.mem = mem;
        }
    }

Disk：硬盘类

public abstract class Disk extends Component{
        /**
         * 存储大小
         */
        protected String storageSize;
        /**
         * 硬盘类型
         */
        protected String type;
        public Disk(int cost,String storageSize,String type) {
            super(cost);
            this.storageSize = storageSize;
            this.type = type;
        }
    }

Computer：主机箱/笔记本类

public abstract class Computer extends Component{
        //CPU
        protected Cpu cpu;
        //显卡
        protected Gpu gpu;
        //内存条
        protected Mem mem;
        //硬盘
        protected Disk disk;
        //总价
        protected int totalCost;
    
        public Computer(int cost) {
            super(cost);
            this.totalCost = cost;
        }
    
        /**
         * 安装零件
         */
        public void fitComponent(Cpu cpu,Gpu gpu,Mem mem,Disk disk){
            this.cpu = cpu;
            totalCost += cpu.cost;
            this.gpu = gpu;
            totalCost += gpu.cost;
            this.mem = mem;
            totalCost += mem.cost;
            this.disk = disk;
            totalCost += disk.cost;
        }
    }

Factory：抽象工厂

public abstract class Factory {
        //生成具体工厂的静态方法
        public static Factory getFactory(String clazz){
            try {
                return (Factory) Class.forName(clazz).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
                throw new RuntimeException(e.getMessage());
            }
        }
    
        /**
         * 创建CPU
         */
        public abstract Cpu createCpu(int cost);
    
        /**
         * 创建显卡
         */
        public abstract Gpu createGpu(int cost,String mem);
    
        /**
         * 创建内存条
         */
        public abstract Mem createMem(int cost,String mem);
    
        /**
         * 创建硬盘
         */
        public abstract Disk createDisk(int cost,String storageSize,String type);
    
        /**
         * 创建一个主机/笔记本
         */
        public abstract Computer createComputer(int cost);
    }

> 到此，抽象部分定义完毕，接下来定义具体部分

IntelCpu：英特尔CPU

public class IntelCpu extends Cpu {
    
        /**
         * 型号
         */
        private String model;
    
        public IntelCpu(int cost,String model) {
            super(cost);
            this.model = model;
        }
    
        @Override
        public String info() {
            return "CPU [ Intel " + model + " ] "+cost +"元";
        }
    }

SansungMem：三星内存条

public class SansungMem extends Mem {
    
        public SansungMem(int cost, String mem) {
            super(cost, mem);
        }
    
        @Override
        public String info() {
            return "内存 [ 三星 "+ mem +" ] "+cost+"元";
        }
    }

NvidiaGpu：英伟达显卡

public class NvidiaGpu extends Gpu {
        /**
         * 型号
         */
        private String model;
    
        public NvidiaGpu(int cost, String mem,String model) {
            super(cost, mem);
            this.model = model;
        }
    
        @Override
        public String info() {
            return "显卡 [ NVIDIA " + model + " " + mem + " ] " +cost+"元";
        }
    }

SansungDisk：三星硬盘

public class SansungDisk extends Disk {
    
        public SansungDisk(int cost, String storageSize, String type) {
            super(cost, storageSize, type);
        }
    
        @Override
        public String info() {
            return "硬盘 [ 三星 " + storageSize + " " + type + " ] " + cost+"元";
        }
    }

CaseComputer：主机箱

public class CaseComputer extends Computer {
        private static final String LINEFEED = "\r\n";
    
        public CaseComputer(int cost) {
            super(cost);
        }
    
        @Override
        public String info() {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("主机信息：");
            stringBuilder.append(LINEFEED);
            stringBuilder.append("总价：").append(totalCost).append("元");
            stringBuilder.append(LINEFEED);
            stringBuilder.append(cpu.info());
            stringBuilder.append(LINEFEED);
            stringBuilder.append(mem.info());
            stringBuilder.append(LINEFEED);
            stringBuilder.append(gpu.info());
            stringBuilder.append(LINEFEED);
            stringBuilder.append(disk.info());
            return stringBuilder.toString();
        }
    }

CaseFactory：组装机工厂

public class CaseFactory extends Factory {
    
        @Override
        public Cpu createCpu(int cost) {
            return new IntelCpu(cost,"2.9 GHz Intel Core i7");
        }
    
        @Override
        public Gpu createGpu(int cost, String mem) {
            return new NvidiaGpu(cost,mem,"GTX2080 Ti");
        }
    
        @Override
        public Mem createMem(int cost, String mem) {
            return new SansungMem(cost,mem);
        }
    
        @Override
        public Disk createDisk(int cost, String storageSize, String type) {
            return new SansungDisk(cost,storageSize,type);
        }
    
        @Override
        public Computer createComputer(int cost) {
            return new CaseComputer(cost);
        }
    }

> 到此为止，具体的零件类以及具体的工厂（组装机工厂）已经都有了，接下来就是生产一台主机

main方法测试

public static void main(String[] args) {
            Factory factory = Factory.getFactory("designpattern.abstract_factory_pattern.CaseFactory");
            Computer computer = factory.createComputer(1000);
            Cpu cpu = factory.createCpu(1700);
            Gpu gpu = factory.createGpu(2300,"6G");
            Mem mem = factory.createMem(400,"16G");
            Disk disk = factory.createDisk(450,"256G","固态");
            computer.fitComponent(cpu,gpu,mem,disk);
            String info = computer.info();
            System.out.println(info);
        }

结果

主机信息：
    总价：5850元
    CPU [ Intel 2.9 GHz Intel Core i7 ] 1700元
    内存 [ 三星 16G ] 400元
    显卡 [ NVIDIA GTX2080 Ti 6G ] 2300元
    硬盘 [ 三星 256G 固态 ] 450元

### 三、结构 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhb3hpbGFveGlf_size_16_color_FFFFFF_t_70][] 结构

### 四、优劣 ###

> 抽象模块定义好后，很容易扩展新的具体工厂，且使用方代码不怎么需要改，如上main方法，只传入的一个具体工厂类名，就可以运作。
> 
> 但新增零件就比较麻烦（例如新增加一个风扇，则抽象层需要增加一个抽象风扇，抽象工厂需要增加一个生产风扇的方法，且具体实现层也需要增加具体的实现，并且已有的具体工厂也得修改）。
> 
> Spring使用了大量的抽象工厂模式。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xhb3hpbGFveGlf_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/881c0077bd524bc4b74a17eb2a8c1f51.png