工厂模式
实现了创建者和调用者的分离。
详细分类
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
核心本质
- 实例化对象，用工厂方法代替new操作；
- 将选择实现类、创建对象统一管理化控制，从而将调用者和我们的实现类解耦。
简单工厂
要点
- 简单工厂也称静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数不同，来返回不同的对象实例。
- 不符合开闭原则，当要增加新产品时，不得不修改内部代码。
类图：
image
代码实现：
用简单工厂模式模拟一个自动生产奥迪和比亚迪的车厂，创建奥迪和比亚迪实例。
/*
* 车辆类的接口
*/
public interface Car {
void run();
}
/*
* 奥迪车
*/
public class Aodi implements Car{
@Override
public void run() {
System.out.println("开奥迪！");
}
}
/*
* 比亚迪车
*/
public class Byd implements Car{
@Override
public void run() {
System.out.println("开比亚迪！");
}
}
/*
* 简单工厂
*/
public class CarFactory {
public static Car createCar(String type) {
if(type.equals("Aodi"))
return new Aodi();
else if(type.equals("Byd"))
return new Byd();
else
return null;
}
}
/*
* 客户端
*/
public class Client {
public static void main(String[] args) {
//生产一辆奥迪
Car aodi = CarFactory.createCar("Aodi");
//生产一辆比亚迪
Car byd = CarFactory.createCar("Byd");
aodi.run();
byd.run();
}
}
工厂方法
要点
- 为了避免简单工厂的缺点（无法增加新产品），不完全满足OCP（开闭原则）。
- 工厂方法模式和简单工厂模式的最大不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。
类图
image
代码实现
创建一个工厂接口，用来扩展工厂类。下面将工厂分为了奥迪工厂和比亚迪工厂两个分工厂，分别用来生产奥迪车和比亚迪车。
/*
* 车辆类的接口
*/
public interface Car {
void run();
}
/*
* 奥迪车
*/
public class Aodi implements Car{
@Override
public void run() {
System.out.println("开奥迪！");
}
}
/*
* 比亚迪车
*/
public class Byd implements Car{
@Override
public void run() {
System.out.println("开比亚迪！");
}
}
/*
* 工厂类接口
*/
public interface Factory {
Car createCar();
}
/*
* 生产奥迪车的分工厂
*/
public class AudiFactory implements Factory{
@Override
public Car createCar() {
return new Audi();
}
}
/*
* 生产比亚迪的分工厂
*/
public class BydFactory implements Factory{
@Override
public Car createCar() {
return new Byd();
}
}
/*
* 客户端
*/
public class Client {
public static void main(String[] args) {
//创建奥迪车
Car audi = new AudiFactory().createCar();
audi.run();
}
}
抽象工厂
要点
- 用来生产不同产品族的全部产品（对于新增的产品无能为力，但支持增加产品族——不同产品的组合）
- 抽象工厂模式是工厂模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
类图：
image
代码实现：
/*
* 发动机产品类的接口
*/
public interface Engine {
void run();
void start();
}
/*
* 高配的发动机
*/
public class LuxuryEngine implements Engine{
@Override
public void run() {
System.out.println("转的快！");
}
@Override
public void start() {
System.out.println("启动快！");
}
}
/*
* 低配的发动机
*/
public class LowEngine implements Engine{
@Override
public void run() {
System.out.println("转的慢！");
}
@Override
public void start() {
System.out.println("启动慢！");
}
}
/*
* 座椅类产品的接口
*/
public interface Seat {
void massage();
}
/*
* 高配真皮座椅
*/
public class LuxurySeat implements Seat{
@Override
public void massage() {
System.out.print("可以自动按摩");
}
}
/*
* 低配普通座椅
*/
public class LowSeat implements Seat{
@Override
public void massage() {
System.out.print("不可以自动按摩");
}
}
/*
* 工厂类接口
*/
public interface CarFactory {
Engine createEngine();
Seat createSeat();
}
/*
* 高配车工厂
*/
public class LuxuryCarFactory implements CarFactory{
public Engine createEngine() {
return new LuxuryEngine();
}
public Seat createSeat() {
return new LuxurySeat();
}
}
/*
* 低配车工厂
*/
public class LowCarFactory implements CarFactory{
public Engine createEngine() {
return new LowEngine();
}
public Seat createSeat() {
return new LowSeat();
}
}
/*
* 客户端
*/
public class Client {
public static void main(String[] args) {
//高配汽车
CarFactory factory1 = new LuxuryCarFactory();
Engine e = factory1.createEngine();
e.run();
e.start();
System.out.println("---------------------");
//低配汽车
CarFactory factory2 = new LowCarFactory();
Engine e2 = factory2.createEngine();
e2.run();
e2.start();
}
}
总结
工厂模式要点
- 简单工厂模式（静态工厂模式）
虽然某种程度不符合设计原则，但实际却使用最多。
- 工厂方法模式
不修改已有类的前提下，通过增加新的工厂类实现扩展。
- 抽象工厂模式
不可以增加产品，可以增加产品族。
应用场景：
- JDK的Calendar的getInstance方法
- JDBC中的Connection对象的获取
- Hibernate中SessionFactory创建Session
- Spring中的IOC容器创建管理bean对象
- XML解析时的DocumentBuilderFactory创建解析器对象
- 反射中Class对象的newInstance()
