实现了创建者和调用者的分离。
详细分类:简单工厂模式、工厂方法模式、抽象工厂模式。
核心本质
实例化对象,用工厂方法代替new操作。
将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。
- 简单工厂模式
用来生产同一等级结构中的任意产品。(对于增加新的产品,需要修改已有代码) - 工厂方法模式
用来生产同一等级结构中的固定产品。(支持增加任意产品) - 抽象工厂模式
用来生产不同产品族的全部产品。(对于增加新的产品,无能为力,支持增加产品族)
分类
1、简单工厂模式
要点
也叫静态工厂模式,一般使用静态方法,通过接收的参数的不同来返回不同的对象实例。
对于增加新产品无能为力,不修改代码的话,是无法扩展的
主要用来生产同一等级结构中的任意产品
案例
/**
* @author huangyzh
* @create 2020-05-13 23:15
*/
public interface Car {
void run();
}
/**
* @author huangyzh
* @create 2020-05-13 23:16
*/
public class Audi implements Car {
@Override
public void run() {
System.out.println("我是奥迪,正在路上跑……");
}
}
/**
* @author huangyzh
* @create 2020-05-13 23:16
*/
public class Byd implements Car {
@Override
public void run() {
System.out.println("我是比亚迪,正在出发!");
}
}
/**
* 测试没有工厂模式的情况下
* @author huangyzh
* @create 2020-05-13 23:19
*/
public class Test01 {
public static void main(String[] args) {
Car c1 = new Audi();
Car c2 = new Byd();
c1.run();
c2.run();
}
}
/**
* 简单工厂模式1
* @author huangyzh
* @create 2020-05-13 23:22
*/
public class CarFactory01 {
public static Car createCar(String type){
if("ad".equals(type)){
return new Audi();
}else if("byd".equals(type)){
return new Byd();
}
return null;
}
}
/**
* 简单工厂模式2
* @author huangyzh
* @create 2020-05-13 23:22
*/
public class CarFactory02 {
public static Car createAudi(){
return new Audi();
}
public static Car createByd(){
return new Byd();
}
}
/**
* 简单工厂模式的情况下
* @author huangyzh
* @create 2020-05-13 23:19
*/
public class Test02 {
public static void main(String[] args) {
Car ad = CarFactory01.createCar("ad");
ad.run();
Car byd = CarFactory01.createCar("byd");
byd.run();
}
}
2、工厂方法模式
要点
为了避免简单工厂模式的缺点→不完全满足OCP
工厂方法模式和简单工厂模式最大的不同在于,简单工厂模式只有一个(对于一个项目或一个独立模块而言)工厂类,而工厂方法模式有一组实现了系统接口的工厂类
用来生产同一等级结构中的固定产品。(支持增加任意产品)
案例
/**
* @author huangyzh
* @create 2020-05-13 23:15
*/
public interface Car {
void run();
}
/**
* @author huangyzh
* @create 2020-05-13 23:16
*/
public class Audi implements Car {
@Override
public void run() {
System.out.println("我是奥迪,正在路上跑……");
}
}
/**
* @author huangyzh
* @create 2020-05-13 23:16
*/
public class Byd implements Car {
@Override
public void run() {
System.out.println("我是比亚迪,正在出发!");
}
}
/**
* @author huangyzh
* @create 2020-05-14 0:08
*/
public interface CarFactory {
Car createCar();
}
/**
* @author huangyzh
* @create 2020-05-14 0:09
*/
public class AudiFactory implements CarFactory {
@Override
public Car createCar() {
return new Audi();
}
}
/**
* @author huangyzh
* @create 2020-05-14 0:09
*/
public class BydFactory implements CarFactory {
@Override
public Car createCar() {
return new Byd();
}
}
/**
* 工厂方法模式测试
* @author huangyzh
* @create 2020-05-13 23:19
*/
public class Test01 {
public static void main(String[] args) {
Car c1 = new AudiFactory().createCar();
Car c2 = new BydFactory().createCar();
c1.run();
c2.run();
}
}
简单工厂模式和工厂方法模式PK:
- 结构复杂度
简单工厂模式占优,简单工厂模式只需要一个工厂类,而工厂方法模式随着产品类个数增加而增加,会使类的个数越来越多,从而增加了结构的复杂程度。 - 代码复杂度
与结构复杂度是相互矛盾,简单工厂模式代码方面比工厂方法复杂,简单工厂模式工厂类随着产品类的增加需要增加很多方法(或代码),而工厂方法模式每个具体工厂类只完成单一任务,代码简洁。 - 客户端编码难度
工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP,但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类,在客户端无需实例化,这无疑是一个优点。 - 管理上难度
工厂方法模式完全满足OCP,使用它有非常良好的扩展性。但并不意味着简单工厂模式就没有扩展性,简单工厂模式同样具备良好的扩展性——扩展的时候仅需要修改少量的代码就可以满足扩展性的要求了,尽管没有完全满足OCP,但是要知道,就是在sun提供的java官方工具包中也有相当多没有满足OCP的例子。
从维护性的角度考虑,假定某个具体的产品类需要进行一定的修改,很可能需要修改对于的工厂类。当同时需要修改多个产品类的时候,对工厂类的修改会变得相当麻烦。反而简单工厂没有这些麻烦,当多个产品类需要修改时,简单工厂模式仍然仅仅需要修改唯一的工厂类。
根据设计理念建议:工厂方法模式。但实际上,一般使用简单工厂模式的情况居多。
3、抽象工厂模式
用来生产不同产品族的全部产品。(对于增加新的产品,无能为力,支持增加产品族)
抽象工厂模式是工厂方法模式的升级版本,在有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
案例
/**
* 座椅
* @author huangyzh
* @create 2020-05-14 0:41
*/
public interface Seat {
void message();
}
/**
* 轮胎
* @author huangyzh
* @create 2020-05-14 0:43
*/
public interface Tyre {
void revolve();
}
/**
* 发动机接口
* @author huangyzh
* @create 2020-05-14 0:38
*/
public interface Engine {
void run();
void start();
}
/**
* @author huangyzh
* @create 2020-05-14 0:40
*/
public class LowEngine implements Engine {
@Override
public void run() {
System.out.println("转的慢……");
}
@Override
public void start() {
System.out.println("启动慢……");
}
}
/**
* @author huangyzh
* @create 2020-05-14 0:39
*/
public class LuxuryEngine implements Engine {
@Override
public void run() {
System.out.println("转的快……");
}
@Override
public void start() {
System.out.println("启动快……自动启停");
}
}
//依次创建LuxurySeat、LowSeat实现Seat接口
//依次创建LowTyre、LuxuryTyre实现Tyre接口
/**
* @author huangyzh
* @create 2020-05-14 0:45
*/
public interface CarFactory {
Engine createEngine();
Seat createSeat();
Tyre createTyre();
}
/**
* @author huangyzh
* @create 2020-05-14 0:47
*/
public class LowCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LowEngine();
}
@Override
public Seat createSeat() {
return new LowSeat();
}
@Override
public Tyre createTyre() {
return new LowTyre();
}
}
/**
* @author huangyzh
* @create 2020-05-14 0:46
*/
public class LuxuryCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
return new LuxurySeat();
}
@Override
public Tyre createTyre() {
return new LuxuryTyre();
}
}
/**
* @author huangyzh
* @create 2020-05-14 0:48
*/
public class Test01 {
public static void main(String[] args) {
CarFactory factory = new LuxuryCarFactory();
Engine engine = factory.createEngine();
engine.run();
engine.start();
}
}
总结
- 1、简单工厂模式:虽然某种程度不满足设计原则,但实际使用最多。
- 2、工厂方法模式:不修改已有类的前提下,通过增加新的工厂类实现扩展。
- 3、抽象工厂模式:不可以增加产品,可以增加产品族。
应用场景:
- JDK中Calendar的getInstance方法
- JDBC中Connection对象的获取
- Hibernate中Session对象的获取
- Spring中IOC容器创建管理bean对象
- XML解析时的DocumentBuilderFactory创建解析器对象
- 反射中Class对象的newInstance()