讲解三种工厂模式，并比较各自优缺点
简单工厂
/**
* @author Gjing
* 抽象产品
**/
interface Product {
void create();
}
/**
* 产品A
*/
class ProductA implements Product {
@Override
public void create() {
System.out.println("产品A");
}
}
/**
* 产品B
*/
class ProductB implements Product {
@Override
public void create() {
System.out.println("产品B");
}
}
/**
* 产品工厂
*/
class ProductFactory {
Product getProduct(Integer type) {
switch (type) {
case 1:
return new ProductA();
case 2:
return new ProductB();
default:
throw new NullPointerException("没有你要的产品");
}
}
}
调用：
/**
* @author Gjing
**/
public class Test {
public static void main(String[] args) {
ProductFactory factory = new ProductFactory();
Product productA = factory.getProduct(1);
productA.create();
Product productB = factory.getProduct(2);
productB.create();
}
}
工厂模式
- 工厂
/**
* @author Gjing
* 抽象工厂
**/
public interface Factory {
/**
* 生产产品
* @return Product
*/
Product create();
}
/**
* @author Gjing
* 创建产品A 的工厂A
**/
class FactoryA implements Factory {
@Override
public Product create() {
return new ProductA();
}
}
/**
* @author Gjing
* 工厂B负责创建产品B
**/
class FactoryB implements Factory {
@Override
public Product create() {
return new ProductB();
}
}
- 产品
/**
* @author Gjing
* 抽象产品
**/
interface Product {
void create();
}
/**
* 产品A
*/
class ProductA implements Product {
@Override
public void create() {
System.out.println("产品A");
}
}
/**
* 产品B
*/
class ProductB implements Product {
@Override
public void create() {
System.out.println("产品B");
}
}
调用
public class Test {
public static void main(String[] args) {
FactoryA factoryA = new FactoryA();
factoryA.create().create();
FactoryB factoryB = new FactoryB();
factoryB.create().create();
}
}
抽象工厂模式
- 工厂
/**
* @author Gjing
**/
public interface Factory {
Product getProductA();
Product getProductB();
}
class FactoryA implements Factory {
@Override
public Product getProductA() {
return new ProductAa();
}
@Override
public Product getProductB() {
return new ProductBb();
}
}
- 产品
/**
* @author Gjing
* 抽象产品
**/
abstract class Product {
abstract void create();
}
/**
* 抽象产品A
*/
abstract class ProductA extends Product {
@Override
abstract void create();
}
/**
* 抽象产品A的具体某个产品
*/
class ProductAa extends ProductA {
@Override
void create() {
System.out.println("产品A");
}
}
/**
* 抽象产品B
*/
abstract class ProductB extends Product {
@Override
abstract void create();
}
/**
* 抽象产品B的具体某个产品
*/
class ProductBb extends ProductB {
@Override
void create() {
System.out.println("产品B");
}
}
调用
public class Test {
public static void main(String[] args) {
Factory factory = new FactoryA();
factory.getProductA().create();
factory.getProductB().create();
}
}
以上为三种不同工厂模式，他们各自的优缺点是啥？
- 简单工厂
优点：将创建使用工作分开，不必关心类对象如何创建，实现了解耦；
缺点：违背“开放 - 关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂。
- 工厂模式
a. 优点:
1. 符合开-闭原则：新增一种产品时，只需要增加相应的具体产品类和相应的工厂子类即可
2. 符合单一职责原则：每个具体工厂类只负责创建对应的产品
b. 缺点：
1. 增加了系统的复杂度：类的个数将成对增加
2. 增加了系统的抽象性和理解难度
3. 一个具体工厂只能创建一种具体产品
- 抽象工厂
优点：
1.降低耦合
2.符合开-闭原则
3.符合单一职责原则
4.不使用静态工厂方法，可以形成基于继承的等级结构。
缺点：难以扩展新种类产品
总结
- 角色不同
- 简单工厂：具体工厂、抽象产品、具体产品
- 工厂方法：抽象工厂、具体工厂、抽象产品、具体产品
- 抽象工厂：抽象工厂、具体工厂、抽象产品族、抽象产品、具体产品
- 定义
- 简单工厂：由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（继承自一个父类或接口）的实例。
- 工厂方法：定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象
- 抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类；具体的工厂负责实现具体的产品实例。
- 对比
- 工厂方法模式解决了简单工厂模式的“开放 - 关闭原则
- 抽象工厂模式解决了工厂方法模式一个具体工厂只能创建一类产品
以上为个人理解，如理解有误欢迎各位指正
