设计模式(3) ------- 抽象方法模式

设计模式(3) ——- 抽象方法模式

• 抽象工厂模式可以说是工厂方法模式的进一步抽象。关于 工厂方法模式

概述

• 抽象工厂模式

  工厂方法模式是针对一个产品族，而抽象工厂模式是针对多个产品族。
  什么是产品族什么是产品结构，这里举个例子。大家都知道，Windows 系列和 linux系列操作系统都有用户界面，在用户界面里面有不同的 Button 和 Text 等等。在设计时可以抽象出接口或者抽象类来描述不同的 Button 和 Text 共同的属性。Button 和 Text 可以称为不同的产品结构由它们组成一个操作系统。这里组成的两个系统 Windwos 和 linux 就是两个产品族。图示如下：

  

  那么怎样针对上述例子利用抽象工厂模式建类呢。这里只需要根据不同的产品族创建对应的工厂类即可，其他与工厂方法模式一样。
  抽象工厂模式是三种工厂模式中最为抽象、最具一般性的。

• 抽象工厂模式图示

举例说明

• 案例说明

  想必大家一定自己组装过电脑，对于不同的处理器需要用不同的主板。比如 Amd 的处理器与 Intel 的处理器由于针脚不同必须使用不同的主板。在这里只简单的说着两种，然后只利用处理器和主板组成电脑，抽象说就是生成一个产品族。这里有两种产品族，一种是 Intel 处理器系列组成的，另一种是由 Amd 处理器系列组成的。

• 代码

  package 抽象工厂;
  
  public interface CPU {
    void explain();
    int getStitch();
    void setStitch(int stitch);
  }
  
  package 抽象工厂;
  
  public class AmdCPU implements CPU {
    private int stitch;
  
    public AmdCPU(int stitch) {
        this.stitch = stitch;
    }
  
    @Override
    public void explain() {
        System.out.println("我有 " + stitch + " 针脚。");
    }
  
    public int getStitch() {
        return stitch;
    }
  
    public void setStitch(int stitch) {
        this.stitch = stitch;
    }
  }
  
  package 抽象工厂;
  
  public class IntelCPU implements CPU{
    private int stitch;
  
    public IntelCPU(int stitch) {
        this.stitch = stitch;
    }
  
    @Override
    public void explain() {
        System.out.println("我有 " + stitch + " 针脚。");
    }
  
    public int getStitch() {
        return stitch;
    }
  
    public void setStitch(int stitch) {
        this.stitch = stitch;
    }
  }
  
  package 抽象工厂;
  
  public interface MainBoard {
    void installCPU(CPU cpu);
    int getHoles();
    void setHoles(int holes);
  }
  
  package 抽象工厂;
  
  public class IntelMainBoard implements MainBoard{
    private int holes;
  
    public IntelMainBoard(int holes) {
        this.holes = holes;
    }
  
    @Override
    public void installCPU(CPU cpu) {
        int stitch = cpu.getStitch();
        if (this.holes == stitch) {
            System.out.println("CPU和主板兼容!");
            System.out.println("安装成功!");
        }
        else {
            System.out.println("CPU和主板不兼容!");
            System.out.println("安装失败!");
        }
    }
  
    public int getHoles() {
        return holes;
    }
  
    public void setHoles(int holes) {
        this.holes = holes;
    }
  }
  
  package 抽象工厂;
  
  public class AmdMainBoard implements MainBoard{
    private int holes;
  
    public AmdMainBoard(int holes) {
        this.holes = holes;
    }
  
    @Override
    public void installCPU(CPU cpu) {
        int stitch = cpu.getStitch();
        if (stitch == holes) {
            System.out.println("CPU和主板兼容!");
            System.out.println("安装成功!");
        }
        else {
            System.out.println("CPU和主板不兼容!");
            System.out.println("安装失败!");
        }
    }
  
    @Override
    public int getHoles() {
        return this.holes;
    }
  
    @Override
    public void setHoles(int holes) {
        this.holes = holes;
    }
  }
  
  package 抽象工厂;
  
  public interface Factory {
  
    CPU createCPU();
    MainBoard createMainBoard();
  
  }
  
  package 抽象工厂;
  
  public class AmdFactory implements Factory {
    @Override
    public CPU createCPU() {
        return new AmdCPU(938);
    }
  
    @Override
    public MainBoard createMainBoard() {
        return new AmdMainBoard(938);
    }
  }
  
  package 抽象工厂;
  
  public class IntelFactory implements Factory{
    @Override
    public CPU createCPU() {
        return new IntelCPU(755);
    }
  
    @Override
    public MainBoard createMainBoard() {
        return new IntelMainBoard(755);
    }
  }
  
  package 抽象工厂;
  
  public class Client {
    private CPU cpu;
    private MainBoard mainBoard;
  
    public Client(CPU cpu,MainBoard mainBoard) {
        this.cpu = cpu;
        this.mainBoard = mainBoard;
    }
  
    public void assembleComputer(){
        System.out.println("开始组装电脑：");
        System.out.println("1，准备CPU和主板");
        cpu.explain();
        System.out.println("2，开始安装");
        mainBoard.installCPU(cpu);
    }
  
    public static void main(String[] args) {
        //测试
        AmdFactory amdFactory = new AmdFactory();
        Client client = new Client(amdFactory.createCPU(),amdFactory.createMainBoard());
        client.assembleComputer();
        IntelFactory intelFactory = new IntelFactory();
        client = new Client(intelFactory.createCPU(),intelFactory.createMainBoard());
        client.assembleComputer();
    }
  }

总结

• 优缺点

  它的一个缺点不易扩展，其他的就不再详细的陈述了。具体什么时候用，要靠大家慢慢体会了。

• 小结

  其实，简单工厂模式、工厂方法模式和抽象工厂模式是层层递进的，都挺简单的，但是怎么用就要慢慢的积累经验了。

新年第一天，给大家拜年 O(∩_∩)O~