JAVA常用设计模式(一、抽象工厂模式)

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

如何解决：在一个产品族里面，定义多个产品。

关键代码：在一个工厂里聚合多个同类产品。

应用实例：下面例子中鼠标，键盘，耳麦为产品，惠普，戴尔为工厂，抽象工厂模式也就是不仅生产鼠标，同时生产键盘。也就是 PC 厂商是个父类，有生产鼠标，生产键盘两个接口。戴尔工厂，惠普工厂继承它，

　　　　　可以分别生产戴尔鼠标+戴尔键盘，和惠普鼠标+惠普键盘。创建工厂时，由戴尔工厂创建。后续工厂.生产鼠标()则生产戴尔鼠标，工厂.生产键盘()则生产戴尔键盘。

 

以下是具体实现代码，首先是代码结构图：

import cn.review.day03.abstractfactory.product.Keboy;
import cn.review.day03.abstractfactory.product.Mouse;

/**
 * PC厂商工厂抽象类
 * @author dyq
 *
 */
public abstract class PcFactory {
    public abstract Mouse createMouse();
    public abstract Keboy createKeboy();
}

import cn.review.day03.abstractfactory.product.DellKeyboy;
import cn.review.day03.abstractfactory.product.DellMouse;
import cn.review.day03.abstractfactory.product.Keboy;
import cn.review.day03.abstractfactory.product.Mouse;
/**
 * 戴尔生产工厂
 * @author dyq
 *
 */
public class DellFactory extends PcFactory{

    @Override
    public Mouse createMouse() {
        return new DellMouse();
    }

    @Override
    public Keboy createKeboy() {
        return new DellKeyboy();
    }

}

import cn.review.day03.abstractfactory.product.HpKeboy;
import cn.review.day03.abstractfactory.product.HpMouse;
import cn.review.day03.abstractfactory.product.Keboy;
import cn.review.day03.abstractfactory.product.Mouse;
/**
 * 惠普生产工厂
 * @author dyq
 *
 */
public class HpFactory extends PcFactory{
    @Override
    public Mouse createMouse() {
        return new HpMouse();
    }
    @Override
    public Keboy createKeboy() {
        return new HpKeboy();
    }

}

/**
 * 生成工厂器类，通过不同的厂家来获取不同的生产工厂
 * @author dyq
 *
 */
public class FactoryProducer {
    public static PcFactory getFactory(String choice){
          if(choice.equalsIgnoreCase("DELL")){
             return new DellFactory();
          } else if(choice.equalsIgnoreCase("HP")){
             return new HpFactory();
          }
          return null;
       }
}

/**
 * 产品之鼠标接口
 * @author dyq
 *
 */
public interface Mouse {
    public String sayHi();
}

/**
 * 产品之键盘接口
 * @author dyq
 *
 */
public interface Keboy {
    public String sayHi();
}

/**
 * 戴尔键盘生产类
 * @author dyq
 *
 */
public class DellKeyboy implements Keboy{
    @Override
    public String sayHi() {
        return "生产了戴尔键盘";
    }

}

/**
 * 戴尔鼠标生产类
 * @author dyq
 *
 */
public class DellMouse implements Mouse{

    @Override
    public String sayHi() {
        return "生产了戴尔鼠标";
    }

}

/**
 * 
 * @author dyq
 *
 */
public class HpKeboy implements Keboy{

    @Override
    public String sayHi() {
        return "生产了惠普键盘";
    }

}

public class HpMouse implements Mouse{

    @Override
    public String sayHi() {
        return "生产了惠普鼠标";
    }

}

最后是测试类：

import cn.review.day03.abstractfactory.factory.FactoryProducer;
import cn.review.day03.abstractfactory.factory.PcFactory;
import cn.review.day03.abstractfactory.product.Mouse;
/**
 * 测试抽象工厂模式
 * @author dyq
 *
 */
public class DesignPatternAbstractFactory {
    public static void main(String[] args) {
        PcFactory dellPcFactory = FactoryProducer.getFactory("DELL");
        Mouse dellMouse = dellPcFactory.createMouse();
        String mouse1 = dellMouse.sayHi();
        System.out.println(mouse1);
        
        
        PcFactory hpPcFactory = FactoryProducer.getFactory("HP");
        Mouse hpMouse = hpPcFactory.createMouse();
        String  mouse2 = hpMouse.sayHi();
        System.out.println(mouse2);
    }
}

 

在抽象工厂模式中，假设我们需要增加一个产品

假设我们增加耳麦这个产品，则首先我们需要增加耳麦这个父类，再加上戴尔耳麦，惠普耳麦这两个子类。

之后在PC厂商这个父类中，增加生产耳麦的接口。最后在戴尔工厂，惠普工厂这两个类中，分别实现生产戴尔耳麦，惠普耳麦的功能。