广东seo课程seo软件工具

本节主要介绍设计模式中的工厂方法模式。

简介：

工厂方法模式，它是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
它定义了一个用于创建对象的工厂接口，让子类决定实例化哪个类。在工厂方法模式中，父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。这种模式将类实例化操作延迟到子类中完成，即由子类来决定究竟应该实例化哪个类。

工厂方法模式的创建步骤如下：
1、创建抽象工厂类，定义具体工厂的公共接口。
2、创建抽象产品类，定义具体产品的公共接口。
3、创建具体产品类，继承抽象产品类并定义具体产品的生产。
4、创建具体工厂类，继承抽象工厂类并定义创建对应具体产品实例的方法。
5、外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例。

工厂方法模式的优点，主要包括：
1、增加新的产品类时无需修改现有系统：当需要增加一个新的产品时，只需要创建一个新的具体工厂和具体产品类，符合“开放-封闭”原则，增加了系统的灵活性和可扩展性。
2、封装了产品对象的创建细节：客户端只需要使用具体工厂类创建产品对象，无需关心对象是如何被创建的，这样就可以将产品对象的创建细节封装在具体工厂类中。
3、系统具有良好的灵活性和可扩展性：通过使用工厂方法模式，可以在不改变现有客户端代码的情况下，增加或修改产品类和工厂类，具有较强的灵活性。

工厂方法模式的缺点，主要包括：
1、增加额外的编写工作量：在增加新产品时，需要编写新的具体产品类和对应的具体工厂类，增加了系统的复杂度，需要更多的类需要编译和运行，给系统带来一些额外的开销。
2、需要考虑系统的抽象性和理解难度：为了增加系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

​​​​​​​

示例

一、C#工厂方法模式

以下是一个示例，展示了如何在C#中实现工厂方法模式：

// 产品的抽象类  
public abstract class Product  
{  public abstract void Use();  
}  // 具体产品类1  
public class ConcreteProduct1 : Product  
{  public override void Use()  {  Console.WriteLine("使用具体产品1");  }  
}  // 具体产品类2  
public class ConcreteProduct2 : Product  
{  public override void Use()  {  Console.WriteLine("使用具体产品2");  }  
}  // 工厂的抽象类  
public abstract class Creator  
{  // 工厂方法，由子类实现具体的创建逻辑  public abstract Product CreateProduct();  
}  // 具体工厂类1  
public class ConcreteCreator1 : Creator  
{  public override Product CreateProduct()  {  return new ConcreteProduct1();  }  
}  // 具体工厂类2  
public class ConcreteCreator2 : Creator  
{  public override Product CreateProduct()  {  return new ConcreteProduct2();  }  
}  class Program  
{  static void Main(string[] args)  {  Creator creator1 = new ConcreteCreator1(); Product product1 = creator1.CreateProduct();   product1.Use();  Creator creator2 = new ConcreteCreator2  Product product2 = creator2.CreateProduct(); product2.Use();  }  
}

二、java工厂方法模式

以下是一个示例，展示了如何在Java中实现工厂方法模式：

// 抽象产品类  
public abstract class Product {  public abstract void use();  
}  // 具体产品类1  
public class ConcreteProduct1 extends Product {  @Override  public void use() {  System.out.println("使用具体产品1");  }  
}  // 具体产品类2  
public class ConcreteProduct2 extends Product {  @Override  public void use() {  System.out.println("使用具体产品2");  }  
}  // 抽象工厂类  
public abstract class Factory {  // 工厂方法，由子类实现具体的创建逻辑  public abstract Product createProduct();  
}  // 具体工厂类1  
public class ConcreteFactory1 extends Factory {  @Override  public Product createProduct() {  return new ConcreteProduct1();  }  
}  // 具体工厂类2  
public class ConcreteFactory2 extends Factory {  @Override  public Product createProduct() {  return new ConcreteProduct2();  }  
}  // Client代码  
public class Client {  public static void main(String[] args) {  Factory factory = new ConcreteFactory1(); // 可以根据实际需要更换为ConcreteFactory2  Product product = factory.createProduct();  product.use();  }  
}

三、javascript工厂方法模式

在JavaScript中，工厂方法模式通常可以通过构造函数和对象字面量的组合来实现。

// 抽象产品类  
class Product {  // 抽象方法  use() {  throw new Error('Use abstract method "use"');  }  
}  // 具体产品类1  
class ConcreteProduct1 extends Product {  use() {  console.log('使用具体产品1');  }  
}  // 具体产品类2  
class ConcreteProduct2 extends Product {  use() {  console.log('使用具体产品2');  }  
}  // 抽象工厂类  
class Factory {  // 工厂方法，由子类实现具体的创建逻辑  createProduct() {  throw new Error('Use abstract method "createProduct"');  }  
}  // 具体工厂类1  
class ConcreteFactory1 extends Factory {  createProduct() {  return new ConcreteProduct1();  }  
}  // 具体工厂类2  
class ConcreteFactory2 extends Factory {  createProduct() {  return new ConcreteProduct2();  }  
}  // Client代码  
class Client {  constructor(factory) {  this.factory = factory;  }  useProduct() {  let product = this.factory.createProduct();  product.use();  }  
}  // 使用Client类和ConcreteFactory1实例化一个新的Client对象并使用产品  
let client1 = new Client(new ConcreteFactory1());  
client1.useProduct();

四、C++工厂方法模式

以下是在C++中实现工厂方法模式：

//定义一个抽象产品类，它包含产品对象的公共接口。
class Product {  
public:  virtual void use() = 0; // 纯虚函数，具体实现由子类来决定  
};
//创建具体产品类，它们扩展了抽象产品类并实现了产品的具体行为。
class ConcreteProduct1 : public Product {  
public:  void use() override {  // 具体实现逻辑  std::cout << "使用具体产品1" << std::endl;  }  
};  class ConcreteProduct2 : public Product {  
public:  void use() override {  // 具体实现逻辑  std::cout << "使用具体产品2" << std::endl;  }  
};
//定义一个抽象工厂类，它包含一个工厂方法用于创建产品对象。这个方法是纯虚函数，具体实现由子类来决定。
class Factory {  
public:  virtual Product* createProduct() = 0; // 纯虚函数，具体实现由子类来决定  
};
//创建具体工厂类，它们扩展了抽象工厂类并实现了工厂方法的特定实现，以创建特定类型的产品对象。
class ConcreteFactory1 : public Factory {  
public:  Product* createProduct() override {  return new ConcreteProduct1();  }  
};  class ConcreteFactory2 : public Factory {  
public:  Product* createProduct() override {  return new ConcreteProduct2();  }  
};
//最后，在客户端代码中使用工厂方法模式来创建产品对象。客户端通过调用工厂对象的 createProduct 方法来创建产品对象，而不需要直接了解如何创建这些对象。这样可以提高客户端代码的灵活性和可维护性。
int main() {  Factory* factory = new ConcreteFactory1(); // 创建具体工厂对象  Product* product = factory->createProduct(); // 创建具体产品对象  product->use(); // 使用具体产品对象  delete factory; // 释放工厂对象内存  delete product; // 释放产品对象内存  return 0;  
}

五、python工厂方法模式

以下是在python中实现工厂方法模式：

from abc import ABCMeta, abstractmethod  # 抽象产品类  
class Product(metaclass=ABCMeta):  @abstractmethod  def operation(self):  pass  # 具体产品类1  
class ConcreteProduct1(Product):  def operation(self):  print("具体产品1被使用了")  # 具体产品类2  
class ConcreteProduct2(Product):  def operation(self):  print("具体产品2被使用了")  # 抽象工厂类  
class Factory(metaclass=ABCMeta):  @abstractmethod  def create_product(self):  pass  # 具体工厂类1  
class ConcreteFactory1(Factory):  def create_product(self):  return ConcreteProduct1()  # 具体工厂类2  
class ConcreteFactory2(Factory):  def create_product(self):  return ConcreteProduct2()  # Client代码  
if __name__ == "__main__":  factory1 = ConcreteFactory1()  product1 = factory1.create_product()  product1.operation()  factory2 = ConcreteFactory2()  product2 = factory2.create_product()  product2.operation()

    

六、go工厂方法模式

以下是一个示例，展示了如何在go中实现工厂方法模式：

//首先定义一个产品接口，该接口定义了产品的通用方法：
type Product interface {  Use()  
}
//然后，定义两个具体产品结构体，并实现Product接口的方法：
type ConcreteProduct1 struct{}  func (p *ConcreteProduct1) Use() {  fmt.Println("使用具体产品1")  
}  type ConcreteProduct2 struct{}  func (p *ConcreteProduct2) Use() {  fmt.Println("使用具体产品2")  
}
//接下来，定义一个工厂接口，该接口定义了一个创建产品的 方法：
type Factory interface {  CreateProduct() Product  
}
//然后，定义两个具体工厂结构体，并实现Factory接口的方法：
type ConcreteFactory1 struct{}  func (f *ConcreteFactory1) CreateProduct() Product {  return &ConcreteProduct1{}  
}  type ConcreteFactory2 struct{}  func (f *ConcreteFactory2) CreateProduct() Product {  return &ConcreteProduct2{}  
}
//最后，在客户端代码中，根据需要选择具体的工厂结构体实例化，然后使用该工厂结构体创建并使用产品：
func main() {  factory1 := &ConcreteFactory1{}  product1 := factory1.CreateProduct()  product1.Use()  factory2 := &ConcreteFactory2{}  product2 := factory2.CreateProduct()  product2.Use()  
}

七、PHP工厂方法模式

以下是一个示例，展示了如何在PHP中实现工厂方法模式：

//定义一个抽象产品接口（Abstract Product）：
interface Product {  public function operation();  
}
//创建具体产品类实现抽象产品接口：
class ConcreteProduct1 implements Product {  public function operation() {  echo "具体产品1被使用了";  }  
}  class ConcreteProduct2 implements Product {  public function operation() {  echo "具体产品2被使用了";  }  
}
//定义一个抽象工厂类：
abstract class Creator {  abstract public function factoryMethod(): Product;  
}
//创建具体工厂类继承抽象工厂类：
class ConcreteCreator1 extends Creator {  public function factoryMethod() {  return new ConcreteProduct1();  }  
}  class ConcreteCreator2 extends Creator {  public function factoryMethod() {  return new ConcreteProduct2();  }  
}
//在客户端代码中，根据需要选择具体的工厂类实例化，并使用该工厂类创建并使用产品：
$creator1 = new ConcreteCreator1();  
$product1 = $creator1->factoryMethod();  
$product1->operation(); // 输出：具体产品1被使用了  $creator2 = new ConcreteCreator2();  
$product2 = $creator2->factoryMethod();  
$product2->operation(); // 输出：具体产品2被使用了

《完结》