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

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

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

简单工厂

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

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

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

接口：

package com.robin.factoryPattern.simpleFactory;public interface Moveable {void RunRoad();
}

品牌汽车类：

比亚迪：

package com.robin.factoryPattern.simpleFactory;// 比亚迪
public class BydCar implements Moveable {@Overridepublic void RunRoad() {System.out.println("[比亚迪]:一路同驰骋");}
}

法拉利：

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

五菱宏光：

package com.robin.factoryPattern.simpleFactory;// 五菱汽车
public class WuLingCar implements Moveable {@Overridepublic 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{@Overridepublic void printName() {System.out.println("惠普鼠标 created!");}@Overridepublic CpParts create() {return new HpMouseFactory();}
}

package com.robin.factoryPattern.factoryMethod;public class LenovoMouseFactory extends CpPartsFactory implements CpParts{@Overridepublic void printName() {System.out.println("联想鼠标 created!");}@Overridepublic CpParts create() {return new LenovoMouseFactory();}
}

package com.robin.factoryPattern.factoryMethod;public class LogitechMouseFactory extends CpPartsFactory implements CpParts{@Overridepublic void printName() {System.out.println("罗技鼠标 created!");}@Overridepublic 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{@OverrideFood getFood() {return new Bread();}@OverrideWeapon getWeapon() {return new BroadSword();}@OverrideVehicle getVehicle() {return new Car();}
}

魔法师：

package com.robin.factoryPattern.abstractFactory;public class MagicManFactory extends AbstractFactory{@OverrideFood getFood() {return new MushRoom();}@OverrideWeapon getWeapon() {return new MagicWand();}@OverrideVehicle 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();// [魔法师]食物-蘑菇}
}

工厂模式区别

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