乐趣区

关于设计模式:设计模式之工厂模式

jiezi

工厂模式能够细分为：简略工厂、工厂办法和形象工厂三种模式

应用场景

总体而言工厂模式的应用场景分为两种：

  1. 单个对象的创立过程比较复杂，如须要做简单初始化操作的对象
  2. 须要依据不同的类型创立不同的对象

针对细分的三种模式，应用场景又能够辨别：

  1. 当 对象的创立逻辑简略 ，通常只须要 new 一下就能够，此时能够思考 简略工厂模式
  2. 当 对象的创立逻辑很简单 ，须要做各种初始化操作，此时能够思考应用 工厂办法模式，将对象创立的简单逻辑拆分到各个工厂类中，让每个工厂类都不至于过于简单
  3. 当 零碎中有多于一个产品族 ，而每次只应用其中某一产品族，此时应用 形象工厂模式

简略工厂模式

类图

ProcuctA 和 ProductB 继承 Product 抽象类，ProductFactory 依据传入的 type 来返回不同的 Product 实例

代码实现

Product

public abstract class Product {public abstract void use();
}

ProductA

public class ProductA extends Product {
    @Override
    public void use() {System.out.println("You are using ProductA...");
    }
}

ProductB

public class ProductB extends Product {
    @Override
    public void use() {System.out.println("You are using ProductB...");
    }
}

ProductFactory

public class ProductFactory {public Product createProduct(String type) {
        Product product = null;
        if ("A".equals(type)) {product = new ProductA();
        } else if ("B".equals(type)) {product = new ProductB();
        }
        return product;
    }
}

Main

public class Main {public static void main(String[] args) {ProductFactory factory = new ProductFactory();
        Product product;

        product = factory.createProduct("A");
        product.use();

        product = factory.createProduct("B");
        product.use();}
}

点评

当频繁的新增不同产品时，须要频繁的批改 ProductFactory 中的 if/else 逻辑

利用

JDK

java.text.DateFormat#getDateInstance()
java.text.DateFormat#getDateInstance(int)
java.text.DateFormat#getDateInstance(int, java.util.Locale)

加密类，获取不同加密算法的密钥生成器:

KeyGenerator keyGen=KeyGenerator.getInstance("DESede");

工厂办法模式

类图

相比简略工厂，这种形式将 ProductFactory 定义为抽象类，而后创立不同的具体的 ProductAFactory 和ProductBFactory，在应用时决定创立那种工厂和对象，防止了 if/else 判断

代码实现

Product

public abstract class Product {public abstract void use();
}

ProductA

public class ProductA extends Product {
    @Override
    public void use() {System.out.println("You are using ProductA...");
    }
}

ProductB

public class ProductB extends Product {
    @Override
    public void use() {System.out.println("You are using ProductB...");
    }
}

ProductFactory

public abstract class ProductFactory {public abstract Product createProduct();
}

ProductAFactory

public class ProductAFactory extends ProductFactory {
    @Override
    public Product createProduct() {return new ProductA();
    }
}

ProductBFactory

public class ProductBFactory extends ProductFactory {
    @Override
    public Product createProduct() {return new ProductB();
    }
}

Main

public class Main {public static void main(String[] args) {
        ProductFactory factory;
        Product product;

        factory = new ProductAFactory();
        product = factory.createProduct();
        product.use();

        factory = new ProductBFactory();
        product = factory.createProduct();
        product.use();}

}

点评

这种模式更加合乎开闭准则，然而与最原始的 new ProductA() 和new ProductA()相比十分类似，引入工厂模式，反倒让设计变得更加简单了。

利用

JDBC

Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/db1","db_user","123456");
Statement statement=conn.createStatement();
ResultSet rs=statement.executeQuery("select * from user");

形象工厂模式

为了了解形象工厂模式，咱们要先理解两个概念：

  • 产品等级构造：产品等级构造即产品的继承构造，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL 电视机，则形象电视机与具体品牌的电视机之间形成了一个产品等级构造，形象电视机是父类，而具体品牌的电视机是其子类。
  • 产品族：在形象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级构造中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级构造中，海尔电冰箱位于电冰箱产品等级构造中。

在工厂办法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品。个别状况下，一个具体工厂中只有一个工厂办法或者一组重载的工厂办法。然而有时候咱们须要一个工厂能够提供多个产品对象，而不是繁多的产品对象。

类图

Factory1负责创立 ProductA1 和ProductB1
Factory2负责创立 ProductA2 和ProductB2
客户端不须要晓得具体的产品，只须要晓得创立的工厂即可应用该产品

代码实现

AbstractProductA

public abstract class AbstractProductA {public abstract void use();

}

ProductA1

public class ProductA1 extends AbstractProductA {

    @Override
    public void use() {System.out.println("You are using ProductA1...");
    }

}

ProductA2

public class ProductA2 extends AbstractProductA {

    @Override
    public void use() {System.out.println("You are using ProductA2...");
    }

}

AbstractProductB

public abstract class AbstractProductB {public abstract void eat();

}

ProductB1

public class ProductB1 extends AbstractProductB {

    @Override
    public void eat() {System.out.println("You are eating ProductB1...");
    }

}

ProductB2

public class ProductB2 extends AbstractProductB {

    @Override
    public void eat() {System.out.println("You are eating ProductB2...");
    }

}

AbstractFactory

public abstract class AbstractFactory {public abstract AbstractProductA createProductA();

    public abstract AbstractProductB createProductB();}

Factory1

public class Factory1 extends AbstractFactory {

    @Override
    public AbstractProductA createProductA() {return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {return new ProductB1();
    }

}

Factory2

public class Factory2 extends AbstractFactory {

    @Override
    public AbstractProductA createProductA() {return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {return new ProductB2();
    }

}

Main

public class Main {public static void main(String[] args) {
        AbstractFactory factory;
        
        factory = new Factory1();
        use(factory);

        factory = new Factory2();
        use(factory);
    }

    public static void use(AbstractFactory factory) {AbstractProductA productA = factory.createProductA();
        productA.use();
        AbstractProductB productB = factory.createProductB();
        productB.eat();}

}

点评

形象工厂模式带来了泛滥类，构造绝对简单，且创立新的产品等级构造麻烦。
形象工厂模式理论工作中利用场景很少，简略关注理解下即可

退出移动版