工厂模式 Factory Pattern（简单工厂、工厂方法、抽象工厂）

工厂模式-创建型模式-提供了创建对象的最佳方式。

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

简单工厂

简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。（工厂类拥有一个工厂方法（create），接受了一个参数，通过不同的参数实例化不同的产品类。）

定义了一个创建对象的类，由这个类来封装实例化对象的行为。

例子：一个汽车生产工厂，生产不同品牌的汽车，每台汽车具有说广告标语的行为。将汽车生产工厂封装成一个简单工厂类。说汽车广告标语的行为封装为一个接口。

接口：

package com.robin.factoryPattern.simpleFactory;

public interface Moveable {
    
    void RunRoad();
}

品牌汽车类：

比亚迪：

package com.robin.factoryPattern.simpleFactory;

// 比亚迪
public class BydCar implements Moveable {

    @Override
    public void RunRoad() {
        System.out.println("[比亚迪]:一路同驰骋");
    }
}

法拉利：

package com.robin.factoryPattern.simpleFactory;

// 法拉利汽车
public class FerrariCar implements Moveable {

    @Override
    public void RunRoad() {
        System.out.println("[法拉利]:对车手来说，是速度\n" +
                "对小孩来说，是红色\n" +
                "对父亲来说，是血液\n" +
                "对车迷来说，是情人\n" +
                "对个人来说，是挑战\n" +
                "对一群人来说，是传奇\n" +
                "对我们来说，是一切");
    }
}

五菱宏光：

package com.robin.factoryPattern.simpleFactory;

// 五菱汽车
public class WuLingCar implements Moveable {

    @Override
    public void RunRoad() {
        System.out.println("[五菱宏光]:人民需要什么，五菱就造什么");
    }
}

简单工厂类：

package com.robin.factoryPattern.simpleFactory;

public class SimpleFactory {

    // 根据传入参数进行不同汽车的生产
    public Moveable getVehicle(String vehicleName){
        if (vehicleName.equalsIgnoreCase("BYD")){
            return new BydCar();
        }else if(vehicleName.equalsIgnoreCase("FERRARI")){
            return new FerrariCar();
        }else if(vehicleName.equalsIgnoreCase("WULING")){
            return new WuLingCar();
        }
        return null;
    }
}

客户端类：

package com.robin.factoryPattern.simpleFactory;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 充当客户端 利用一个While循环测试
        while (true){
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入汽车名称:");
            String carName = scanner.next();
            Moveable m = new SimpleFactory().getVehicle(carName);
            if (m==null){
                break;
            }else {
                m.RunRoad();
            }
        }
        System.out.println("=====over=====");
    }
}

小结：当我们需要新的品牌汽车时，在简单工厂类中进行代码修改即可。

• 优点：很明显，简单工厂的特点就是“简单粗暴”，通过一个含参的工厂方法，可以实例化任何产品类。
• 缺点：
  • 任何”东西“的子类都可以被生产，负担太重。当所要生产产品种类非常多时，工厂方法的代码量可能会很庞大。
  • 没有遵循开闭原则（对拓展开放，对修改关闭），简单工厂对于增加新的产品，无能为力。因为增加新产品只能通过修改工厂方法来实现。

工厂方法

结合上面的简单工厂，工厂方法进一步解耦合，把工厂类进行抽象，不再负责所有实例的创建，而是把具体的创建工作交给其子类去完成，实例化延迟到子类加载，由子类来决定要实例化的类。

一句话概括就是，工厂方法定义了一个对象的接口，但由子类去决定实例化的类是哪一个。

一个电脑配件工厂，创建对应的品牌配件。

鼠标接口（打印名称）:

package com.robin.factoryPattern.factoryMethod;

public interface CpParts {
    void printName();
}

鼠标工厂方法类：

package com.robin.factoryPattern.factoryMethod;

public abstract class CpPartsFactory {

    public abstract CpParts create();
}

鼠标实现类工厂：

package com.robin.factoryPattern.factoryMethod;

public class HpMouseFactory extends CpPartsFactory implements CpParts{

    @Override
    public void printName() {
        System.out.println("惠普鼠标 created!");
    }

    @Override
    public CpParts create() {
        return new HpMouseFactory();
    }
}

package com.robin.factoryPattern.factoryMethod;

public class LenovoMouseFactory extends CpPartsFactory implements CpParts{
    @Override
    public void printName() {
        System.out.println("联想鼠标 created!");
    }

    @Override
    public CpParts create() {
        return new LenovoMouseFactory();
    }
}

package com.robin.factoryPattern.factoryMethod;

public class LogitechMouseFactory extends CpPartsFactory implements CpParts{
    @Override
    public void printName() {
        System.out.println("罗技鼠标 created!");
    }

    @Override
    public CpParts create() {
        return new LogitechMouseFactory();
    }
}

客户端测试类：

package com.robin.factoryPattern.factoryMethod;

public class Main {
    public static void main(String[] args) {
        //  工厂模式-工厂方法
        CpPartsFactory cpPartsFactory = new HpMouseFactory();
        cpPartsFactory.create().printName();// 惠普鼠标 created!
    }
}

优缺点

• 优点

  • 工厂方法模式就很好的减轻了工厂类的负担，把某一类/某一种东西交由一个工厂生产；（对应简单工厂的缺点)。
  • 同时增加某一类 ”东西“ 并不需要修改工厂类，只需要添加生产这类 ”东西“ 的工厂即可，使得工厂类符合开闭原则。

• 缺点

  • 对于某些可以形成产品族（一组产品）的情况处理比较复杂。

抽象工厂

抽象工厂：提供一个接口，用于创建相关或依赖的家族，而不需要明确指定具体类。

例子：假设你做了一个大型游戏，里面人物角色的种族属性及世界观都是不同的。比如，普通人类，魔法师，外星物种…

载具抽象类：

package com.robin.factoryPattern.abstractFactory;

// 交通工具的抽象类
public abstract class Vehicle {

    abstract void go();
}

食物抽象类：

package com.robin.factoryPattern.abstractFactory;

// 食物抽象类  抽象类，一个具体的名词真实世界存在且是一个抽象的概念统称
public abstract class Food {
    abstract void printName();
}

武器抽象类：

package com.robin.factoryPattern.abstractFactory;

// 武器抽象类
public abstract class Weapon {
    abstract void wave();
}

抽象工厂类：

package com.robin.factoryPattern.abstractFactory;

// 抽象工厂类  一个【人】的拥有的...
public abstract class AbstractFactory {

    // 抽象方法
    abstract Food getFood();
    abstract Weapon getWeapon();
    abstract Vehicle getVehicle();
}

载具实现类：

package com.robin.factoryPattern.abstractFactory;

public class Car extends Vehicle{
    public void go(){
        System.out.println("[人类]-载具-汽车...");
    }
}

package com.robin.factoryPattern.abstractFactory;

public class Broom extends Vehicle{
    public void go(){
        System.out.println("[魔法师]-载具-魔法扫帚...");
    }
}

食物实现类：

package com.robin.factoryPattern.abstractFactory;

public class Bread extends Food{
    public void printName(){
        System.out.println("[人类]-食物-面包...");
    }
}

package com.robin.factoryPattern.abstractFactory;

public class MushRoom extends Food {
    public void printName(){
        System.out.println("[魔法师]食物-蘑菇");
    }
}

武器实现类：

package com.robin.factoryPattern.abstractFactory;

public class BroadSword extends Weapon{
    public void wave(){
        System.out.println("[人类]挥动大刀...");
    }
}

package com.robin.factoryPattern.abstractFactory;

public class MagicWand extends Weapon{
    public void wave(){
        System.out.println("[魔法师]挥舞着魔法棒....");
    }
}

不同人物种族的区分：

普通地球人：

package com.robin.factoryPattern.abstractFactory;

public class EarthManFactory extends AbstractFactory{
    @Override
    Food getFood() {
        return new Bread();
    }

    @Override
    Weapon getWeapon() {
        return new BroadSword();
    }

    @Override
    Vehicle getVehicle() {
        return new Car();
    }
}

魔法师：

package com.robin.factoryPattern.abstractFactory;

public class MagicManFactory extends AbstractFactory{
    @Override
    Food getFood() {
        return new MushRoom();
    }

    @Override
    Weapon getWeapon() {
        return new MagicWand();
    }

    @Override
    Vehicle getVehicle() {
        return new Broom();
    }
}

Main客户端测试类：

package com.robin.factoryPattern.abstractFactory;

// 充当客户端
public class Main {
    // 一个人类
    public static void main(String[] args) {
        // 通过AbstractFactory 抽象工厂类对不同世界|星球|种族 的人的描述
        AbstractFactory abstractFactory = new MagicManFactory();
        // 这样当我们有不同的设定的种族来时，从抽象工厂继承实现即可，
        // 然后客户端只需要修改 AbstractFactory abstractFactory = new xxxFactory();即可
        Vehicle vehicle = abstractFactory.getVehicle();
        vehicle.go();// [魔法师]-载具-魔法扫帚...
        Weapon weapon = abstractFactory.getWeapon();
        weapon.wave();// [魔法师]挥舞着魔法棒....
        Food food = abstractFactory.getFood();
        food.printName();// [魔法师]食物-蘑菇
    }
}

工厂模式区别

• 简单工厂 ： 使用一个工厂对象用来生产同一等级结构中的任意产品。（不支持拓展增加产品）
• 工厂方法 ： 使用多个工厂对象用来生产同一等级结构中对应的固定产品。（支持拓展增加产品）
• 抽象工厂 ： 使用多个工厂对象用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

---