设计模式之工厂模式——应用最广泛的模式

最新推荐文章于 2023-03-04 21:27:39 发布

蒲公英291

最新推荐文章于 2023-03-04 21:27:39 发布

阅读量1.7k

点赞数 4

分类专栏： Java 设计模式

本文链接：https://blog.csdn.net/qianhaifeng2012/article/details/52014773

版权

Java 同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

设计模式

12 篇文章 0 订阅

订阅专栏

工厂模式主要分为三种，简单工厂模式、工厂方法模式、抽象工厂模式。

1、绪论

在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。在这些情况,新对象的建立就是一个 “过程”，不仅是一个操作，像一部大机器中的一个齿轮传动。

那么如何能轻松方便地构造对象实例，而不必关心构造对象实例的细节和复杂过程呢？
其实可以建立一个工厂来创建对象。

2、工厂方法定义

定义一个用于创建对象的接口，让子类决定实例化哪个类。

3、使用场景

在绪论中已经大概说明了使用场景，总结就是在任何需要生产复杂对象的地方，都可以使用工厂模式，复杂对象适合使用工厂模式，用new就可以完成创建对象无需使用工厂模式。

下面逐一介绍三个工厂模式。

4、简单工厂模式

简单工厂模式的UML类图如图所示：

抽象产品类：它一般是具体产品继承的父类或者实现的接口。

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

具体产品类A:工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

public class ConcreteProductA extends Product {

	@Override
	public void method() {
		System.out.println("创建产品A");

	}

}

具体产品类B:同上

public class ConcreteProductB extends Product {

	@Override
	public void method() {
		System.out.println("创建产品B");

	}

}

工厂类：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品

public class Factory {
	private  Product product;
	public  Product createProduct(String name) {
		
		
		switch (name) {
		case "A":
			product = new ConcreteProductA();
			break;
		case "B":
			product = new ConcreteProductB();
			break;
		default:
			break;
		}
		return product;
		
		
	}
}

客户端测试代码

public class Client {
	public static void main(String[] args) {
		
		Factory factory = new Factory();
		
		Product product = factory.createProduct("A");
		product.method();
		product = factory.createProduct("B");
		product.method();
	}
}

最后输出结果

创建产品A
创建产品B

下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当客户不再满足现有的产品的时候，想要另外一种产品，只要这种产品符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了，所以对产品部分来说，它是符合开闭原则的；

但是工厂部分好像不太理想，因为每增加一种新产品，都要在工厂类中增加相应的创建业务逻辑（createProduct方法需要新增case），这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。

我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。
于是工厂方法模式作为救世主出现了。工厂类定义成了接口,而每新增的产品,就增加该产品对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。

5、工厂方法模式

工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。

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

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的！

工厂方法模式UML类图：

抽象工厂角色

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

具体工厂角色

public class ConcreteFactoryA extends Factory {

	@Override
	public Product createProduct() {
		
		return new ConcreteProductA();
	}

	

}

public class ConcreteFactoryB extends Factory {

	@Override
	public Product createProduct() {
		
		return new ConcreteProductB();
	}

}

抽象产品角色

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

具体产品角色

public class ConcreteProductA extends Product {

	@Override
	public void method() {
		System.out.println("创建产品A");

	}

}

public class ConcreteProductB extends Product {

	@Override
	public void method() {
		System.out.println("创建产品B");

	}

}

客户端代码

public class Client {
	public static void main(String[] args) {
		Factory factory = new ConcreteFactoryA();
		Product product = factory.createProduct();
		product.method();
		
		
		factory = new ConcreteFactoryB();
		product = factory.createProduct();
		product.method();
		
		
	}
}

输出结果为：

创建产品A
创建产品B

与简单工厂方式一样。但是多了一个工厂类，不同的工厂生产不同的产品。

这种方式比较常见，需要哪一个产品就生产哪一个，有时候也可以利用反射的方式更简洁的来生产具体产品对象，此时，需要在工厂方法的参数列表中传入一个Class对象类决定是哪一个产品类。

这里采用反射的方式更简洁的来表示

UML类图为：

抽象工厂角色

public abstract class Factory {
	public abstract <T extends Product> T createProduct(Class<T> clz);
}

具体工厂角色

public class ConcreteFactory extends Factory {

	@Override
	public <T extends Product> T createProduct(Class<T> clz) {
		// TODO Auto-generated method stub
		
		Product p = null;
		try {
			p = (Product)Class.forName(clz.getName()).newInstance();
		} catch (Exception e) {
			
			e.printStackTrace();
		}
		
		return (T) p;
	}

}

抽象产品角色，具体产品角色代码

客户端代码

public class Client {
	public static void main(String[] args) {
		Factory factory = new ConcreteFactory();
		Product product = factory.createProduct(ConcreteProductA.class);
		product.method();
		
		product = factory.createProduct(ConcreteProductB.class);
		product.method();
	}
}

输出结果与上面是一样的

需要哪一个类的对象就传入哪一个类的类型就可以，这种方式比较简洁、动态。

6、抽象工厂模式

随着客户的要求越来越高，产品需要不同配置的配件A与配件B。于是这个工厂开始生产配件A与配件B，用来组装产品，当然配件有好有差，具体有1型，2型。这时候工厂有两个系列的产品:产品A和产品B。产品A配置1型号配件A和1型号配件B，产品B配置2型号配件B和2型号配件B.

举个例子

随着客户的要求越来越高，宝马车需要不同配置的空调和发动机等配件。于是这个工厂开始生产空调和发动机，用来组装汽车。这时候工厂有两个系列的产品:空调和发动机。宝马750系列配置A型号空调和A型号发动机，宝马320系列配置B型号空调和B型号发动机。

这时候就需要抽象工程模式了。

抽象工程模式用来为创建一组相关或者相互依赖的对象提供一个接口，而不需要指定他们的具体类。

当一个对象族有相同的约束时可以使用抽象工厂模式，比如宝马750，宝马都需要有空调和发动机，但是他们又都有A型号与B型号，即使他们同属于空调或者发动机。

抽象工厂模式的UML类图：

根据类图可以得出如下一个抽象工厂模式的通用代码：

抽象产品类A，对应于空调这个配件产品。

public abstract class AbstractProductA {
	public abstract void method();
}

抽象产品类B，对应于发动机这个配件产品。

public abstract class AbstractProductB {
	public abstract void method();
}

具体产品类A1 对应1型空调

public class ConcreteProductA1 extends AbstractProductA {

	@Override
	public void method() {
		System.out.println("创建产品A1");

	}

}

具体产品类A2 对应2型空调

public class ConcreteProductA2 extends AbstractProductA {

	@Override
	public void method() {
		System.out.println("创建产品A2");

	}

}

具体产品类B1 对应1型发动机

public class ConcreteProductB1 extends AbstractProductB {

	@Override
	public void method() {
		System.out.println("创建产品B1");

	}

}

具体产品类B2 对应2型发动机

public class ConcreteProductB2 extends AbstractProductB {

	@Override
	public void method() {
		System.out.println("创建产品B2");

	}

}

抽象工厂类对应于汽车工厂

public abstract class AbstractFactory {
	//创建产品A的方法
	public abstract AbstractProductA createProductA();
	//创建产品B的方法
	public abstract AbstractProductB createProductB();
}

具体工厂类1 对应于宝马750的生产工厂

public class ConcreteFactory1 extends AbstractFactory {
	//生产A1产品
	@Override
	public AbstractProductA createProductA() {
		
		return new ConcreteProductA1();
	}
	//生产B1产品
	@Override
	public AbstractProductB createProductB() {
		
		return new ConcreteProductB1();
	}
}

具体工厂类2 对应于宝马320的生产工厂

public class ConcreteFactory2 extends AbstractFactory {
	//生产A2产品
	@Override
	public AbstractProductA createProductA() {
		
		return  new ConcreteProductA2();
	}
	//生产B2产品
	@Override
	public AbstractProductB createProductB() {
		
		return  new ConcreteProductB2();
	}



}

客户端代码

public class Client {
	public static void main(String[] args) {
		AbstractFactory factory = new ConcreteFactory1();
		factory.createProductA().method();
		factory.createProductB().method();
		System.out.println("-------------");
		factory = new ConcreteFactory2();
		factory.createProductA().method();
		factory.createProductB().method();
	}
}

输出结果：

创建产品A1
创建产品B1
-------------
创建产品A2
创建产品B2

可以看出工厂1创建了产品A1 B1 那么A1 B1就可以组装组装产品1了，就是这个样子哈，组装产品！！

这里也看出抽象工厂模式的一个弊端，类特别多，所以在实际开发中，权衡利弊即可。

总结：
无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。

蒲公英291

关注

4
点赞
踩
4

收藏

觉得还不错? 一键收藏
2
评论
设计模式之工厂模式——应用最广泛的模式

工厂模式主要分为三种，简单工厂模式、工厂方法模式、抽象工厂模式。1、绪论在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助
复制链接

扫一扫