工厂模式
工厂模式:
实现了创建者和调用者的分离。
详细分类:
简单工厂模式(静态工厂模式)
- 虽然某种程度不符合设计原则,但实际使用最多。
工厂方法模式
- 不修改已有类的前提下,通过增加新的工厂类实现扩展。
抽象工厂模式
- 不可以增加产品,可以增加产品族
面向对象设计的基本原则:
OCP(开闭原则,Open-Closed Principle):一个软件的实体应当对扩展开放,对修改关闭。
DIP(依赖倒转原则,Dependence Inversion Principle):要针对接口编程,不要针对实现编程。
LOD(迪米特法则,Law of Demeter):只与你直接的朋友通信,而避免和陌生人通信。
核心本质:
- 实例化对象,用工厂方法代替new操作。
- 将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。
工厂模式:
- 简单工厂模式:用来生产同一等级结构中的任意产品。(对于增加新的产品,需要修改已有代码)
- 工厂方法模式:用来生产同一等级结构中的固定产品。(支持增加任意产品)
- 抽象工厂模式:用来生产不同产品族的全部产品。(对于增加新的产品,无能为力;支持增加产品族)
需要使用的类和接口
package com.kevin.创建型模式.工厂模式.simplefactory;
/**
* @author kevin
* @version 1.0
* @description 实现的接口类
* @createDate 2019/2/17
*/
public interface Car {
void run();
}
package com.kevin.创建型模式.工厂模式.simplefactory;
/**
* @author kevin
* @version 1.0
* @description
* @createDate 2019/2/17
*/
public class Audi implements Car {
@Override
public void run() {
System.out.println("奥迪行驶中");
}
}
package com.kevin.创建型模式.工厂模式.simplefactory;
/**
* @author kevin
* @version 1.0
* @description
* @createDate 2019/2/17
*/
public class Byd implements Car {
@Override
public void run() {
System.out.println("比亚迪行驶中");
}
}
不使用简单工厂的情况
package com.kevin.创建型模式.工厂模式.simplefactory;
/**
* @author kevin
* @version 1.0
* @description 测试未使用工厂模式
* @createDate 2019/2/17
*/
public class Test {
public static void main(String[] args) {
// 普通创建方式,需要选择调用哪个类
Car c1 = new Audi();
Car c2 = new Byd();
c1.run();
c2.run();
}
}
UML类图
问题:调用方需要知道创建哪个类?比较麻烦
使用简单工厂模式
package com.kevin.创建型模式.工厂模式.simplefactory;
/**
* @author kevin
* @version 1.0
* @description 简单工厂模式
* 1.简单工厂模式也叫做静态工厂模式,就是工厂类一般使用静态方法,通过接收的参数的不同来返回不同的对象实例。
* 2.对于增加新产品无能为力,不修改代码的话是无法扩展的。
* @createDate 2019/2/17
*/
public class CarFactory {
// 方式一:
public static Car createCar(String type) {
if("奥迪".equals(type)){
return new Audi();
} else if("比亚迪".equals(type)){
return new Byd();
} else {
return null;
}
}
// 方式二:
public static Car createAudi(){
return new Audi();
}
public static Car createByd(){
return new Byd();
}
}
package com.kevin.创建型模式.工厂模式.simplefactory;
/**
* @author kevin
* @version 1.0
* @description 测试工厂模式
* @createDate 2019/2/17
*/
public class Test {
public static void main(String[] args) {
// 简单工厂模式
// 方式一:调用方便,不需要有调用方选择调用那个实例,只需要传入参数
CarFactory.createCar("奥迪").run();
CarFactory.createCar("比亚迪").run();
//c3.run();
// 方式二:
CarFactory.createAudi().run();
CarFactory.createByd().run();
}
}
UML类图
注:
- 简单工厂模式也叫做静态工厂模式,就是工厂类一般使用静态方法,通过接收的参数的不同来返回不同的对象实例。
- 对于增加新产品无能为力,不修改代码的话是无法扩展的。
工厂方法模式
package com.kevin.创建型模式.工厂模式.factorymethod;
/**
* @author kevin
* @version 1.0
* @description 工厂方法模式
* @createDate 2019/2/17
*/
public interface CarFactory {
Car createCar();
}
package com.kevin.创建型模式.工厂模式.factorymethod;
/**
* @author kevin
* @version 1.0
* @description
* 为了避免简单工厂模式的缺点,不完全满足OCP。
* 工厂方法模式和简单工厂模式最大的不同在于,简单工厂模式只有一个(对于一个项目或者一个独立模块而言)工厂类,
* 而工厂方法模式有一组实现了相同接口的工厂类。
* @createDate 2019/2/17
*/
public class AudiFactory implements CarFactory{
@Override
public Car createCar() {
return new Audi();
}
}
package com.kevin.创建型模式.工厂模式.factorymethod;
/**
* @author kevin
* @version 1.0
* @description
* @createDate 2019/2/17
*/
public class BydFactory implements CarFactory{
@Override
public Car createCar() {
return new Byd();
}
}
package com.kevin.创建型模式.工厂模式.factorymethod;
/**
* @author kevin
* @version 1.0
* @description 测试工厂方法模式
* @createDate 2019/2/17
*/
public class Test {
public static void main(String[] args) {
Car c1 = new AudiFactory().createCar();
Car c2 = new BydFactory().createCar();
c1.run();
c2.run();
}
}
UML类图
注:
* 为了避免简单工厂模式的缺点,不完全满足OCP。 * 工厂方法模式和简单工厂模式最大的不同在于,简单工厂模式只有一个(对于一个项目或者一个独立模块而言)工厂类, * 而工厂方法模式有一组实现了相同接口的工厂类。
抽象工厂模式
用于生产不同产品族的全部产品。(对于增加新的产品,无能为力;支持增加产品族)
抽象工厂模式是工厂方法模式的升级版本,在有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
发动机
package com.kevin.创建型模式.工厂模式.abstractfactory;
/**
* @author kevin
* @version 1.0
* @description 发动机
* @createDate 2019/2/17
*/
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 com.kevin.创建型模式.工厂模式.abstractfactory;
/**
* @author kevin
* @version 1.0
* @description 座椅
* @createDate 2019/2/17
*/
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 com.kevin.创建型模式.工厂模式.abstractfactory;
import javax.swing.plaf.synth.SynthOptionPaneUI;
/**
* @author kevin
* @version 1.0
* @description 轮胎
* @createDate 2019/2/17
*/
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 com.kevin.创建型模式.工厂模式.abstractfactory;
/**
* @author kevin
* @version 1.0
* @description 工厂
* @createDate 2019/2/17
*/
public interface CarFactory {
Engine createEngine();
Seat createSeat();
Tyre createTyre();
}
高端产品族工厂
package com.kevin.创建型模式.工厂模式.abstractfactory;
/**
* @author kevin
* @version 1.0
* @description 高端产品族工厂
* @createDate 2019/2/17
*/
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();
}
}
低端产品族工厂
package com.kevin.创建型模式.工厂模式.abstractfactory;
/**
* @author kevin
* @version 1.0
* @description 低端产品族工厂
* @createDate 2019/2/17
*/
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();
}
}
测试抽象工厂模式
package com.kevin.创建型模式.工厂模式.abstractfactory;
/**
* @author kevin
* @version 1.0
* @description 测试抽象工厂模式
* @createDate 2019/2/17
*/
public class Test {
public static void main(String[] args) {
// 高端工厂
Engine luxuryEngine = new LuxuryCarFactory().createEngine();
luxuryEngine.run();
luxuryEngine.start();
// 低端工厂
Engine lowEngine = new LowCarFactory().createEngine();
lowEngine.run();
lowEngine.start();
}
}
UML类图
注:抽象工厂模式,通过不同的产品族创建产品。
应用场景:
- JDK中Calendar的getInstance方法
- JDBC中Connection对象的获取
- Hibernate中SessionFactory创建Session
- spring中IOC容器创建管理bean对象
- XML解析时的DocumentBuilderFactory创建解析器对象
- 反射中Class对象的newInstance()
更多推荐
Java的23种设计模式---(2)工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)
发布评论