设计模式——工厂模式

最新推荐文章于 2024-09-25 23:08:45 发布

Exploring1024

最新推荐文章于 2024-09-25 23:08:45 发布

阅读量349

点赞数

分类专栏： Android进阶文章标签：工厂模式设计模式 Android设计模式 Android进阶 Java设计模式

本文链接：https://blog.csdn.net/Mr_dsw/article/details/79111723

版权

Android进阶专栏收录该内容

25 篇文章 2 订阅

订阅专栏

工厂模式核心是封装对象的创建接口，将new对象的操作封装起来，方便创建使用、管理对象。

工厂模式的分类

简单工厂模式（Simple Factory）
工厂方法模式（Factory Method）
抽象工厂模式（Abstract Factory）

工厂模式适用于：

在编码时不能预见需要创建哪种类的实例。
系统不应依赖于产品类实例如何被创建、组合和表达的细节

简单工厂模式

简单工厂模式又称为静态工厂方法模式。简单工厂模式是由一个工厂类来控制产品类对象的创建，模式构成比较简单，适用于简单稳定、扩展少的模块。它由三部分角色类构成：

简单工厂类：它是本模块的核心，用于创建对应的产品对象，包含一定的逻辑处理。
抽象产品类：它一般是具体产品继承的父类或者实现的接口，一般由接口或者抽象类来实现，它定义了产品的特点。
具体产品类：具体需要创建的产品类对象的实例。

它们之间关系的UML图如下：

具体的演示实例：首先我们创建抽象产品了Ball，并定义了两个具体的产品BasketBall和FootBall。

/**
 * 定义一个球的实体
 * @author Iflytek_dsw
 *
 */
abstract class Ball {
	/**
	 * 定义球的特性，都能玩
	 */
	public abstract void play();
}

class Basketball extends Ball{
	private String name = "";
	
	public Basketball(String name){
		this.name = name;
	}

	@Override
	public void play() {
		System.out.println("拍打：" + name);
	}
	
}

class Football extends Ball{
	private String name = "";
	public Football(String name){
		this.name = name;
	}

	@Override
	public void play() {
		System.out.println("踢：" + name);
	}
}

上面中创建了抽象产品类Ball，并定义方法play。同时每个具体产品类进行实现对应的方法。有了产品类，在定义一个简单工厂类：

/**
 * 工厂类，用于封装创建对象的操作，对外进行封装，不被外部调用。
 * 封装具体产品的创建对象。
 * @author Iflytek_dsw
 *
 */
public class BallFactory {
	enum BallType{
		BasketBall,
		FootBall
	}
	
	public static Ball createBall(BallType ballType){
		switch(ballType){
			case BasketBall:
				return new Basketball("篮球");
			case FootBall:
				return new Football("足球");
			default:
				return null;
		}
	}
}

这样，在简单工厂类中，我们封装了创建对象的静态方法。然后在客户端进行调用：

public class SimpleFactoryClient {

	/**
	 * 通过简单工厂模式，我们可以根据我们的需求进行产品类的创建，直接进行使用，避免了客户端对产品的生产。
	 * 弊端是：如果我们新增一个品种，修改比较多。
	 * @param args
	 */
	public static void main(String[] args) {
		//指定创建的类型
		Ball basketBall = BallFactory.createBall(BallType.BasketBall);
		basketBall.play();
		
		Ball footBall = BallFactory.createBall(BallType.FootBall);
		footBall.play();
	}
}

简单工厂的优点/缺点：

优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则，当新增一个产品类是，需要改动工厂类，产品多，工厂类逻辑就过于复杂。

工厂方法模式

工厂方法模式，又称为多态性工厂模式，主要是利用面向对象的继承多态实现。在工厂方法模式中，核心的工厂类提取成为一个抽象工厂类，由对应产品的子类工厂负责创建对应的产品类对象。抽象工厂类只负责定义子类工厂需要实现的接口，不涉及具体产品类实例化的细节。工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

工厂方法模式由四个角色类组成：

抽象工厂类：定义工厂类的方法，用来创建产品类
具体工厂类：用于创建对应的产品对象
抽象产品类：定义产品了公共的属性、方法
具体产品类：实现对应产品类的属性、方法

它们之间的UML关系图如下：

实现例子：

定义产品类对象：

/**
 * 定义一个球的实体
 * @author Iflytek_dsw
 *
 */
abstract class Ball {
	/**
	 * 定义球的特性，都能玩
	 */
	public abstract void play();
}

class Basketball extends Ball{
	private String name = "";
	
	public Basketball(String name){
		this.name = name;
	}

	@Override
	public void play() {
		System.out.println("拍打：" + name);
	}
	
}

class Football extends Ball{
	private String name = "";
	public Football(String name){
		this.name = name;
	}

	@Override
	public void play() {
		System.out.println("踢：" + name);
	}
}

定义工厂类：

/**
 * 定义抽象工厂类，来定义所有工厂应该具备的职责，通性。
 * @author Iflytek_dsw
 *
 */
abstract class BallFacoty {
	 public abstract Ball createBall();
}

class BasketballFactory extends BallFacoty{

	@Override
	public Ball createBall() {
		return new Basketball("篮球");
	}
}

class FootballFactory extends BallFacoty{

	@Override
	public Ball createBall() {
		return new Football("足球");
	}

}

定义客户端：

public class MethodFactoryClient {

	/**
	 * 工厂方法模式，根据需要，直接创建对象。方便扩展。无用改变Factory类代码，只需要新增。
	 * @param args
	 */
	public static void main(String[] args) {
		BasketballFactory basketballFactory = new BasketballFactory();
		Ball basketBall = basketballFactory.createBall();
		basketBall.play();
		
		FootballFactory footballFactory = new FootballFactory();
		Ball footBall = footballFactory.createBall();
		footBall.play();
	}
}

工厂方法的优点/缺点：

优点：子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。-- 加一层间接性，增加了灵活性屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。多态性：客户代码可以做到与特定应用无关，适用于任何实体类。缺点：需要Creator和相应的子类作为factory method的载体，如果应用模型确实需要creator和子类存在，则很好；否则的话，需要增加一个类层次，有点冗余。

抽象工厂模式

产品族：位于不同产品等级结构中，功能相关联的产品组成的家族。抽象工厂模式是针对产品族进行使用，抽象工厂类的用途就是提供一个接口，创建多个产品族中的对象。比如，我们上面的例子中，篮球和足球就是产品层次结构。而篮球中又可以有大的和小的篮球种类，足球中也有大的和小的的足球种类，这里打篮球和大足球就属于产品族。而且使用抽象工厂模式还要满足一下条件：

系统中有多个产品族，而系统一次只可能消费其中一族产品
同属于同一个产品族的产品以其使用。

来看看抽象工厂模式的各个角色：

抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

来看具体的实例：

新建抽象产品类

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


abstract class ProductA extends Product{
	public abstract void play();
}

abstract class ProductB extends Product{
	public abstract void play();
}

class ProductABig extends ProductA{

	@Override
	public void play() {
		System.out.print("ProductABig");
	}
}

class ProductASmall extends ProductA{
	@Override
	public void play() {
		System.out.print("ProductASmall");
	}
}

class ProductBBig extends ProductB{

	@Override
	public void play() {
		System.out.print("ProductBBig");
	}
}

class ProductBSmall extends ProductB{
	@Override
	public void play() {
		System.out.print("ProductBSmall");
	}
}

抽象工厂类

abstract class Factory {
	abstract ProductA createProductA();
	abstract ProductB createProductB();
}

class FactoryBig extends Factory{

	@Override
	ProductA createProductA() {
		return new ProductABig();
	}

	@Override
	ProductB createProductB() {
		return new ProductBBig();
	}
}

class FactorySmall extends Factory{

	@Override
	ProductA createProductA() {
		return new ProductASmall();
	}

	@Override
	ProductB createProductB() {
		return new ProductBSmall();
	}
}

客户端

public static void main(String[] args) {
    Factory factoryBig = new FactoryBig();
    Product productABig = factoryBig.createProductA();
    Product productBBig = factoryBig.createProductB();
    productABig.play();
    productBBig.play();
}

从抽象工厂特点来看，就是在工厂中不仅仅只生产一种对象，而是可以创建多种产品对象。优点：抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。

缺点：产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。

适用场景：当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。通俗一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行创建，则更合适一点。

抽象工厂模式-与-工厂方法模式区别

首先来看看这两者的定义区别：

工厂模式：定义一个用于创建对象的借口，让子类决定实例化哪一个类
抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类

区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构，抽象工厂模式针对的是面向多个产品等级结构的。再来看看工厂方法模式与抽象工厂模式对比：

工厂方法模式	抽象工厂模式
针对的是一个产品等级结构	针对的是面向多个产品等级结构
一个抽象产品类，可以派生出多个具体产品类	多个抽象产品类，每个抽象产品类可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类	个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类只能创建一个具体产品类的实例	每个具体工厂类可以创建多个具体产品类的实例