1.工厂模式的介绍
工厂方法模式(英语:Factory method pattern)是一种实现了“工厂”概念的面向对象设计模式。就像其他创建型模式一样,它也是处理在不指定对象具体类型的情况下创建对象的问题。工厂方法模式的实质是“定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。在面向对象程序设计中,工厂通常是一个用来创建其他对象的对象。工厂是构造方法的抽象,用来实现不同的分配方案。
2.简单工厂模式(静态工厂)
- 先看一下没有使用任何设计模式的情况下的代码。这里写了一个Car接口和两个实现接口的类Audi和Byd,还有一个测试类Demo01。
package factory;
public interface Car {
void run();
}
package factory;
public class Audi implements Car{
@Override
public void run() {
System.out.println("奥迪在跑....");
}
}
package factory;
public class Byd implements Car {
@Override
public void run() {
System.out.println("比亚迪在跑.....");
}
}
package factory;
/**
1. 普通模式下的测试
*/
public class Demo01 {
public static void main(String[] args) {
Car c1 = new Audi();
Car c2 = new Byd();
c1.run();
c2.run();
}
}
下面是普通方法下的UML图。这时候我们发现调用者需要直接和这些类打交道。同时,当创建这些类本身是个非常复杂的事情的时候,会有大量重复代码。最重要的当这个类非常复杂时(例子写的很简单),调用者想创建这个类的对象时还需要了解这个类的很多,而调用者仅仅是想要创建一个对象而已。
2. 下面看一下使用简单工厂模式的代码,这里写了个CarFactory类和测试类Demo02。代码如下。
package factory;
/**
* 简单工厂
*/
public class CarFactory {
/*第一种造车方法*/
public static Car createCar(String type) {
if("奥迪".equals(type)) {
return new Audi();
}
if("比亚迪".equals(type)) {
return new Byd();
} else {
return null;
}
}
/*第二种造车方法*/
public static Car createAudi() {
return new Audi();
}
/*第二种造车方法*/
public static Car createByd() {
return new Byd();
}
}
package factory;
/**
1. 简单工厂
*/
public class Demo02 {
public static void main(String[] args) {
//不必要管内部怎么实现 直接调用工厂方法 调用者不用直接和相关类打交道,和工厂打交道就行 这样具有更详细的分工。
Car c1 = CarFactory.createCar("奥迪");
Car c2 = CarFactory.createCar("比亚迪");
Car c3 = CarFactory.createAudi();
Car c4 = CarFactory.createByd();
c1.run();
c2.run();
c3.run();
c4.run();
}
}
这时候的UML图如下。可以发现调用者不用理会类的内部怎么实现,也不用和他们打交道,直接和工厂打交道就行。从而达到了更加详细的分工。以上面的例子来说,调用者想创建奥迪车,直接问工厂要奥迪车就行,不需要知道具体怎么创建奥迪车(这个过程可能很复杂)。
2. 缺点:对于增加新类要修改代码,违背了OCP(开闭原则,一个软件的实体应当对扩展开放,对修改关闭)。
3.工厂方法模式
- 有了上面的基础后,下面我们直接看工厂方法模式实现上面的需求的代码。其中定义了一个CarFactory接口,两个实现了这个接口的类AudiFactory和BydFactory,还有一个测试用的Demo类(前面重复的类就没有列出了)。
package factoryMethod;
public interface CarFactory {
Car createCar();
}
package factoryMethod;
public class AudiFactory implements CarFactory{
@Override
public Car createCar() {
return new Audi();
}
}
package factoryMethod;
public class BydFactory implements CarFactory {
@Override
public Car createCar() {
return new Byd();
}
}
package factoryMethod;
public class Demo {
//现在如果要增加一个新的类 比如奔驰 这样不用修改原来的代码 直接增加一个奔驰factory即可 符合开闭原则 但是类就多了
public static void main(String[] args) {
Car c1 = new AudiFactory().createCar();
Car c2 = new BydFactory().createCar();
c1.run();
c2.run();
}
}
这时的UML图如下。可以发现创建了许多新类,同时调用者需要知道更多的信息,这便是工厂方法模式的缺点。但是工厂方法模式符合面向对象程设设计的开闭原则(一个软件的实体应当对扩展开放,对修改关闭),如当创建一个新的Car类Benz时,不用修改原来的代码,直接创建一个新类BenzFactory实现CarFactory接口即可。
3.抽象工厂模式
下面以汽车配件(发动机、座椅和轮胎)的模型分析抽象工厂模式。这里我们把汽车分为高端汽车配件和低端汽车配件,于是我们有Engine、Seat、Tyre和CarFactory接口,同时我们有实现CarFactory接口的类LuxuryCarFactory和lowFactory。最后写了个测试类Demo。代码如下。
package abstractFactory;
public interface Engine {
void run();
void start();
}
/*高端发动机*/
class LuxuryEngine implements Engine {
@Override
public void run() {
System.out.println("高端发动机转的快!");
}
@Override
public void start() {
System.out.println("高端发动机启动快!");
}
}
/*低端发动机*/
class LowEngine implements Engine {
@Override
public void run() {
System.out.println("低端发动机转的慢!");
}
@Override
public void start() {
System.out.println("低端发动机启动慢!");
}
}
package abstractFactory;
public interface Seat {
void massage();
}
class LuxurySeat implements Seat {
@Override
public void massage() {
System.out.println("高端座椅,可以按摩");
}
}
class LowSeat implements Seat {
@Override
public void massage() {
System.out.println("低端座椅,不可以按摩");
}
}
package abstractFactory;
public interface Tyre {
void revolve();
}
/*高端轮胎*/
class LuxuryTyre implements Tyre {
@Override
public void revolve() {
System.out.println("高端轮胎磨损慢");
}
}
/*低端轮胎*/
class LowTyre implements Tyre {
@Override
public void revolve() {
System.out.println("低端轮胎磨损快");
}
}
package abstractFactory;
public interface CarFactory {
Engine createEngine();
Seat createSeat();
Tyre createTyre();
}
package abstractFactory;
public class LuxuryCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Tyre createTyre() {
return new LuxuryTyre();
}
@Override
public Seat createSeat() {
return new LuxurySeat();
}
}
package abstractFactory;
public class LowFactory implements CarFactory{
@Override
public Engine createEngine() {
return new LowEngine();
}
@Override
public Tyre createTyre() {
return new LowTyre();
}
@Override
public Seat createSeat() {
return new LowSeat();
}
}
package abstractFactory;
public class Demo {
public static void main(String[] args) {
CarFactory factory = new LuxuryCarFactory();
Engine e = factory.createEngine();
e.run();
e.start();
}
}
这时候我们发现抽象工厂模式可以弄出产品链。如示例中的高端汽车配件链和低端汽车配件链。
4.总结
- 这篇是本人学习时记得笔记,如有错误的地方恳请大家指正。
- 简单工厂模式虽然不符合开闭原则(一个软件的实体应当对扩展开放,对修改关闭),但是实际使用最多。
- 根据设计模式理论我们应该使用工厂方法,但是实际往往不同(
好像TCP/IP协议也是这样)。 - 抽象工厂模式可以弄出产品链。