一、简单工厂模式
1 简单工厂模式概述
简单工厂模式即指定一个模子,模子中定义一些方法,方法由具体的类去实现。而工厂类负责创建具体的类的对象实例。
2 简单工厂模式结构图
组成:
Product:抽象产品类,定义了产品的通用属性,相当于模子,它定义了一些功能由子类去实现;
ConcreteProduct:具体产品角色,实现了抽象产品类中的功能;
SimpleFactory:工厂模式类,负责创建具体 的产品。
3 简单工厂模式的Java代码实现
Product类:
public abstract class AbstractProduct {
public abstract void product();
}
- 1
- 2
- 3
ConcreteProduct类:
public class ConcreteProductA extends AbstractProduct {
@Override
public void product() {
System.out.println("产品A开始定制了。。。");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
public class ConcreteProductB extends AbstractProduct {
@Override
public void product() {
System.out.println("产品B开始定制了。。。");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
工厂类:
public class SimpleFactory {
public static AbstractProduct createProduct(String type){
AbstractProduct p = null;
switch(type){
case "A":
p = new ConcreteProductA();
break;
case "B":
p = new ConcreteProductB();
break;
}
return p;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
测试:
public class Main {
public static void main(String[] args) {
System.out.println("给我一个来个A产品:");
AbstractProduct pro = SimpleFactory.createProduct("A");
pro.product();
System.out.println("给我一个来个B产品:");
pro = SimpleFactory.createProduct("B");
pro.product();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
输出:
给我一个来个A产品:
产品A开始定制了。。。
给我一个来个B产品:
产品B开始定制了。。。
二、工厂方法模式
1 工厂方法模式概述
简单工厂模式:
优点:工厂类中含有判断逻辑,可以根据客户端的选择来动态创建哪个产品的实例;对于客户端来说去除了与具体产品的依赖;
缺点:
1)工厂类中含有复杂的产品创建逻辑判断,当逻辑判断较多时 不好维护和控制;
2)当需要添加新的产品子类时,需要在工厂类中加case 进行选择,即需要修改类,违反了开发-封闭原则。
工厂方法模式:
工厂模式与简单工厂模式类似,只是加了一个抽象工厂接口,以及为每个具体的产品加了一个具体的工厂类,即每一个具体工厂类负责生产一种产品类实例。
这样做的好处在于:
当你想要再加产品类ConcreteProductC的时候,就不需要修改简单工厂类加上case判断,而是直接加一个用来生产该新增的产品类ConcreteProductC的工厂类ProductCFactory即可。
工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂模式使一个类的实例化延迟到子类。
2 工厂方法模式结构图
组成:
Product:抽象产品类,定义了产品的通用属性,相当于模子,它定义了一些功能由子类去实现;
ConcreteProduct:具体产品角色,实现了抽象产品类中的功能;
Factory: 抽象工厂角色,定义了所有工厂都应该具有的功能;
ConcreteFactory: 具体工厂模式类,实现了抽象工厂定义的所有功能。
3 工厂方法模式的Java代码实现
(1)象产品类及具体产品类同上:
Product类:
public abstract class AbstractProduct {
public abstract void product();
}
- 1
- 2
- 3
ConcreteProduct类:
public class ConcreteProductA extends AbstractProduct {
@Override
public void product() {
System.out.println("产品A开始定制了。。。");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
public class ConcreteProductB extends AbstractProduct {
@Override
public void product() {
System.out.println("产品B开始定制了。。。");
}
}
- 1
- 2
- 3
- 4
- 5
- 6
(2)工厂类:
抽象工厂接口 IFactory :
public interface IFactory {
public AbstractProduct createProduct();
}
- 1
- 2
- 3
具体工厂方法模式类:
//专门用来生产A产品类实例
public class ProductAFactory implements IFactory {
@Override
public ConcreteProductA createProduct() {
return new ConcreteProductA();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
//专门用来生产B产品类实例
public class ProductBFactory implements IFactory{
@Override
public ConcreteProductB createProduct() {
return new ConcreteProductB();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
(3)测试:
public class Main {
public static void main(String[] args) {
ProductAFactory factoryA = new ProductAFactory();
//创建A产品类实例,并开始生产A产品
ConcreteProductA productA = factoryA.createProduct();
productA.product();
ProductBFactory factoryB = new ProductBFactory();
//创建B产品类实例,并开始生产B产品
ConcreteProductB productB = factoryB.createProduct();
productB.product();
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
输出:
产品A开始定制了。。。
产品B开始定制了。。。
工厂方法模式的优点在于:
每一种 产品类都有一个工厂类去负责生产;
这样当你想要再加产品类ConcreteProductC的时候,就不需要修改简单工厂类加上case判断,而是直接加一个用来生产该新增的产品类ConcreteProductC的工厂类ProductCFactory即可。