java设计模式---工厂模式

一、工厂模式（Factory Pattern）

工厂模式是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

二、介绍

**意图：**定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
**主要解决：**主要解决接口选择的问题。
**何时使用：**我们明确地计划不同条件下创建不同实例时。
**如何解决：**让其子类实现工厂接口，返回的也是一个抽象的产品。
**关键代码：**创建过程在其子类执行。
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。3、屏蔽产品的具体实现，调用者只关心产品的接口。
**缺点：**每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。
**注意事项：**作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

三、实现

1.普通工厂模式

普通工厂模式:说白了就是写一个接口，用多个类实现这同一个接口。
首先我们先创建一个Animal的接口，里面写一个say方法。

Animal

package com.test.ordinary;
/**
 * @Author test
 * @create 2021/11/27
 */
public interface Animal {
    void say();
}

然后我们再分别创建Cat 、Dog、People三个类来实现这个接口

Cat

package com.test.ordinary;

/**
 * @Author test
 * @create 2021/11/27
 */
public class Cat implements Animal {
    @Override
    public void say() {
        System.out.println("小猫说：喵啊！");
    }
}

Dog

package com.test.ordinary;

/**
 * @Author test
 * @create 2021/11/27
 */
public class Dog implements Animal {
    @Override
    public void say() {
        System.out.println("小狗说：旺啊！");
    }
}

People

package com.test.ordinary;

/**
 * @Author test
 * @create 2021/11/27
 */
public class People implements Animal {
    @Override
    public void say() {
        System.out.println("我说：哎哟！不错哦！");
    }
}

三个实现类写完之后，再创建一个工厂类Factory，来返回这些实现类的对象。

package com.test.ordinary;

/**
 * @Author luyu
 * @create 2021/11/27
 */
public class Factory {

    public Animal whoSay(String sayer){
        if ("cat".equals(sayer)){
            return new Cat();
        } else if ("dog".equals(sayer)){
            return new Dog();
        }else if ("people".equals(sayer)){
            return new People();
        }
        return null;
    }
}

接下来，测试一下，通过参数是谁,来控制该是谁说话！

package com.test.ordinary;

/**
 * @Author luyu
 * @create 2021/11/27
 */
public class main {
    public static void main(String[] args) {
        Factory factory = new Factory();

        Animal cat = factory.whoSay("cat");
        cat.say();

        Animal dog = factory.whoSay("dog");
        dog.say();

        Animal people = factory.whoSay("people");
        people.say();
    }
}

输出的结果：

2.抽象工厂模式
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

1.正常创建一个Animal的接口，里面存在一个say方法；

package com.test.abstractFac;

/**
 * @Author luyu
 * @create 2021/11/27
 */
public interface Animal {
    void say();
}

2.再分别创建Cat 、Dog、People三个实体类来实现这个接口的

package com.test.ordinary;

/**
 * @Author test
 * @create 2021/11/27
 */
public class Cat implements Animal {
    @Override
    public void say() {
        System.out.println("小猫说：喵啊！");
    }
}

package com.test.ordinary;

/**
 * @Author test
 * @create 2021/11/27
 */
public class Dog implements Animal {
    @Override
    public void say() {
        System.out.println("小狗说：旺啊！");
    }
}

package com.test.ordinary;

/**
 * @Author test
 * @create 2021/11/27
 */
public class People implements Animal {
    @Override
    public void say() {
        System.out.println("我说：哎哟！不错哦！");
    }
}

3.再为实物创建一个Food接口

package com.test.abstractFac;

/**
 * @Author luyu
 * @create 2021/11/27
 */
public interface Food {
    void eatFood();
}

4.分别用 CatFood、DogFood、PeopleFood三个类来实现Food中的吃方法:
CatFood

package com.test.abstractFac;

/**
 * @Author luyu
 * @create 2021/11/27
 */
public class CatFood implements Food {
    @Override
    public void eatFood() {
        System.out.println("小猫吃的是猫粮！");
    }
}

DogFood

package com.test.abstractFac;

/**
 * @Author luyu
 * @create 2021/11/27
 */
public class DogFood implements Food {
    @Override
    public void eatFood() {
        System.out.println("小狗吃的是狗粮！");
    }
}

PeopleFood

package com.test.abstractFac;

/**
 * @Author luyu
 * @create 2021/11/27
 */
public class PeopleFood implements Food {
    @Override
    public void eatFood() {
        System.out.println("我吃的是单身狗粮！");
    }
}

5.再为动物和实物创建一个抽象类(AbstractFactory)来获取工厂

package com.test.abstractFac;

/**
 * @Author luyu
 * @create 2021/11/28
 */
public abstract class AbstractFactory {
    public abstract Animal getSay(String sType);
    public abstract Food getFood(String fType);
}

6.创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象
FoodFactory

package com.test.abstractFac;

import com.test.ordinary.Cat;
import com.test.ordinary.Dog;
import com.test.ordinary.People;

/**
 * @Author luyu
 * @create 2021/11/28
 */
public class FoodFactory extends AbstractFactory{
    @Override
    public Food getFood(String sayerType) {
        if (sayerType == null){
            return null;
        }
        if ("catF".equals(sayerType)){
            return new CatFood();
        } else if ("dogF".equals(sayerType)){
            return new DogFood();
        }else if ("peopleF".equals(sayerType)){
            return new PeopleFood();
        }
        return null;
    }

    @Override
    public Animal getSay(String sType) {
        return null;
    }
}

AnimalFactory

package com.test.abstractFac;

import com.test.abstractFac.Cat;
import com.test.abstractFac.Dog;
import com.test.abstractFac.People;

/**
 * @Author luyu
 * @create 2021/11/27
 */
public class AnimalFactory extends AbstractFactory{

    @Override
    public Animal getSay(String sType) {
        if (sType == null){
            return null;
        }
        if ("cat".equals(sType)){
            return new Cat();
        } else if ("dog".equals(sType)){
            return new Dog();
        }else if ("people".equals(sType)){
            return new People();
        }
        return null;
    }

    @Override
    public Food getFood(String fType) {
        return null;
    }
}

7.创建一个工厂创造器/生成器类,通过传递动物类型或食物类型来获取工厂
FactoryProducer

package com.test.abstractFac;

/**
 * @Author luyu
 * @create 2021/11/28
 * 分发工厂
 */
public class FactoryProducer {
    public static AbstractFactory getAbsFactory(String flag){
        if (flag.equals("Food")){
            return new FoodFactory();
        }else if (flag.equals("Animal")){
            return new AnimalFactory();
        }
        return null;
    }
}

8.使用FactoryProducer 来获取抽象工厂AbstractFactory,通过传递的信息类型来获取实现类打印的信息:
AbstractFactoryDemo

package com.test.abstractFac;

/**
 * @Author luyu
 * @create 2021/12/17
 */
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        //获取食物工厂
        AbstractFactory abstractFactory1 = FactoryProducer.getAbsFactory("Food");
        //获取猫的食物实现类
        Food catF = abstractFactory1.getFood("catF");
        //调用实现类的方法
        catF.eatFood();

        //获取狗的食物实现类
        Food dogF = abstractFactory1.getFood("dogF");
        //调用实现类的方法
        dogF.eatFood();

        //获取人类的食物实现类
        Food peopleF = abstractFactory1.getFood("peopleF");
        //调用实现类的方法
        peopleF.eatFood();

        //获取动物工厂
        AbstractFactory abstractFactory2 = FactoryProducer.getAbsFactory("Animal");
        //获取猫的实现类
        Animal cat = abstractFactory2.getSay("cat");
        //调用猫的实现方法
        cat.say();

        //获取狗的实现类
        Animal dog = abstractFactory2.getSay("dog");
        //调用狗的实现方法
        dog.say();

        //获取人类的实现类
        Animal people = abstractFactory2.getSay("people");
        //调用人类的实现方法
        people.say();
    }
}

9.实现结果

小猫吃的是猫粮！
小狗吃的是狗粮！
我吃的是单身狗粮！
小猫说：喵啊！
小狗说：旺啊！
我说：哎哟！不错哦！