工厂模式
简单工厂模式概述
工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。工厂模式属于创建型模式,它提供了一种创建对象的广泛方式。
在工厂模式中,我们可以根据参数的不同返回不同类的实例;简单工厂专门定义了一个类来负责创建其他类的实例,被创建的类通常都具有共同的父类。
面向对象基本设计原则
在理解工厂模式之前,我们先了解下面向对象基本设计原则,了解这些设计原则有助于我们更好地理解设计模式。
-
单一职责原则(Single Responsibility Principle):类的职责功能要单一,不能将太多的职责放在同一个类中。
-
开闭原则(Open-Closed principle):对拓展开放,对修改关闭。
-
里氏替换原则(Liskov-Substituion Principle):子类必须能够替换其基类,以保证继承复用的基础。
-
依赖倒置原则(Dependecy-Inversion
Principle):依赖于抽象。具体而言就是高层模块不依赖于底层模块,二者都同依赖于抽象;抽象不依赖于具体,具体依赖于抽象。 -
接口隔离原则(Interface-Segregation Principle):使用多个小的专门的接口,而不要使用一个大的总接口。
-
合成复用原则:在系统中应该尽量多使用组合和聚合关联关系,尽量少使用甚至不使用继承关系。
-
迪米特法则:一个软件实体对其他实体的引用越少越好,或者说如果两个类不必彼此直接通信,那么这两个类就不应当发生直接的相互作用,而是通过引入一个第三者发生间接交互。
简单工厂模式的结构
-
Factory(工厂)
核心部分,负责实现创建所有产品的内部逻辑,工厂类可以被外界直接调用,创建所需对象。
-
Product(抽象类产品):
工厂类所创建的所有对象的父类,封装了产品对象的公共方法,所有的具体产品为其子类对象。
-
ConcreteProduct(具体产品):
简单工厂模式的创建目标,所有被创建的对象都是某个具体类的实例。它要实现抽象产品中声明的抽象方法。
简单工厂模式的实现
interface Product {
void create();
}
static class ProductA implements Product {
@Override
public void create() {
System.out.println("创造了 ProductA");
}
}
static class ProductB implements Product {
@Override
public void create() {
System.out.println("创造了 ProductB");
}
}
// 新增ProductC
static class ProductC implements Product {
@Override
public void create() {
System.out.println("创造了 ProductC");
}
}
static class ProductFactory {
public Product manageProduct(String productType) {
switch (productType) {
case "ProductA":
return new ProductA();
case "ProductB":
return new ProductB();
// 新增ProductC
case "ProductC":
return new ProductC();
default:
throw new IllegalStateException("unexpected value:" + productType);
}
}
}
// 简单工厂模式
static class ProductFactoryClient{
public static void main(String[] args) {
ProductFactory factory = new ProductFactory();
Product productA = factory.manageProduct("ProductA");
productA.create();
Product productB = factory.manageProduct("ProductB");
productB.create();
Product productC = factory.manageProduct("ProductC");
productC.create();
}
}
通过分析,我们发现,如果我需要创建ProductC,需要创建一个ProductC类,并且在核心工厂类中还必须增加判断。很明显不符合里氏替换原则(对拓展开放,对修改关闭),因此,我们需要优化简单工厂模式。
简单工厂模式->工厂模式
实际上,在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
话不多说,直接上代码
public class FactoryMode {
interface Product {
void create();
}
static class ProductA implements Product {
@Override
public void create() {
System.out.println("创造了 ProductA");
}
}
static class ProductB implements Product {
@Override
public void create() {
System.out.println("创造了 ProductB");
}
}
// 新增ProductC
static class ProductC implements Product {
@Override
public void create() {
System.out.println("创造了 ProductC");
}
}
interface ProductFactory {
Product manageProduct();
}
static class ProductAFactory implements ProductFactory {
@Override
public Product manageProduct() {
return new ProductA();
}
}
static class ProductBFactory implements ProductFactory {
@Override
public Product manageProduct() {
return new ProductB();
}
}
// 新增ProductC的处理
static class ProductCFactory implements ProductFactory {
@Override
public Product manageProduct() {
return new ProductC();
}
}
// 简单工厂模式
static class ProductFactoryClient {
public static void main(String[] args) {
Product productA = new ProductAFactory().manageProduct();
productA.create();
Product productB = new ProductBFactory().manageProduct();
productB.create();
Product productC = new ProductCFactory().manageProduct();
productC.create();
}
}
}
通过对比分析,我们发现优化后,无需修改ProductFactory工厂类内部逻辑,只需要新增ProductCFactory 类实现ProductFactory 接口即可。