抽象工厂和工厂方法模式都是创建型设计模式，解决了不同场景下的对象创建问题。
根据 GOF工厂方法 pattern
定义一个用于创建对象的接口，但让子类决定实例化哪个类。工厂方法让类将实例化推迟到子类。
我的理解 ：动机Client是获取执行的工厂基类中存在的方法，该方法依赖于现在未知其具体类的对象（在这种情况下，要么在向客户端提供软件期间，要么将其定义，要么将是客户自己编写具体的实现，最有可能在框架的情况下）。为未知（或可能更改）的产品提供一个抽象类型：IProduct，并设置一个约定，将来任何产品的实现都必须实现此接口。
I产品界面
package com.companyx;
public interface IProduct {
public void serve();
}
带有需要执行的“方法”的工厂类
package com.companyx;
public abstract class Factory {
public abstract IProduct createProduct();
private void performCriticalJob(){
IProduct product = createProduct();
product.serve();
}
public void executeJob(){
//some code
performCriticalJob();
//some more code
}
}
一些具体产品
package com.companyx;
class AppAProductFeatureX implements IProduct{
@Override
public void serve() {
//some code
}
}
混凝土制品厂
package com.companyx;
public class AppAFeatureXProductFactory extends Factory{
@Override
public IProduct createProduct() {
return new AppAProductFeatureX();
}
}
客户端代码
package com.clientcompany;
import com.companyx.AppAFeatureXProductFactory;
import com.companyx.Factory;
public class Client {
public static void main(String[] args) {
Factory fact = new AppAFeatureXProductFactory();
fact.executeJob();
}
}
根据 GOF抽象工厂 pattern
提供一个接口，用于创建相关或依赖对象系列，而无需指定它们的具体类。
我的理解
The client对产品感兴趣，这里这种模式有助于通过将具体产品类隐藏在工厂类后面来提供产品。
客户想要的产品类型
package com.companyb;
public interface IProductA {
public void performAJob();
}
产品实施
package com.companyb;
//can be named better, but lets go with this name for this time
public class ProductAVersion1 implements IProductA{
@Override
public void performAJob() {
// some code
}
}
工厂界面,（也可以是抽象类）
package com.companyb;
public interface IFactory {
public IProductA createProduct();
}
Factory创建ProductS的具体实现
包 com.company；
public class FactoryA implements IFactory{
@Override
public IProductA createProduct() {
return new ProductAVersion1(); // concrete class of product is hidden
}
}
客户端代码
package com.clientcompany.productprovider;
import com.companyb.IFactory;
import com.companyb.IProductA;
public class SomeClientClass {
private IFactory factory;
private IProductA product;
public void doSomeJobWithProductA() {
// some code
product.performAJob();
//someCode();
}
public void setFactory(IFactory factory) {
this.factory = factory;
this.product = factory.createProduct();
}
}
package com.clientcompany.productprovider;
import com.companyb.FactoryA;
public class SomeOtherClientCode {
public static void main(String[] args) {
SomeClientClass someClientClass = new SomeClientClass();
someClientClass.setFactory(new FactoryA());
someClientClass.doSomeJobWithProductA();
}
}
Q1：抽象工厂模式中相关产品系列是否是必要的，如果只有一种产品（如上）存在各种子类型但没有各种相关类型，那么这种模式是否仍然相关？
Q2我上面的理解正确吗？
Q3以上给我带来了另一个疑问：工厂方法是否更适合框架（客户端可以给出产品的实现），就像模板方法模式一样，工厂调用createProduct()具体实现形式是用户提供的Concrete Factory实现？
同样，抽象工厂是否更适合库开发，其中具体的产品类（可能会有所不同）隐藏在更稳定的工厂类后面？
