在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。这时就可以采用工厂模式。
工厂模式根据抽象程度的不同分为三种：简单工厂模式（也叫静态工厂模式）、普通工厂模式、以及抽象工厂模式。
工厂模式是编程中经常用到的一种模式。它的主要优点有：
1、可以使代码结构清晰，有效地封装变化。在编程中，产品类的实例化有时候是比较复杂和多变的，通过工厂模式，将产品的实例化封装起来，使得调用者根本无需关心产品的实例化过程，只需依赖工厂即可得到自己想要的产品。
2、对调用者屏蔽具体的产品类。如果使用工厂模式，调用者只关心产品的接口就可以了，至于具体的实现，调用者根本无需关心。即使变更了具体的实现，对调用者来说没有任何影响。
3、降低耦合度。产品类的实例化通常来说是很复杂的，它需要依赖很多的类，而这些类对于调用者来说根本无需知道，如果使用了工厂方法，我们需要做的仅仅是实例化好产品类，然后交给调用者使用。对调用者来说，产品所依赖的类都是透明的。
工厂方法模式有四个要素：
1、工厂接口。工厂接口是工厂方法模式的核心，与调用者直接交互用来提供产品。在实际编程中，有时候也会使用一个抽象类来作为与调用者交互的接口，其本质上是一样的。
2、工厂实现。在编程中，工厂实现决定如何实例化产品，是实现扩展的途径，需要有多少种产品，就需要有多少个具体的工厂实现。
3、产品接口。产品接口的主要目的是定义产品的规范，所有的产品实现都必须遵循产品接口定义的规范。产品接口是调用者最为关心的，产品接口定义的优劣直接决定了调用者代码的稳定性。同样，产品接口也可以用抽象类来代替，但要注意最好不要违反里氏替换原则。
4、产品实现。实现产品接口的具体类，决定了产品在客户端中的具体行为。
适用场景：
1、作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。
2、工厂模式是一种典型的解耦模式，迪米特法则在工厂模式中表现的尤为明显。假如调用者自己组装产品需要增加依赖关系时，可以考虑使用工厂模式。将会大大降低对象之间的耦合度。
3、由于工厂模式是依靠抽象架构的，它把实例化产品的任务交由实现类完成，扩展性比较好。也就是说，当需要系统有比较好的扩展性时，可以考虑工厂模式，不同的产品用不同的实现工厂来组装。
应用实例：
1、假如需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。
2、Hibernate 换数据库只需换方言和驱动就可以。
3、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
下面结合具体事例来说。举例如下：（我们举一个发送邮件和短信的例子）
1、因为邮件和短信是不同的事物，但执行的操作类似。我们定义一个两者的共同接口。
public interface Sender {
public void Send(); //邮件和短信都需要进行发送操作
}
2、实现邮件和短信类
邮件类
public class MailSender implements Sender {
@Override
public void Send() {
System.out.println("this is mailsender!");
}
} 短信类
public class SmsSender implements Sender {
@Override
public void Send() {
System.out.println("this is sms sender!");
}
} 下面来分别介绍三种工厂模式。
二、简单工厂模式
通过提供的不同的静态方法来创建相应的类实例。
定义工厂类
public class SendFactory {
//采用静态方法创建不同的类实例
public static Sender produceMail(){
return new MailSender();
}
public static Sender produceSms(){
return new SmsSender();
}
} 测试
public class FactoryTest {
public static void main(String[] args) {
Sender sender = SendFactory.produceMail();//创建邮件类
sender.Send();
}
} 三、普通工厂模式
通过传入不同的字符串来创建相应的类实例。
定义工厂类
public class SendFactory {
//通过传入的字符串参数决定初始化那个类实例
public Sender produce(String type) {
if ("mail".equals(type)) {
return new MailSender();
} else if ("sms".equals(type)) {
return new SmsSender();
} else {
System.out.println("请输入正确的类型!");
return null;
}
}
} 测试
public class FactoryTest {
public static void main(String[] args) {
SendFactory factory = new SendFactory();
Sender sender = factory.produce("sms");//传入sms字符串，初始化一个短信类实例。
sender.Send();
}
} 四、抽象工厂模式
将工厂类定义为一个接口，不同的类实例的创建需要实现这个接口，从而保证不同的工厂类创建不同的类实例。
首先定义一个工厂类的接口：
public interface Provider {
public Sender produce();
}
之后根据不同的类实例创建相应的工厂类：
邮件工厂类
public class SendMailFactory implements Provider {
@Override
public Sender produce(){
return new MailSender();
}
} 短信工厂类
public class SendSmsFactory implements Provider{
@Override
public Sender produce() {
return new SmsSender();
}
}
测试：
public class Test {
public static void main(String[] args) {
Provider provider1 = new SendMailFactory();//初始化邮件类工厂
Sender sender1 = provider1.produce();//产生一个邮件类实例
sender1.Send();
Provider provider2 = new SendMailFactory();//初始化短信类工厂
Sender sender2 = provider2.produce();//产生一个短信类实例
sender2.Send();
}
}
五、抽象工厂模式的复杂应用
事实上，抽象工厂模式可以更复杂。抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
下面来看一个较为复杂的例子：
我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义两个工厂类： ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory接口。然后创建一个工厂创造器/生成器类 FactoryProducer，这个工厂可以生成ShapeFactory和ColorFactory。
1、shape接口
public interface Shape {
void draw();
}2、建立shape的三个实现类
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}Square.java
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}3、color接口
public interface Color {
void fill();
}4、建立三个color的实体类
Red.java
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}
Green.java
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method.");
}
}Blue.java
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}5、建立一个抽象工厂类
public abstract class AbstractFactory {
abstract Color getColor(String color);
abstract Shape getShape(String shape) ;
}
6、针对shape和color创建相应的工厂类，扩展自 AbstractFactory 的工厂类
ShapeFactory.java
public class ShapeFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
@Override
Color getColor(String color) {
return null;
}
}ColorFactory.java
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
Color getColor(String color) {
if(color == null){
return null;
}
if(color.equalsIgnoreCase("RED")){
return new Red();
} else if(color.equalsIgnoreCase("GREEN")){
return new Green();
} else if(color.equalsIgnoreCase("BLUE")){
return new Blue();
}
return null;
}
}7、创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取相应的工厂。
FactoryProducer.java
public class FactoryProducer {
public static AbstractFactory getFactory(String choice){
if(choice.equalsIgnoreCase("SHAPE")){
return new ShapeFactory();//返回一个shape工厂类实例
} else if(choice.equalsIgnoreCase("COLOR")){
return new ColorFactory();//返回一个color工厂类实例
}
return null;
}
}8、测试：
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
//获取形状工厂
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
//获取形状为 Circle 的对象，通过形状工厂生成
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取形状为 Rectangle 的对象
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取形状为 Square 的对象
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
//获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");
//调用 Red 的 fill 方法
color1.fill();
//获取颜色为 Green 的对象
Color color2 = colorFactory.getColor("Green");
//调用 Green 的 fill 方法
color2.fill();
//获取颜色为 Blue 的对象
Color color3 = colorFactory.getColor("BLUE");
//调用 Blue 的 fill 方法
color3.fill();
}
}五、总结
普通工厂模式：
一个抽象产品类，可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别：
普通工厂模式只有一个抽象产品类，而抽象工厂模式有多个。
普通工厂模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。