工厂模式是创建型模式之一。简单的说,工厂模式就是为了减少代码的工作量,方便测试和扩展。在工厂模式中,创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。创建工厂类,接收不同的参数生成不同的对象的过程。由于简单工厂模式,抽象工厂模式,工厂方法模式依次递进且很相似,所以放在一起总结。
一、定义
工厂模式定义一个用于创建对象的接口,这个接口由子类决定实例话哪一个类。该模式是一个类的实例话延迟到了子类。而子类可以重写接口方法便于创建不同类型的对像
二、分类
简单工厂模式
简单工厂模式(Simple Factory Pattern):又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式。在简单 工厂模式中,可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
优点:
1、简单工厂模式实现了责任分离
2、工厂类中包含了对象生成的必要逻辑判断,根据客户端的选择条件实例化不同的对象,所以客户端没有创建对象所需要的条件
3、客户端不直接创建产品类的对象,客户端只作为消费者,具体逻辑代码交由工厂类处理
缺点:
1、工厂类必须知道怎么样创建每一个对象,当增加一个对象时必须改动工厂类的逻辑代码,所以简单工厂模式不符合开闭原则。
2、因为工厂类中的工厂方法是静态的,所以工厂类中的方法不能被重写,工厂类只是一个单独的类,它不能成为一个层次的类
抽象工厂模式
抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无须指定它们具体的类。抽象工厂模式又称为Kit模式,属于对象创建型模式。
优点:
1、更符合开闭原则,增加创建对象时只需要修改相应的产品类和工厂子类
2、符合单一职责原则,每个产品都有相应的工厂负责
3、不使用静态工厂方法,可以形成基于继承的等级结构。
缺点:
1、没有完全符合开闭原则,这是因为在抽象工厂角色中规定了所有可能被创建的产品集合,要支持新种类的产品就意味着要对该接口进行扩 展,而这将涉及到对抽象工厂角色及其所有子类的修改,显然会带来较大的不便。
工厂方法模式(工厂模式)
优点:
缺点:
三、基本结构
简单工厂模式
简单工厂模式定义三个角色:
· 工厂角色(Factory): 负责创建实例的具体逻辑。
· 抽象产品角色(Product):是所有创建对象的的父类,拥有所有创建对象的公共接口。
· 具体产品角色(CreateProduct):具体产品角色是创建目标,所有创建的对象都充当这个角色的某个具体类的实例。
![](https://i-blog.csdnimg.cn/blog_migrate/39d44895efbb39c3572fc149dffcadbf.png)
抽象工厂模式
AbstractFactory:抽象工厂
ConcreteFactory:具体工厂
AbstractProduct:抽象产品
Product:具体产品
![](https://i-blog.csdnimg.cn/blog_migrate/f43cdcc6ab0782255f124a9785981a25.png)
工厂方法模式
Product:抽象产品
ConcreteProduct:具体产品
Factory:抽象工厂
ConcreteProduct:具体工厂
四、时序图
简单工厂模式
抽象工厂模式
![](https://i-blog.csdnimg.cn/blog_migrate/1355749d0b32cd553660a948581c025c.png)
五、代码实现
简单工厂模式
1.工厂角色
public class FruitFactory {
public static Fruit newInstance(String name) throws BadFruitException {
if ("apple".equalsIgnoreCase(name)) {
return new Apple();
} else if ("grape".equalsIgnoreCase(name)) {
return new Grape();
} else if ("strawberry".equalsIgnoreCase(name)) {
return new Strawberry();
// 其它情况,则抛出异常。
} else {
throw new BadFruitException("Bad fruit request!");
}
}
}
2.抽象产品角色
public abstract class Fruit {
//公共属性
abstract void grow(); // 生长
abstract void harvest(); // 收获
abstract void plant(); // 种植
}
3.具体产品角色
由三个角色 apple、grape、strawberry都继承抽象产品角色,重写其中的方法表现出每个产品不一样的行为
4.客户端代码
public class Client {
public static void main(String[] args) {
try {
Fruit apple = FruitFactory.newInstance("Apple");
apple.plant();
apple.grow();
apple.harvest();
Fruit grape = FruitFactory.newInstance("Grape");
grape.plant();
grape.grow();
grape.harvest();
Fruit strawberry = FruitFactory.newInstance("strawberry");
strawberry.plant();
strawberry.grow();
strawberry.harvest();
Fruit error = FruitFactory.newInstance("error");
error.plant();
error.grow();
error.harvest();
} catch (BadFruitException e) {
e.printStackTrace();
}
}
}
抽象工厂模式
1、抽象工厂
abstract class Factory{
public abstract Product ManufactureContainer();
public abstract Product ManufactureMould();
}
2、具体工厂
//A厂 - 生产模具+容器产品
class FactoryA extends Factory{
@Override
public Product ManufactureContainer() {
return new ContainerProductA();
}
@Override
public Product ManufactureMould() {
return new MouldProductA();
}
}
//B厂 - 生产模具+容器产品
class FactoryB extends Factory{
@Override
public Product ManufactureContainer() {
return new ContainerProductB();
}
@Override
public Product ManufactureMould() {
return new MouldProductB();
}
}
3、抽象产品族
abstract class AbstractProduct{
public abstract void Show();
}
4、抽象产品
//容器产品抽象类
abstract class ContainerProduct extends AbstractProduct{
@Override
public abstract void Show();
}
//模具产品抽象类
abstract class MouldProduct extends AbstractProduct{
@Override
public abstract void Show();
}
5、具体产品
//容器产品A类
class ContainerProductA extends ContainerProduct{
@Override
public void Show() {
System.out.println("生产出了容器产品A");
}
}
//容器产品B类
class ContainerProductB extends ContainerProduct{
@Override
public void Show() {
System.out.println("生产出了容器产品B");
}
}
//模具产品A类
class MouldProductA extends MouldProduct{
@Override
public void Show() {
System.out.println("生产出了模具产品A");
}
}
//模具产品B类
class MouldProductB extends MouldProduct{
@Override
public void Show() {
System.out.println("生产出了模具产品B");
}
}
6、客户端
//生产工作流程
public class AbstractFactoryPattern {
public static void main(String[] args){
FactoryA mFactoryA = new FactoryA();
FactoryB mFactoryB = new FactoryB();
//A厂当地客户需要容器产品A
mFactoryA.ManufactureContainer().Show();
//A厂当地客户需要模具产品A
mFactoryA.ManufactureMould().Show();
//B厂当地客户需要容器产品B
mFactoryB.ManufactureContainer().Show();
//B厂当地客户需要模具产品B
mFactoryB.ManufactureMould().Show();
}
}
六、应用
简单工厂模式
1、工厂类负责创建的对象比较少:由于创建的对象较少,不会造成工厂方法中的业务逻辑太过复杂。
2、客户端只知道传入工厂类的参数,对于如何创建对象不关心:客户端既不需要关心创建细节,甚至连类名都不需要记住,只需要知道类型所对应的参数。
抽象工厂模式
1、一个系统不要求依赖产品类实例如何被创建、组合和表达的表达,这点也是所有工厂模式应用的前提。
2、这个系统有多个系列产品,而系统中只消费其中某一系列产品