概念

定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

格式

abstract class Product {

}

class ProductA : Product() {}
class ProductB : Product() {}

object Factory {
    fun createProduct(requirement :String) : Product {
           // 判断逻辑
           return product
        }
    }
}

fun main() {
    val product = Factory.createProduct(arg)
}

Kotiln示例

想象有一个工厂(Factory),能够生产产品U盘(Product),U盘有很多种它们的功能都一样(show),但分为不同的接口版本(version)和速度(speed)
这个电子厂不是任意的U盘都能生产,它只能生产2Gbps+"3.1 Gen 1"的 型号A(ProductA) 和16 Gbps+"3.2 Gen 2x2"的 型号B(ProductB)

自底向上的看,首先我们需要一个产品类(Product),它不是具体的类(不是什么样的U盘都能得到)
其次,我们要给出具体的能生产出来的产品型号(ProductA,ProductB)
最后,我们需要一个工厂,这个工厂当然只有一个(单例),他根据输入的内容返回不同的产品型号

abstract class Product {
    abstract val version :String
    abstract val speed :String
    fun show() {
        println("this is product $version , speed = $speed")
    }
}

class ProductA : Product() {
    override val version :String = "3.1 Gen 1"
    override val speed :String = "2 Gbps"
}

class ProductB : Product() {
    override val version :String = "3.2 Gen 2x2"
    override val speed :String = "16 Gbps"
}

object Factory {
    fun createProduct(requirement :String) : Product {
        return when(requirement) {
            "typeA" -> ProductA()
            "typeB" -> ProductB()
            else -> { throw IllegalArgumentException() }
        }
    }
}

fun main() {
    val product = Factory.createProduct("typeA")
    product.show()
    val product2 = Factory.createProduct("typeB")
    product2.show()
}

C++实现

#include <iostream>

using namespace std;

enum class ProductTypes
{
	TYPE_A,
	TYPE_B
};

class Product 
{
	public:
		int prop;
		void show()
		{
			cout << "This is product gen " << prop << endl;
		}
};

class ProductA : public Product
{
	public:
		ProductA() 
		{
			prop = 2;
		}
};

class ProductB : public Product
{
	public:
		ProductB() 
		{
			prop = 3;
		}
};

class Factory 
{
	public:
		static Product createProduct(ProductTypes type)
		{
			switch (type) {
				case ProductTypes::TYPE_A:
					return ProductA();
				case ProductTypes::TYPE_B:
					return ProductB();
			}
		}
		
};

int main()
{
	Product product  = Factory::createProduct(ProductTypes::TYPE_A);
	product.show();
	Product product2 = Factory::createProduct(ProductTypes::TYPE_B);
	product2.show();
	return 0;
}