芜湖有哪些招聘网站,小程序需要租服务器吗,大连网站建设外贸,网站内部优化是什么本节主要介绍设计模式中的工厂方法模式。
简介#xff1a;
工厂方法模式#xff0c;它是对简单工厂模式的进一步抽象化#xff0c;其好处是可以使系统在不修改原来代码的情况下引进新的产品#xff0c;即满足开闭原则。 它定义了一个用于创建对象的工厂接口#xff0c;让…本节主要介绍设计模式中的工厂方法模式。
简介
工厂方法模式它是对简单工厂模式的进一步抽象化其好处是可以使系统在不修改原来代码的情况下引进新的产品即满足开闭原则。 它定义了一个用于创建对象的工厂接口让子类决定实例化哪个类。在工厂方法模式中父类负责定义创建对象的公共接口而子类则负责生成具体的对象。这种模式将类实例化操作延迟到子类中完成即由子类来决定究竟应该实例化哪个类。
工厂方法模式的创建步骤如下 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(metaclassABCMeta): 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(metaclassABCMeta): 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被使用了
《完结》
