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