一、简单工厂模式
简单来说,简单工厂模式有一个具体的工厂类,可以生成多个不同的产品
优点:
工厂类包含必要的逻辑判断,可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责,很方便的创建出相应的产品。工厂和产品的职责区分明确。
客户端无需知道所创建具体产品的类名,只需知道参数即可。
也可以引入配置文件,在不修改客户端代码的情况下更换和添加新的具体产品类。
缺点:
简单工厂模式的工厂类单一,负责所有产品的创建,职责过重,一旦异常,整个系统将受影响。且工厂类代码会非常臃肿,违背高聚合原则。
使用简单工厂模式会增加系统中类的个数(引入新的工厂类),增加系统的复杂度和理解难度
系统扩展困难,一旦增加新产品不得不修改工厂逻辑,在产品类型较多时,可能造成逻辑过于复杂
简单工厂模式使用了 static 工厂方法,造成工厂角色无法形成基于继承的等级结构。
主要角色:
简单工厂(SimpleFactory):是简单工厂模式的核心,负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用,创建所需的产品对象。
抽象产品(Product):是简单工厂创建的所有对象的父类,负责描述所有实例共有的公共接口。
具体产品(ConcreteProduct):是简单工厂模式的创建目标。
示例:
static abstract class Car {
abstract void driver();
}
static class HondaCar extends Car {
@Override
void driver() {
System.out.println("生产本田汽车");
}
}
static class AudiCar extends Car {
@Override
void driver() {
System.out.println("生产奥迪汽车");
}
}
static class SimpleFactory{
public Car getCar(String carName) {
if ("honda".equals(carName)) {
return new HondaCar();
} else if ("audi".equals(carName)) {
return new AudiCar();
} else {
System.out.println("没有该品牌汽车");
return null;
}
}
}
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
HondaCar hondaCar = (HondaCar) simpleFactory.getCar("honda");
if (hondaCar != null) {
hondaCar.driver();
}
AudiCar audiCar = (AudiCar) simpleFactory.getCar("audi");
if (audiCar != null) {
audiCar.driver();
}
}
二、工厂模式
简单来说,工厂模式有多个具体的工厂类,具体的产品由具体的工厂去生产
优点:
用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程。
灵活性增强,对于新产品的创建,只需多写一个相应的工厂类。
典型的解耦框架。高层模块只需要知道产品的抽象类,无须关心其他实现类,满足迪米特法则、依赖倒置原则和里氏替换原则。
缺点:
类的个数容易过多,增加复杂度
增加了系统的抽象性和理解难度
抽象产品只能生产一种产品,此弊端可使用抽象工厂模式解决。
主要角色:
抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。
具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。
示例:
static abstract class Car {
abstract void driver();
}
static class HondaCar extends Car {
@Override
void driver() {
System.out.println("生产本田汽车");
}
}
static class AudiCar extends Car {
@Override
void driver() {
System.out.println("生产奥迪汽车");
}
}
static abstract class Factory {
public abstract Car getCar();
}
static class HondaFactory extends Factory {
@Override
public Car getCar() {
return new HondaCar();
}
}
static class AudiFactory extends Factory {
@Override
public Car getCar() {
return new AudiCar();
}
}
public static void main(String[] args) {
HondaFactory hondaFactory = new HondaFactory();
hondaFactory.getCar().driver();
AudiFactory audiFactory = new AudiFactory();
audiFactory.getCar().driver();
}
三、抽象工厂模式
抽象工厂模式是工厂方法模式的升级版本,工厂方法模式只生产一个等级的产品,而抽象工厂模式可生产多个等级的产品
主要角色
抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法 newProduct(),可以创建多个不同等级的产品。
具体工厂(Concrete Factory):主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。
抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。
具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间是多对一的关系。
示例:
static abstract class Car {
abstract void driver();
}
static class HondaCar extends Car {
@Override
void driver() {
System.out.println("生产本田汽车");
}
}
static class AudiCar extends Car {
@Override
void driver() {
System.out.println("生产奥迪汽车");
}
}
static abstract class motuo {
abstract void motuoDriver();
}
static class HondaMotuo extends motuo {
@Override
void motuoDriver() {
System.out.println("生产本田摩托车");
}
}
static class AudiMotuo extends motuo {
@Override
void motuoDriver() {
System.out.println("生产奥迪摩托车");
}
}
static abstract class Factory {
public abstract Car getCar();
public abstract motuo getMotuo();
}
static class HondaFactory extends Factory {
@Override
public Car getCar() {
return new HondaCar();
}
@Override
public motuo getMotuo() {
return new HondaMotuo();
}
}
static class AudiFactory extends Factory {
@Override
public Car getCar() {
return new AudiCar();
}
@Override
public motuo getMotuo() {
return new AudiMotuo();
}
}
public static void main(String[] args) {
HondaFactory hondaFactory = new HondaFactory();
hondaFactory.getCar().driver();
hondaFactory.getMotuo().motuoDriver();
AudiFactory audiFactory = new AudiFactory();
audiFactory.getCar().driver();
audiFactory.getMotuo().motuoDriver();
}