23种设计模式之工厂模式

工厂模式分为 简单工厂、工厂方法

核心理念:实例化对象不使用new 用工厂方法代替 将调用者和实现者分离提高内聚降低耦合。

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

一、简单工厂模式（常用）

用来生产同一等级结构中的任意产品（对于增加新的产品需要扩展已有代码）

例如： 我们创建一个公共的接口 创建两个具体的类实现该接口 然后创建一个消费者来调用

猫的接口

/**
 * 猫接口
 * @create: 2021/6/19
 * @author: Tony Stark
 */
public interface Cat{
    /**
     * 名字
     */
    void name();
}

猫的实现类

/**
 * @create: 2021/6/19
 * @author: Tony Stark
 */
public class BaiMao implements Cat {
    @Override
    public void name() {
        System.out.println("白猫");
    }
}

红猫

/**
 * @create: 2021/6/19
 * @author: Tony Stark
 */
public class RedMao implements Cat{
    @Override
    public void name() {
        System.out.println("红猫");
    }
}

调用

/**
 * @create: 2021/6/19
 * @author: Tony Stark
 */
public class Consumer {
    public static void main(String[] args) {
        //接口， 所有的实现类
       Cat cat=new BaiMao();
       Cat cat1 = new RedMao();
       cat.name();
       cat1.name();
    }
}

这种方式 不理想 我们买猫应该去宠物店买 而不是自己new出来

所以我们应该在生产调用之间 加一个宠物店 （工厂）

加入工厂方法

/**
 * 工厂模式
 * @create: 2021/6/19
 * @author: Tony Stark
 */
public class CatFactory {
    /**
     * 拿到猫的方法
     * 参数为猫的类型  根据类型返回猫
     * @Return
     */
    public static Cat  getCat(String cat){
            String str1="白猫";
            String str2="红猫";
           if (str1.equals(cat)){
              return new BaiMao();
           }else if (str2.equals(cat)){
              return new RedMao();
           }else{
               return null;
           }
    }
}

或者 又称为静态工厂

/**
 * 静态工厂模式
 * @create: 2021/6/19
 * @author: Tony Stark
 */
public class CatFactory {
    /**
     * 拿到猫的方法
     * 参数为猫的类型  根据类型返回猫
     * @Return
     */
    public static Cat  getRedCat(){
          return new RedCat();
    }
    public static Cat getBaiMao(){
          return new BaiMao();
    }
}

调用

/**
 * @create: 2021/6/19
 * @author: Tony Stark
 */
public class Consumer {
    public static void main(String[] args) {
        Cat cat1 = CatFactory.getCat("白猫");
         //调用工厂 返回一只猫
        cat1.name();
    }
}

效果

这样也有弊端 因为如果我们新增一个猫 就需要修改工厂等源代码

不满足我们的开闭原则（对扩展开放，对修改关闭）了

所以为了解决这个问题 我们引入了工厂方法模式

二、工厂方法模式

用来生产同一等级中的固定产品（支持增加任意产品）

增加一个获取猫的工厂接口 每一个新增的猫工厂实现这个接口

猫接口

public interface Cat {
    public void name();
}

猫实现类

public class BaiMao implements Cat {
    @Override
    public void name() {
        System.out.println("白猫");
    }
}

工厂接口

public interface CatFactory {

    public Cat getCat();
}

猫实现工厂

public class BaiMaoFactory implements CatFactory {
    @Override
    public Cat getCat() {
        return new BaiMao();
    }
}

消费者调用

/**
 * @create: 2021/6/19
 * @author: Tony Stark
 */
public class Consumer {
    public static void main(String[] args) {
        Cat cat = new BaiMaoFactory().getCat();
        cat.name();
    }
}

当我们新增加一个产品 只需要实现接口即可 不用修改源代码 。
但这种方法增加了成本 我们大多数时候还会应用简单工厂。