设计模式【04】——抽象工厂模式

最新推荐文章于 2024-04-20 12:45:20 发布

洞之蝉

最新推荐文章于 2024-04-20 12:45:20 发布

阅读量1.3k

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/muyimo/article/details/106515853

版权

设计模式专栏收录该内容

6 篇文章 0 订阅

订阅专栏

书接上回，策略模式最好跟其他模式等结合起来进行混编，弥补策略类膨胀和对外暴露的问题。实际项目中，一般通过工厂方法模式来实现策略类的声明，那么就来学一下工厂模式。

一、抽象工厂模式

1、简介

类比奢侈品店，有一个抽象工厂用来生产迪奥和香奈儿产品，具体的香水柜台，就卖香奈儿和迪奥的香水，具体的包包柜台就卖这两家的包包。

AbstractFactory一个抽象工厂类，有几个产品族，抽象工厂类中就有N个产品的创建方法。如创建香奈儿产品、创建迪奥产品，会有具体的实现类：包包工厂类、香水工厂类
AbstractChaneProd，香奈儿抽象产品类，会有包包和香水实现类
AbstractDiorProd,迪奥抽象产品类，会有具体的包包和香水实现类
测试场景：定义俩柜台，分别让他们出两种包包和香水即可，无须关心具体的实现类。

抽象工厂模式：提供一个创建一组对象（相关或者相互依赖）的接口，无须指定具体类

/**
 * @name: AbstractFactory.class
 * @Author :
 * @create :   2020-07-08
 * @Desc: 抽象工厂类,有多少个产品族，在抽象工厂类中就有N个创建方法
 */
public abstract class AbstractFactory {

    //创建香奶奶系列
    public abstract AbstractChanelProd createChanelProd();

    //创建迪奥系列
    public abstract AbstractDiorProd createDiorProd();
}



/**
 * @name: BagFactory.class
 * @Author :   
 * @create :   2020-07-08
 * @Desc:  包包工厂的实现类
 */
public class BagFactory extends AbstractFactory {
    @Override
    public AbstractChanelProd createChanelProd() {
        return new ChanelBagProd();
    }

    @Override
    public AbstractDiorProd createDiorProd() {
        return new DiorBagProd();
    }
}


/**
 * @name: PerfumeFactory.class
 * @Author :   
 * @create :   2020-07-08
 * @Desc:  香水工厂的实现类
 */
public class PerfumeFactory extends AbstractFactory {
    @Override
    public AbstractChanelProd createChanelProd() {
        return new ChanelPerfumeProd();
    }

    @Override
    public AbstractDiorProd createDiorProd() {
        return new DiorPerfumeProd();
    }
}


/**
 * @name: AbstractChanelProd.class
 * @Author :   
 * @create :   2020-07-08
 * @Desc:  香奈儿抽象产品类
 */
public abstract class AbstractChanelProd {

    public abstract void sayChanel();
}


/**
 * @name: AbstractDiorProd.class
 * @Author :   
 * @create :   2020-07-08
 * @Desc: 迪奥商品的抽象类
 */
public abstract class AbstractDiorProd {
    
    public abstract void sayDior();
}


/**
 * @name: ChanelProduct.class
 * @Author :   
 * @create :   2020-07-08
 * @Desc:  香奈儿包包实现类
 */
public class ChanelBagProd extends AbstractChanelProd {
    @Override
    public void sayChanel() {
        System.out.println("我是香奶奶包包");
    }
}

/**
 * @name: ChanelPerfumeProd.class
 * @Author :   
 * @create :   2020-07-08
 * @Desc: 香奈儿香水的实现类
 */
public class ChanelPerfumeProd extends AbstractChanelProd {
    @Override
    public void sayChanel() {
        System.out.println("我是香奈儿香水！");
    }
}



/**
 * @name: DiorBagProd.class
 * @Author :   
 * @create :   2020-07-08
 * @Desc: 迪奥包包实现类
 */
public class DiorBagProd extends AbstractDiorProd{
    @Override
    public void sayDior() {
        System.out.println("我是迪奥包包");
    }
}




/**
 * @name: DiorPerfumeProd.class
 * @Author :   
 * @create :   2020-07-08
 * @Desc: 迪奥产品抽象类的实现类
 */
public class DiorPerfumeProd extends AbstractDiorProd {
    @Override
    public void sayDior() {
        System.out.println("我是迪奥香水！");
    }
}


/**
 * @name: Store.class
 * @Author :   
 * @create :   2020-07-08
 * @Desc: 商店测试类
 */
public class Store {

    public static void main(String[] args) {

        //定义俩工厂
        AbstractFactory bagFactory = new BagFactory();
        AbstractFactory perfumeFactory = new PerfumeFactory();

        //进货香奈儿、迪奥的包包和香水
        AbstractChanelProd chanelBag = bagFactory.createChanelProd();
        AbstractChanelProd chanelPerfume = perfumeFactory.createChanelProd();

        //没有一个方法与实现类有关，都是抽象商品类
        //只要知道工厂就能生产一个产品，无须关心实现类
        AbstractDiorProd diorBag = bagFactory.createDiorProd();
        AbstractDiorProd diorPerfume = perfumeFactory.createDiorProd();

        chanelBag.sayChanel();
        chanelPerfume.sayChanel();
        diorBag.sayDior();
        diorPerfume.sayDior();
    }

}