工厂模式 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();// [魔法师]食物-蘑菇
}
}
工厂模式区别
- 简单工厂 ： 使用一个工厂对象用来生产同一等级结构中的任意产品。（不支持拓展增加产品）
- 工厂方法 ： 使用多个工厂对象用来生产同一等级结构中对应的固定产品。（支持拓展增加产品）
- 抽象工厂 ： 使用多个工厂对象用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）
