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