设计模式 - 工厂模式 - 《Java 学习之路》

简单工厂模式
工厂方法模式
抽象工厂模式

定义：工厂模式是一种非常常用的创建型设计模式，其提供了创建对象的最佳方式。在创建对象时，不会对客户端暴露对象的创建逻辑，而是通过使用共同的接口来创建对象。

简单工厂模式

就是简单的将创建对象的过程交由工厂类来处理。逻辑比较简单，直接上代码。
如何吃鱼的抽象类

public abstract class EatFish {
    public void buyFish(){
        System.out.println("买一条鱼。");
    }
    public void handlingFish(){
        System.out.println("处理鱼：杀鱼、去鱼鳞、去内脏");
    }
    public abstract void cookFish();
    public void eatfish(){
        System.out.println("开吃");
    }
}

具体如何吃鱼

/**
 * 鱼汤
 */
public class FishSoup extends EatFish {
    @Override
    public void cookFish() {
        System.out.println("鱼汤");
    }
}
/**
 * 烤鱼
 */
public class RoastFish  extends EatFish{
    @Override
    public void cookFish() {
        System.out.println("烤鱼");
    }
}
/**
 * 清蒸鱼
 */
public class SteamedFish extends EatFish{
    @Override
    public void cookFish() {
        System.out.println("清蒸");
    }
}

工厂类创建具体的吃鱼类

/**
 * 简单工厂模式:将创建对象的过程交给工厂，只需提供对应的类型
 */
public class SimpleFactory {
    public EatFish createEatFish(String cookType) {
        EatFish eatFish = null;
        if ("steamed".equals(cookType)) {
            eatFish = new SteamedFish();
        } else if ("roast".equals(cookType)) {
            eatFish = new RoastFish();
        } else if ("soup".equals(cookType)) {
            eatFish = new FishSoup();
        }
        return eatFish;
    }
}

吃鱼

class PeopleEat {
    private SimpleFactory simpleFactory ;
    public PeopleEat(SimpleFactory simpleFactory){
        this.simpleFactory = simpleFactory;
    }
    public void  eat(String cookType){
        EatFish eatFish = simpleFactory.createEatFish(cookType);
        eatFish.buyFish();
        eatFish.handlingFish();
        eatFish.cookFish();
        eatFish.eatfish();
    }
}

工厂方法模式

其实就是在简单工厂的基础上，将创建对象的方法交由其子类去实现，细化其创建的对象。
抽象方法

/**
 * 将创建对象的过程往后推，由子类进行创建
 * 比如：江西人喜欢烤鱼和清蒸鱼，湖南人喜欢烤鱼和鱼汤
 */
public abstract class People {
    abstract EatFish createEatFish(String cookType);
    public void  eat(String cookType){
        EatFish eatFish = createEatFish(cookType);
        eatFish.buyFish();
        eatFish.handlingFish();
        eatFish.cookFish();
        eatFish.eatfish();
    }
}

具体哪里的人创建对应的对象

/**
 * 江西人喜欢烤鱼和清蒸鱼
 */
public class JiangXiPeople extends People {
    @Override
    EatFish createEatFish(String cookType) {
        EatFish eatFish = null ;
        if ("steamed".equals(cookType)) {
            eatFish = new SteamedFish();
        } else if ("roast".equals(cookType)) {
            eatFish = new RoastFish();
        }
        return eatFish;
    }
    public static void main(String[] args) {
        People people = new JiangXiPeople();
        people.eat("steamed");
    }
}

抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
举个例子：

有小米和华为两个品牌，都能生产手机和路由器。这里就有两个维度了：1.小米和华为都有自己的工厂 2.工厂可以分为手机工厂和路由器工厂

类图如下：

创建手机工厂和路由器工厂的工厂

//产品工厂接口
public interface IProductFactory {
    //生产手机
    IPhoneProduct phoneProduct();
    //生成路由器
    IRouterProduct routerProduct();
}

创建手机和路由器的工厂

//手机产品接口
 interface IPhoneProduct {
    //开机
    void start();
    //关机
    void shutdown();
    //打电话
    void callup();
    //发邮件
    void sendSMS();
}
//路由器产品接口
 interface IRouterProduct {
    //开机
    void start();
    //关机
    void shutdown();
    //打开wifi
    void openwifi();
    //设置
    void setting();
}

各自具体制作内容


//华为手机实现类
 class HuaweiPhone implements IPhoneProduct {
    @Override
    public void start() {
        System.out.println("开启华为手机");
    }
    @Override
    public void shutdown() {
        System.out.println("关闭华为手机");
    }
    @Override
    public void callup() {
        System.out.println("华为手机打电话");
    }
    @Override
    public void sendSMS() {
        System.out.println("华为手机发邮件");
    }
}
//华为路由器实现类
 class HuaweiRouter implements IRouterProduct {
    @Override
    public void start() {
        System.out.println("开启华为路由器");
    }
    @Override
    public void shutdown() {
        System.out.println("关闭华为路由器");
    }
    @Override
    public void openwifi() {
        System.out.println("打开华为wifi");
    }
    @Override
    public void setting() {
        System.out.println("设置华为路由器");
    }
}
//小米手机实现类
 class XiaomiPhone implements IPhoneProduct {
    @Override
    public void start() {
        System.out.println("开启小米手机");
    }
    @Override
    public void shutdown() {
        System.out.println("关闭小米手机");
    }
    @Override
    public void callup() {
        System.out.println("小米手机打电话");
    }
    @Override
    public void sendSMS() {
        System.out.println("小米手机发邮件");
    }
}
//小米路由器实现类
 class XiaomiRouter implements IRouterProduct {
    @Override
    public void start() {
        System.out.println("开启小米路由器");
    }
    @Override
    public void shutdown() {
        System.out.println("关闭小米路由器");
    }
    @Override
    public void openwifi() {
        System.out.println("打开小米wifi");
    }
    @Override
    public void setting() {
        System.out.println("设置小米路由器");
    }
}

创建各自的工厂

//华为工厂实现类
public class HuaweiFactory implements IProductFactory {
    @Override
    public IPhoneProduct phoneProduct() {
        return new HuaweiPhone();
    }
    @Override
    public IRouterProduct routerProduct() {
        return new HuaweiRouter();
    }
}
//小米工厂实现类
 class XiaomiFactory implements IProductFactory {
    @Override
    public IPhoneProduct phoneProduct() {
        return new XiaomiPhone();
    }
    @Override
    public IRouterProduct routerProduct() {
        return new XiaomiRouter();
    }
}