JAVA创建型模式--工厂模式

一、引言

好了好了，今天继续学习JAVA设计模式的工厂模式~

工厂模式是属于创建型模型的一种 ~

认真看完，你也能手写工厂模式，吊打面试官！

二、什么是工厂模式 

• 实例化对象不用new，使用工厂方法代替。
• 将选择实现类，创建对象统一管理和控制。从而将调用者跟实现类解耦。而将调用者跟实现类解耦。

三、三种工厂模式

1. 简单工厂模式 ：用来生产同一等级结构中的任意产品（对于增加新的产品，需要修改已有的代码）
2. 工厂方法模式 ：用来生产同一等级结构中的固定产品（支持增加任意产品）
3. 抽象工厂： 围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

四、简单工厂模式：

介绍：工厂模式中最简单的使用方式

优点：比较简单实现，在项目中应用比较多

缺点：不满足开闭原则（对于新增加的产品，需要修改原来的代码）

思路图：

 

实现: 

步骤1：接口的定义

/**
 * @Author WangYan
 * @Date 2022/6/15 10:23
 * @Version 1.0
 */
public interface Animal {

    void animal();
}

步骤2: Animal的实现类

/**
 * @Author WangYan
 * @Date 2022/6/15 13:42
 * @Version 1.0
 */
public class Dog implements Animal{

    @Override
    public void animal() {
        System.out.println("我是一个狗!");
    }
}

/**
 * @Author WangYan
 * @Date 2022/6/15 13:41
 * @Version 1.0
 */
public class Pig implements Animal {

    @Override
    public void animal() {
        System.out.println("我是一只猪！");
    }
}

步骤3 ：实现工厂类，并且提供获取不同产品对象的方法

/**
 * @Author WangYan
 * @Date 2022/6/15 13:43
 * @Version 1.0
 * 简单工厂类
 */
public class FactoryAnimal {

    public static Animal getFactory(String animal){
        if (animal.equals("dog")){
            return new Dog();
        }else if (animal.equals("pig")){
            return new Pig();
        }else {
            return null;
        }
    }
}

/**
 * @Author WangYan
 * @Date 2022/6/15 13:45
 * @Version 1.0
 * Test测试类
 */
public class Test {

    public static void main(String[] args) {
        Animal dog = FactoryAnimal.getFactory("dog");
        Animal pig = FactoryAnimal.getFactory("pig");
        dog.animal();
        pig.animal();
    }
}

工厂方法模式：

介绍：简单的来说，工厂方法就是让类的实例化推迟到工厂子类去实现。

优点：其实和简单工厂类似，用户只需要关心产品对应的工厂，无需关心创建产品的细节。但简单工厂有违背开闭原则，工厂方法解决很好地解决了这个问题。因为对象的实例化推迟到工厂的子类去实现，符合开闭原则，提高可扩展性。

缺点：这个也很显而易见，如果新增一个产品，需要创建产品对象以及创建对应产品的工厂， 类的个数就容易增多，增加了复杂度。

思路图：

实现：

步骤1：抽象接口工厂类

/**
 * @Author WangYan
 * @Date 2022/8/14 22:34
 * @Version 1.0
 * 工厂方法模式
 */
public interface AnimalFactory {

    Animal getAnimal();
}

步骤2：分别抽象接口的实现类

/**
 * @Author WangYan
 * @Date 2022/8/14 22:35
 * @Version 1.0
 */
public class DogFactory implements AnimalFactory {
    @Override
    public Animal getAnimal() {
        return new Dog();
    }
}

/**
 * @Author WangYan
 * @Date 2022/8/14 22:36
 * @Version 1.0
 */
public class PigFactory implements AnimalFactory {
    @Override
    public Animal getAnimal() {
        return new Pig();
    }
}

/**
 * @Author WangYan
 * @Date 2022/6/15 13:45
 * @Version 1.0
 * Test测试类
 */
public class Test {

    public static void main(String[] args) {
        Animal pig = new PigFactory().getAnimal();
        Animal dog = new DogFactory().getAnimal();

        pig.animal();
        dog.animal();
    }
}

抽象工厂模式： 

介绍：抽象工厂模式提供一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类。

优点：无需关心创建细节，将一个系列的产品统一到一起创建。

缺点：产品族扩展新的产品比较困难，需要修改抽象工厂的定义，同时也增加了系统的抽象和理解难度。 

思路图：

实现： 

步骤1：定义两个抽象的产品接口ProductA,ProductB

1.ProductA

/**
 * @Author WangYan
 * @Date 2022/8/15 11:20
 * @Version 1.0
 * 手机产品接口
 */
public interface IphoneProduct {

    void start();

    void shutdown();

    void callup();

    void sendMessage();
}

/**
 * @Author WangYan
 * @Date 2022/8/15 11:26
 * @Version 1.0
 */
public 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 sendMessage() {
        System.out.println("小米手机发信息！");
    }
}

 

/**
 * @Author WangYan
 * @Date 2022/8/15 11:26
 * @Version 1.0
 */
public 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 sendMessage() {
        System.out.println("华为手机发信息！");
    }
}

2.ProductB

/**
 * @Author WangYan
 * @Date 2022/8/15 11:21
 * @Version 1.0
 * 路由器产品接口
 */
public interface IRouterProduct {

    void start();

    void shutdown();

    void callOpenWifi();
}

 

/**
 * @Author WangYan
 * @Date 2022/8/15 11:28
 * @Version 1.0
 */
public class XiaomiIRouter implements IRouterProduct {
    @Override
    public void start() {
        System.out.println("小米路由器开机！");
    }

    @Override
    public void shutdown() {
        System.out.println("小米路由器关机！");
    }

    @Override
    public void callOpenWifi() {
        System.out.println("小米路由器打开wifi！");
    }
}

 

/**
 * @Author WangYan
 * @Date 2022/8/15 11:29
 * @Version 1.0
 */
public class HuaWeiIRouter implements IRouterProduct {
    @Override
    public void start() {
        System.out.println("华为路由器开机！");
    }

    @Override
    public void shutdown() {
        System.out.println("华为路由器关机！");
    }

    @Override
    public void callOpenWifi() {
        System.out.println("华为路由器打开wifi！");
    }
}

 

步骤2：定义抽象工厂，并且提供创建多个产品的方法，然后有对应不同的产品工厂类，分别实现该方法。

/**
 * @Author WangYan
 * @Date 2022/8/15 11:38
 * @Version 1.0
 * 抽象产品工厂
 */
public interface ProductFactory {

    // 手机
    IphoneProduct iphoneProduct();

    // 路由器
    IRouterProduct iRouterProduct();
}

 

/**
 * @Author WangYan
 * @Date 2022/8/15 11:43
 * @Version 1.0
 */
public class HuaWeiFactory implements ProductFactory {
    @Override
    public IphoneProduct iphoneProduct() {
        return new HuaWeiPhone();
    }

    @Override
    public IRouterProduct iRouterProduct() {
        return new HuaWeiIRouter();
    }
}

/**
 * @Author WangYan
 * @Date 2022/8/15 11:46
 * @Version 1.0
 */
public class XiaomiFactory implements ProductFactory {

    @Override
    public IphoneProduct iphoneProduct() {
        return new XiaomIPhone();
    }

    @Override
    public IRouterProduct iRouterProduct() {
        return new XiaomiIRouter();
    }
}

 

/**
 * @Author WangYan
 * @Date 2022/8/15 11:48
 * @Version 1.0
 * Test测试类
 */
public class Test {
    public static void main(String[] args) {

        System.out.println("=======小米系列产品=======");
        // 小米工厂
        XiaomiFactory xiaomiFactory = new XiaomiFactory();
        IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();
        iphoneProduct.callup();
        iphoneProduct.shutdown();

        xiaomiFactory.iRouterProduct().callOpenWifi();
    }
}

 

总结： 

简单工厂模式(静态工厂模式)：虽然某种程度上不符合设计原则，但实际应用最多！

工厂方法模式 ：不修改已有类的前提下，通过增加新的工厂类实现扩展，这样的话，类也会越来越多，变得比较复杂！

抽象工厂模式 ：不可以增加产品，可以增加产品族！

拜拜~

有任何问题欢迎大家指出~

Thank You !