设计模式-工厂模式
工厂模式(Factory Pattern)是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类:
1. 简单工厂模式(Simple Factory)
2. 工厂方法模式(Factory Method)
3. 抽象工厂模式(Abstract Factory)
简单工厂模式不是我们常说的23种设计模式中的一种,那个23种设计模式中的工厂模式只包含工厂方法和抽象工厂。
下面我们就介绍一下,这三种模式。
简单工厂
简单工厂模式又叫静态工厂方法模式(Static FactoryMethod Pattern),是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
概念:说的通俗些就是工厂根据不同的参数创建对应的产品。
/**
* 抽象产品 Car
* @author hobart
*/
public abstract class Car {
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* 具体产品 Bmw
* @author hobart
*/
public class Bmw extends Car {
public void drive() {
System.out.println(this.getName()+"车----已启动-----------------");
}
}
/**
* 具体产品 Benz
* @author hobart
*/
public class Benz extends Car {
public void drive() {
System.out.println(this.getName()+"车----已启动-----------------");
}
}
/**
* 不存在的产品 Bhq
* @author hobart
*/
public class Bhq extends Car {
void drive() {
System.out.println(this.getName()+"车----不存在-----------------");
}
}
/**
* 简单工厂
* @author hobart
*/
public class DriverSimpleFactory {
public static Car createCar(String car){
Car c = null;
if("Benz".equalsIgnoreCase(car)) {
c = new Benz();
} else if("BMW".equalsIgnoreCase(car)) {
c = new Bmw();
} else {
c = new Bhq();
}
return c;
}
}
/**
* 测试
* @author hobart
*/
public class DriveTest {
public static void main(String[] args) {
Car car = DriverSimpleFactory.createCar("benz");
car.setName("bmw");
//司机开着bmw出发
car.drive();
}
}
UML图
优点:
简单工厂包含逻辑判断,根据客户端实例化相关类,去除与具体产品依赖,客户端不管哪个类的实例,把需求给工厂,工厂单独创建相应实例。是优点也是不足。它方便扩展算法,比如增加一个开根号的功能,我们只要继续继承运算类就行了,同时客户端也就是使用者不知道具体的实现细节,只要给出相关标示符,工厂函数就马上给他创建一个他想要的实体就行了。减少了使用者和功能开发者之间的耦合度。
缺点:
比较明显,在进行扩展的时候,需要修改工厂类的那个分支语句Switch,这样便违背OCP原则[开闭原则(Open Closed Principle)]
,而且当有多级结构继承的时候,简单工厂就会因为只能对应平行一层记得继承,不得不使得好多类继承同一个接口,然后得到A*B这么多的工厂实体可能,工厂函数很难维护。
工厂方法
定义一个用于创建对象的接口,让子类决定实例化哪一个类,工厂方法使得一个类的实例化延迟到了子类。
概念:工厂方法有别于简单工厂却是简单工厂的升级。
不同之处:
简单工厂
是通过参数来控制产品的生产、这里使用的是重载。不同的工厂实现同一个工厂方法生产不同的产品。
工厂方法
是一个工厂生产一个产品(一对一)。如需增加产品、首先要增加工厂。是一对一的生产对象的模式,更符合OCP原则(开闭原则)。
/**
* 抽象产品 Car
* @author hobart
*/
public abstract class Car{
private String name;
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/**
* 具体产品 Bmw
* @author hobart
*/
public class Bmw extends Car {
public void drive() {
System.out.println(this.getName()+"车----已启动-----------------");
}
}
/**
* 具体产品 Benz
* @author hobart
*/
public class Benz extends Car {
public void drive() {
System.out.println(this.getName()+"车----已启动-----------------");
}
}
/**
* 不存在的产品 Bhq
* @author hobart
*/
public class Bhq extends Car {
public void drive() {
System.out.println(this.getName()+"车----是无法生产的车---------");
}
}
/**
* 抽象工厂
* @author hobart
*/
public abstract class DriverFactoryMethod {
public abstract Car createCar(String car);
}
/**
* 具体工厂 BenzDriver(每个具体工厂负责一个具体产品)
* @author hobart
*/
public class BenzDriverFactoryMethod extends DriverFactoryMethod {
@Override
public Car createCar(String car) {
if("Benz".equalsIgnoreCase(car)) {
return new Benz();
} else {
return new Bhq();
}
}
}
/**
* 具体工厂 BmwDriver(每个具体工厂负责一个具体产品)
* @author hobart
*/
public class BmwDriverFactoryMethod extends DriverFactoryMethod {
@Override
public Car createCar(String car) {
if("BMW".equalsIgnoreCase(car)) {
return new Bmw();
} else {
return new Bhq();
}
}
}
/**
* 测试
* @author hobart
*/
public class DriveTest {
public static void main(String[] args) {
DriverFactoryMethod d = new BenzDriverFactoryMethod();
Car car = d.createCar("benz");
car.setName("benz");
//司机开着benz出发
car.drive();
}
}
UML图
优点:
遵守开闭原则,直接添加具体产品类和相应工厂类,实例化哪一个工厂放在客户端, 算法实体的创建被延迟到了工厂子类里,我们不在工厂里直接创建对象,而是直接封装一个一个的小工厂,每个工厂负责创建自己的子类,这样就不存在switch的情况,也就不存在扩展不满足OCP的这个问题。
缺点:
第一:增加一个产品就要增加一个产品工厂类,额外开发.
第二:把简单工厂内部逻辑移到客户端,所以之前修改工厂类,现在修改客户端,问题还是存在.
如果算法种类很多,那么继承抽象工厂的子类也就会很多,不是很好维护,同时不支持产品切换,比如我们要开发PC,分为多个系统,那么我们可以把所有的系统都抽象出来,然后我们在抽象出来工厂,但是如果这个时候我们有两个硬件呢,PC和Phone,虽然我们可以保证只有这两个硬件了,但是如果用基本的抽象工厂去实现的话还是很别扭。
抽象工厂
抽象工厂模式(Abstract Factory Pattern)提供一个创建一系列相关或者相互依赖对象的接口,而无需指定它们具体的类,它是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
概念:说的明白些抽象工厂就是 简单工厂+工厂方法。
/**
* 抽象产品 Car
* @author hobart
*/
public interface Car{
public abstract void drive();
}
/**
* 具体产品 Bmw
* @author hobart
*/
public class Bmw implements Car {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void drive(){
System.out.println(this.getName()+"车----已启动-----------------");
}
}
/**
* 具体产品 Benz
* @author hobart
*/
public class Benz implements Car {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void drive(){
System.out.println(this.getName()+"车----已启动-----------------");
}
}
/**
* 抽象产品 Audi
* @author hobart
*/
public class Audi implements Car {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void drive(){
System.out.println(this.getName()+"车----已启动-----------------");
}
}
/**
* 抽象工厂
* @author hobart
*/
public abstract class DriveAbstractFactory {
public abstract Benz createBenzCar(String car);
public abstract Bmw createBmwCar(String car);
public abstract Audi createAudiCar(String car);
}
/**
* 具体工厂 BmwDriverAbstractFactory(每个具体工厂负责一个具体产品)
* @author hobart
*/
public class BmwDriveAbstractFactory extends DriveAbstractFactory {
@Override
public Bmw createBmwCar(String car) {
Bmw bmw = new Bmw();
bmw.setName(car);
return bmw;
}
@Override
public Benz createBenzCar(String car) {
return null;
}
@Override
public Audi createAudiCar(String car) {
return null;
}
}
/**
* 具体工厂 BenzDriverAbstractFactory(每个具体工厂负责一个具体产品)
* @author hobart
*/
public class BenzDriveAbstractFactory extends DriveAbstractFactory {
@Override
public Benz createBenzCar(String car) {
Benz benz = new Benz();
benz.setName(car);
return benz;
}
@Override
public Bmw createBmwCar(String car) {
return null;
}
@Override
public Audi createAudiCar(String car) {
return null;
}
}
/**
* 具体工厂 AudiDriverAbstractFactory(每个具体工厂负责一个具体产品)
* @author hobart
*/
public class AudiDriveAbstractFactory extends DriveAbstractFactory {
@Override
public Benz createBenzCar(String car) {
return null;
}
@Override
public Bmw createBmwCar(String car) {
return null;
}
@Override
public Audi createAudiCar(String car) {
Audi audi = new Audi();
audi.setName(car);
return audi;
}
}
/**
* 创建工厂的工厂 CarFactory(创建一个具体的工厂)
* @author hobart
*/
public class CarFactory {
public static DriveAbstractFactory driverAbstractFactory = null;
public static DriveAbstractFactory getFactory(String context) {
if(context.equalsIgnoreCase("bmw")) {
return new BmwDriveAbstractFactory();
} else if(context.equalsIgnoreCase("benz")) {
return new BenzDriveAbstractFactory();
} else if(context.equalsIgnoreCase("audi")) {
return new AudiDriveAbstractFactory();
} else {
return null;
}
}
}
/**
* 测试
* @author hobart
*/
public class DriveTest {
public static void main(String[] args) {
//获取car工厂
DriveAbstractFactory driveAbstractFactory = CarFactory.getFactory("BENZ");
//获取形状为 Benz 的对象
Benz benz = driveAbstractFactory.createBenzCar("BENZ");
//调用 Benz 的 drive 方法
benz.drive();
//获取car工厂
DriveAbstractFactory BmwDriveAbstractFactory = CarFactory.getFactory("BMW");
//获取形状为 Bmw 的对象
Bmw bmw = BmwDriveAbstractFactory.createBmwCar("BMW");
//调用 Benz 的 drive 方法
bmw.drive();
}
}
UML图
优点:
首先是满足OCP的,而且可以满足产品切换,能实现的前提是比如A和B两个产品,它们有1和2两个方法接口(类),现在我们在增加新的产品C(假设也是只有1和2两个方法接口),我们要做的只是增加一个产品类再增加一个工厂类就行了,如果是简单工厂或者是工厂方法的的话通常都是增加两个算法类C.1,C.2,简单工厂需要修改switch增加两个语句,工厂方法是在增加两个工厂类。可见抽象工厂的优点。
缺点:
显而易见,太重了。
总括:
简单工厂:
工厂类中,根据条件决定一个接口由哪个具体产品类来实现。
工厂方法:
创建多个工厂类。各个工厂类中,都对应一个获得接口A实例的方法。用户决定使用哪个工厂。
抽象工厂:
对工厂方法进行扩展。各个工厂类中,再增加一个获得接口B实例的方法。
从对象的角度来看:
- 简单工厂是一对多的关系 (一个工厂可以生成多个产品)
- 工厂方法是一对一的关系(一个工厂只能生产一个产品)
- 抽象工厂抽象了前面两个设计模式、(一生产线可以生产多个产品可以、多个生产线可以生产一个产品)
对比:
简单工厂实现简单,扩展也很容易,但是不满足OCP,不满足OCP的代价就是难维护,在维护的时候容易引发新的BUG,相比之下,工厂方法则是把对象的实例化延迟到了继承的子类里面,这样可以量或的扩展工厂。扩展的是时候满足OCP,但是不支持产品切换,也就是只能满足一层的产品(算法)抽象,而抽象工厂则是继续把产品进行再次抽象,最后得到一个可以支持产品切换的结构,但问题是太重了,过于复杂,不过还好,很多支持反射的语言,我们可以直接通过反射技术来优化这个“过重”的缺点。当然,也可以用反射来优化前面两个工厂结构(但是抽象工厂和工厂方法相比,两者也都只是支持一个地方的可扩展而已,不要误解为抽象工厂可以扩展两个地方)。