需要注意的是,虽然工厂模式可以提高代码的灵活性和可维护性,但是如果工厂的创建过程非常复杂,可能会影响系统的性能。此时需要权衡设计的复杂度和系统的性能要求,选择合适的创建方式。
Java 有几种常见的工厂模式:
简单工厂模式(Simple Factory Pattern)又称为静态工厂方法模式
在 Java 中,简单工厂模式的实现一般包括以下几个角色:
- 工厂类(Factory):负责创建具体产品的对象,提供一个静态方法来创建对象。通常情况下,工厂类会根据客户端的请求创建不同的具体产品对象。
- 抽象产品类(Product):定义了具体产品类的共同属性和行为。
- 具体产品类(Concrete Product):实现抽象产品类定义的属性和行为。
// 抽象产品类
public abstract class Product {
abstract void use();
}
// 具体产品类 A
public class ProductA extends Product{
@Override
void use() {
System.out.println("productA is used");
}
}
// 具体产品类 B
public class ProductB extends Product{
@Override
void use() {
System.out.println("productB is used");
}
}
// 工厂类
public class Factory {
public static Product createProduct(String type){
Product product = null;
switch (type){
case "A":
product= new ProductA();
break;
case "B":
product= new ProductB();
break;
default:
break;
}
return product;
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
Product productA = Factory.createProduct("A");
productA.use(); // Output: ProductA is used
Product productB = Factory.createProduct("B");
productB.use(); // Output: ProductB is used
}
}
简单工厂模式的优点是能够将对象的创建和使用分离,使得客户端不需要知道具体产品的类名,降低了客户端和具体产品的耦合度。同时,工厂类可以通过封装对象的创建过程来实现对对象的统一管理,提高代码的可维护性和可读性。缺点是如果需要新增产品,需要修改工厂类的代码,不符合开闭原则。此外,工厂类的静态方法可能会变得过于臃肿,难以维护。
是一种写代码的习惯,不属于23种设计模式中的一种。
工厂方法模式(Factory Method Pattern)
在 Java 中,工厂方法模式的实现一般包括以下几个角色:
- 抽象产品类(Product):定义了具体产品类的共同属性和行为。
- 具体产品类(Concrete Product):实现抽象产品类定义的属性和行为。
- 抽象工厂类(Factory):负责定义创建抽象产品。
- 具体工厂类(Concrete Factory):继承抽象工厂重写了创建产品方法,负责创建一种具体产品对象。
// 抽象产品类
public abstract class Product {
abstract void use();
}
// 具体产品类 A
public class ProductA extends Product{
@Override
void use() {
System.out.println("productA is used");
}
}
// 具体产品类 B
public class ProductB extends Product{
@Override
void use() {
System.out.println("productB is used");
}
}
// 抽象工厂类
public abstract class AbstractFactory {
abstract Product createProduct();
}
// 具体工厂类 A
public class AFactory extends AbstractFactory{
@Override
Product createProduct() {
return new ProductA();
}
}
// 具体工厂类 B
public class BFactory extends AbstractFactory{
@Override
Product createProduct() {
return new ProductB();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
AbstractFactory aFactory = new AFactory();
Product productA = aFactory.createProduct();
productA.use(); //Output: Product A is used
AbstractFactory bFactory = new BFactory();
Product productB = bFactory.createProduct();
productB.use(); //Output: Product B is used
}
}
客户端代码只需要创建具体工厂对象,并调用具体工厂对象的 createProduct()
方法来创建具体产品对象,而不需要知道具体产品的类名。这样可以实现客户端和具体产品的解耦,并且通过定义抽象工厂类,可以方便地添加新的产品类型,符合开闭原则。
适合用于产品族的创建(一维)
抽象工厂模式(Abstract Factory Pattern)
在 Java 中,抽象工厂模式的实现一般包括以下几个角色:
- 抽象工厂类(Abstract Factory):定义了一组用于创建一系列产品对象的方法,这些方法返回抽象产品类型的对象。
- 具体工厂类(Concrete Factory):实现抽象工厂类定义的一组用于创建一系列产品对象的方法,每个方法返回具体产品类型的对象。
- 抽象产品类(Abstract Product):抽象产品类中的方法通常是抽象的。
- 具体产品类(Concrete Product):每个具体产品类对应一个具体工厂类。
// 抽象产品 A
public abstract class ProductA {
abstract void use();
}
// 具体产品 A1
public class ProductA1 extends ProductA{
@Override
void use() {
System.out.println("productA1 is used");
}
}
// 具体产品 A2
public class ProductA2 extends ProductA{
@Override
void use() {
System.out.println("productA2 is used");
}
}
// 抽象产品 B
public abstract class ProductB {
abstract void consume();
}
// 具体产品 B1
public class ProductB1 extends ProductB{
@Override
void consume() {
System.out.println("ProductB1 is consumed");
}
}
// 具体产品 B2
public class ProductB2 extends ProductB{
@Override
void consume() {
System.out.println("ProductB2 is consumed");
}
}
// 抽象工厂类
public abstract class AbstractFactory {
abstract ProductA createProductA();
abstract ProductB createProuductB();
}
// 具体工厂类 1
public class ConcreteFactory1 extends AbstractFactory{
@Override
ProductA createProductA() {
return new ProductA1();
}
@Override
ProductB createProuductB() {
return new ProductB1();
}
}
// 具体工厂类 2
public class ConcreteFactory2 extends AbstractFactory{
@Override
ProductA createProductA() {
return new ProductA2();
}
@Override
ProductB createProuductB() {
return new ProductB2();
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
AbstractFactory concreteFactory1 = new ConcreteFactory1();
ProductA productA = concreteFactory1.createProductA();
productA.use(); //Output: productA1 is used
ProductB prouductB = concreteFactory1.createProuductB();
prouductB.consume(); //Output: ProductB1 is consumed
AbstractFactory concreteFactory2 = new ConcreteFactory2();
ProductA productA2 = concreteFactory2.createProductA();
productA2.use(); //Output: productA2 is used
ProductB prouductB2 = concreteFactory2.createProuductB();
prouductB2.consume(); //Output: productB2 is consumed
}
}
适合用于产品族的创建和扩展(二维)
工厂模式可以提高代码的可维护性、可扩展性和灵活性,而且能够隐藏对象的创建过程,降低客户端对于具体产品的依赖。因此,工厂模式是一种非常常用的设计模式。