Mark的技术博客

SAP顾问 | 咨询专家 | IT与AI技术探索者

吴让宇(Mark)

吴让宇(Mark)

SAP顾问 | 咨询专家 | IT与AI技术探索者

吴让宇(Mark)的个人技术博客,专注于SAP系统实施、行业方案咨询、IT技术与AI技术的研究与分享。

SAP Fiori ABAP CDS OData Dify Docker AI LLM

最新文章

经典 ABAP 报表 (★★★★)

#abap #abap-dialog

概述表

概念 要点
可执行程序 (类型 1) 报表程序
选择屏幕 报表的输入参数
列表输出 WRITE 语句输出
事件 控制处理流程

选择屏幕元素

1
2
3
4
PARAMETERS: pa_car TYPE bc400_s_flight-carrid,
pa_con TYPE bc400_s_flight-connid.

SELECT-OPTIONS: so_date FOR bc400_s_flight-fldate.
元素 语法 用途
PARAMETERS 单字段输入 每个字段一个值
SELECT-OPTIONS 范围/复杂选择 多个值、范围、排除条件

事件处理顺序

1
2
3
4
5
1. LOAD-OF-PROGRAM    → 程序加载
2. INITIALIZATION → 默认值(屏幕显示之前)
3. AT SELECTION-SCREEN → 验证输入(用户输入数据之后)
4. START-OF-SELECTION → 主处理(数据库读取、计算)
5. END-OF-SELECTION → 最终输出(可选)
📌INITIALIZATION 时机
INITIALIZATION 在选择屏幕显示之前运行。用于设置动态默认值。
📌START-OF-SELECTION
这是可执行程序的隐式事件块。INITIALIZATION 和下一个事件之间的任何代码都属于 START-OF-SELECTION。

文本元素

类型 用途 维护位置
选择文本 PARAMETERS 字段的标签 文本元素 → 选择文本
列表标题 列/标题文本 文本元素 → 列表标题
文本符号 可重用文本 (text-001) 文本元素 → 文本符号
💡选择文本维护
选择文本在程序的文本元素中维护——而不是直接在选择屏幕上。

考试/测试模式

场景/关键词 答案
“设置默认值的事件?” INITIALIZATION(屏幕显示之前)
“主处理事件?” START-OF-SELECTION
“选择文本在哪里维护?” 在文本元素中,而不是屏幕上
“SELECT-OPTIONS 的用途?” 范围/复杂选择条件

相关笔记

UML建模 练习

#practice #uml #modeling

📌核心模式
关键词 答案
类图 描述类的结构、属性、方法及类之间的关系
对象图 描述某一时刻对象实例及其关系的快照
关联 类之间的结构关系,表示对象间的连接
序列图 描述对象之间消息传递的时间顺序

题目1 - [记忆] 类图的基本组成

UML类图由哪些基本元素组成?请分别说明每个元素的作用。

📌查看答案
UML类图的基本组成元素:
  1. 类名区域(顶部):显示类的名称,抽象类用斜体表示
  2. 属性区域(中部):列出类的属性,格式为 可见性 名称: 类型,例如 - balance: Decimal
  3. 方法区域(底部):列出类的操作/方法,格式为 可见性 方法名(参数): 返回类型
  4. 可见性符号:
    • + 表示 public(公有)
    • - 表示 private(私有)
    • # 表示 protected(受保护)
  5. 关系线:类之间的关联、继承、依赖等关系

题目2 - [记忆] 类图与对象图的区别

请说明UML类图和对象图之间的三个主要区别。

📌查看答案
特性 类图 对象图
表示内容 类的定义(模板/蓝图) 类的实例(具体对象)
名称格式 仅类名,如 Customer 对象名:类名,如 john:Customer,或匿名 :Customer
属性值 仅显示属性名和类型,如 name: String 显示具体的属性值,如 name = "John"
下划线 无下划线 对象名和属性值都加下划线
用途 设计阶段的静态结构描述 描述系统在某一时刻的特定状态/快照

题目3 - [记忆] UML中的关联类型

请列举UML中类之间的四种主要关系类型,并简要说明每种关系的含义。

📌查看答案
  1. 关联(Association):表示两个类之间存在结构关系,对象之间互相知道对方。用实线表示,可标注多重性(如 1..*, 0..1)
  2. 聚合(Aggregation):一种特殊的关联,表示”整体-部分”关系,但部分可以独立于整体存在。用空心菱形表示
  3. 组合(Composition):更强的聚合关系,部分不能独立于整体存在,整体销毁时部分也被销毁。用实心菱形表示
  4. 依赖(Dependency):表示一个类的变化会影响另一个类,通常是临时性的使用关系。用虚线箭头表示

此外还有泛化(Generalization)/继承:子类继承父类,用空心三角箭头表示。


题目4 - [记忆] 序列图的组成元素

UML序列图由哪些基本元素组成?每个元素的作用是什么?

📌查看答案
序列图的基本组成元素:
  1. 参与者/角色(Actor):参与交互的对象或外部角色,放在图的顶部
  2. 生命线(Lifeline):从每个对象向下延伸的虚线,表示对象在时间轴上的存在周期
  3. 激活框(Activation Bar):生命线上的窄矩形,表示对象正在执行操作的时间段
  4. 消息(Message):
    • 同步消息(实心箭头 →):调用者等待返回
    • 异步消息(开放箭头 →):调用者不等待返回
    • 返回消息(虚线箭头 ←):表示方法的返回值
  5. 时间轴:从上到下表示时间的先后顺序

题目5 - [记忆] 多重性的表示

在UML类图中,关联关系上的多重性(Multiplicity)有哪些常见的表示方式?请解释每种方式的含义。

📌查看答案
常见的多重性表示:
符号 含义 示例
1 恰好一个 一个订单必须有一个客户
0..1 零个或一个(可选) 一个员工可能没有或有一个经理
* 或 0..* 零个或多个 一个客户可以有零个或多个订单
1..* 一个或多个(至少一个) 一个订单必须至少有一个订单项
n..m 从n到m个 一个团队有3到8个成员

多重性标注在关联线的两端,分别表示该端类的对象数量限制。


题目6 - [应用] 根据场景绘制类图关系

一个在线书店系统有以下需求:

  • 一个客户(Customer)可以下多个订单(Order)
  • 每个订单包含多个订单项(OrderItem)
  • 每个订单项对应一本书(Book)
  • 书属于一个类别(Category)

请描述这些类之间的UML关联关系,包括多重性。

📌查看答案
类之间的关联关系:
  1. Customer → Order:

    • Customer 端:1(一个客户)
    • Order 端:0..*(零个或多个订单)
    • 关系:一个客户可以下零个或多个订单
  2. Order → OrderItem:

    • Order 端:1(一个订单)
    • OrderItem 端:1..*(一个或多个订单项)
    • 关系:组合关系,订单项不能独立于订单存在
  3. OrderItem → Book:

    • OrderItem 端:1..*(每个订单项对应一本书)
    • Book 端:1(一本书)
    • 关系:关联关系
  4. Book → Category:

    • Book 端:*(多本书)
    • Category 端:1(属于一个类别)
    • 关系:关联关系,一本书属于一个类别

题目7 - [应用] 读取序列图场景

根据以下交互描述,判断在UML序列图中消息的顺序和类型:

  1. 用户(:User)调用系统(:System)的 login() 方法
  2. 系统调用数据库(:Database)的 authenticate() 方法并等待结果
  3. 数据库返回认证结果
  4. 认证成功后,系统调用会话管理器(:SessionManager)的 createSession() 方法
  5. 系统向用户返回登录结果

请画出消息的顺序并标注消息类型。

📌查看答案
序列图消息顺序(从上到下):
  1. :User → :System — login() — 同步消息(实心箭头)
  2. :System → :Database — authenticate() — 同步消息(实心箭头)
  3. :Database → :System — 认证结果 — 返回消息(虚线箭头)
  4. :System → :SessionManager — createSession() — 同步消息(实心箭头)
  5. :SessionManager → :System — 会话信息 — 返回消息(虚线箭头,隐含)
  6. :System → :User — 登录结果 — 返回消息(虚线箭头)

关键点:

  • 步骤1-3是嵌套调用,系统在等待数据库返回后才继续执行
  • 步骤4发生在步骤3返回之后,表示认证成功后的后续操作
  • 所有消息都是同步的(调用者等待返回)

题目8 - [分析] 选择合适的UML图

在以下三个场景中,你应该选择哪种UML图?请分析理由。

场景A:向新开发人员解释系统中各业务对象的静态结构和关系

场景B:调试一个用户登录流程中对象之间的交互顺序问题

场景C:验证在特定测试用例下,对象的属性值是否正确

📌查看答案

场景A — 选择类图(Class Diagram)

  • 理由:类图描述系统的静态结构,展示所有类、属性、方法以及类之间的关系(关联、继承等)
  • 类图是新开发人员理解系统架构的起点,可以快速了解”系统中有哪些核心对象,它们如何关联”
  • 这是面向对象设计中最基本、最常用的图

场景B — 选择序列图(Sequence Diagram)

  • 理由:序列图专门描述对象之间的动态交互,按时间顺序展示消息传递
  • 调试交互流程问题时,序列图可以清晰显示”谁在什么时候发送了什么消息,返回了什么”
  • 可以直观地发现消息顺序错误、缺少消息或错误的调用关系

场景C — 选择对象图(Object Diagram)

  • 理由:对象图展示类在特定时刻的实例快照,包含具体的属性值
  • 验证特定测试场景下,可以确认”此时刻各对象的属性值是否为预期值”
  • 对象图是类图的实例化,适合用于测试验证和文档示例

总结:静态结构用类图,动态交互用序列图,实例快照用对象图。


📌模式总结
关键词 答案
类图组成 类名 + 属性 + 方法 + 可见性 + 关系线
类图 vs 对象图 类图=模板定义,对象图=实例快照(有下划线和属性值)
四种关系 关联、聚合(空心菱形)、组合(实心菱形)、依赖(虚线)
序列图元素 生命线 + 激活框 + 同步/异步/返回消息
多重性 1, 0..1, , 1.. 表示对象数量约束
图的选择 静态结构→类图,动态交互→序列图,实例验证→对象图

OO编程模型 练习

#practice #oo-basics

📌核心模式
关键词 答案
封装 将数据和操作数据的方法捆绑在一起,隐藏内部实现细节
函数组 vs 类 函数组仅支持单一实例,类支持多实例化和完整的封装
过程式 vs OO 过程式以功能为中心,OO以数据/对象为中心

题目1 - [记忆] 封装的定义

请解释面向对象编程中”封装(Encapsulation)”的概念及其主要目的。

📌查看答案
封装是将数据(属性)和操作这些数据的方法捆绑在一个单元(类)中的机制。其主要目的是:
  1. 隐藏内部实现细节:外部代码无需了解对象内部如何工作
  2. 保护数据完整性:通过定义可见性(public、protected、private)控制外部对内部数据的访问
  3. 降低耦合度:内部实现的变化不会影响外部调用者

在ABAP中,类的公有区域(PUBLIC SECTION)定义外部接口,私有区域(PRIVATE SECTION)隐藏实现细节。


题目2 - [记忆] 函数组与类的区别

请列举函数组(Function Group)和类(Class)之间的三个主要区别。

📌查看答案
特性 函数组 类
实例化 仅支持单一实例(隐式全局数据) 支持多个独立实例
封装程度 函数组内的全局数据对所有函数模块可见,但封装机制较弱 提供严格的可见性控制(public/protected/private)
扩展性 不支持继承和多态 支持继承、多态和接口
状态管理 全局数据在函数组加载时初始化,仅一份 每个对象实例拥有独立的状态

题目3 - [记忆] 过程式编程模型的特点

请描述过程式编程模型的三个核心特征。

📌查看答案
过程式编程模型的核心特征:
  1. 以功能为中心:程序由一系列按顺序执行的功能/过程组成,数据在功能之间传递
  2. 数据与功能分离:数据结构独立定义,函数操作外部传入的数据
  3. 自顶向下的设计:复杂问题被分解为逐步细化的子程序调用层次

在ABAP中,过程式编程通过报表程序、函数模块和子程序实现。


题目4 - [记忆] 多实例化的含义

在面向对象编程中,”多实例化(Multiple Instantiation)”是什么意思?为什么它比函数组的单一实例更有优势?

📌查看答案
多实例化是指可以从同一个类创建多个独立的对象实例,每个实例拥有各自的属性值(状态)。

优势:

  • 独立状态:不同对象互不干扰,例如可以同时存在多个”订单”对象,各有不同的金额和状态
  • 内存管理:对象可按需创建和释放,通过垃圾回收机制自动管理
  • 灵活性:同一类型的多个实例可以同时存在于程序中,各自执行不同的操作

对比函数组:函数组只有一份全局数据,无法同时维护多个独立的状态。


题目5 - [记忆] 面向对象编程的四大特性

请列出面向对象编程的四大核心特性(也称为四大支柱),并简要说明每一个。

📌查看答案
  1. 封装(Encapsulation):将数据和操作数据的方法组合在一个单元中,通过可见性控制保护数据
  2. 继承(Inheritance):子类可以继承父类的属性和方法,并可以扩展或重定义它们,实现代码复用
  3. 多态(Polymorphism):同一操作作用于不同的对象时可以有不同的行为,通过方法重定义和接口实现
  4. 抽象(Abstraction):通过类和接口定义对象的抽象模型,隐藏复杂的实现细节,只暴露必要的接口

题目6 - [应用] 选择编程模型

公司需要开发一个库存管理系统,需要同时处理多个仓库的数据,每个仓库有独立的库存清单和操作日志。使用过程式编程(函数组)还是面向对象编程(类)更合适?请说明理由。

📌查看答案
面向对象编程(类)更合适。

理由:

  1. 多实例需求:系统需要同时管理多个仓库,每个仓库是独立的对象,拥有各自的库存清单和日志。类的多实例化天然支持这种需求
  2. 封装需求:每个仓库的库存数据和操作方法应封装在一起,防止外部直接修改数据,确保数据一致性
  3. 扩展性:未来可能需要添加新类型的仓库(如冷链仓库),可以通过继承实现扩展
  4. 维护性:对象之间的交互关系清晰,代码更易于维护和测试

如果使用函数组,则需要手动管理多个仓库的状态(例如使用内表存储),增加了复杂性且容易出错。


题目7 - [应用] 识别封装违规

以下ABAP代码片段中,类的封装是否被正确使用?请分析并指出问题。

1
2
3
4
5
CLASS lcl_bank_account DEFINITION.
PUBLIC SECTION.
DATA: balance TYPE p DECIMALS 2.
METHODS: deposit IMPORTING iv_amount TYPE p.
ENDCLASS.

假设外部代码直接修改 balance 字段。

📌查看答案
封装被违反。

问题分析:

  1. balance 属性被定义在 PUBLIC SECTION 中,这意味着外部代码可以直接读写该属性
  2. 外部代码可能绕过 deposit 方法直接修改余额,导致:
    • 无法验证金额的有效性(如负数存款)
    • 无法记录交易日志
    • 数据完整性无法保证

修正方案:

1
2
3
4
5
6
7
CLASS lcl_bank_account DEFINITION.
PUBLIC SECTION.
METHODS: deposit IMPORTING iv_amount TYPE p,
get_balance RETURNING VALUE(rv_balance) TYPE p.
PRIVATE SECTION.
DATA: balance TYPE p DECIMALS 2.
ENDCLASS.

将 balance 移至 PRIVATE SECTION,通过公共方法提供受控的访问。


题目8 - [分析] 编程范式对比分析

请从以下五个维度对比分析过程式编程和面向对象编程,并讨论在ABAP项目中何时应选择哪种范式。

📌查看答案
维度 过程式编程 面向对象编程
设计重心 以功能/过程为中心,数据在过程间流动 以数据/对象为中心,功能封装在对象内
数据管理 全局数据或通过参数传递 封装在对象内部,通过方法访问
复用机制 子程序和函数模块的调用 继承、组合、接口实现
扩展方式 修改现有代码或添加新函数 通过继承和重定义扩展,符合开闭原则
可维护性 大型项目中代码耦合度高,维护困难 职责清晰,耦合度低,易于维护和测试

选择建议:

  • 使用过程式的场景:简单的数据转换程序、一次性报表、批量数据处理脚本
  • 使用面向对象的场景:复杂的业务逻辑、需要多实例管理的系统、需要长期维护和扩展的应用、与设计模式结合的架构设计
  • 实际项目中:ABAP支持两种范式混合使用,但新开发应优先采用面向对象方式,以获得更好的可维护性和扩展性

📌模式总结
关键词 答案
封装 数据 + 方法捆绑,隐藏内部细节,通过可见性保护数据
函数组限制 单一实例,弱封装,无继承/多态
多实例化 同一类创建多个独立对象,各自维护状态
四大支柱 封装、继承、多态、抽象
过程式特征 以功能为中心,数据与功能分离,自顶向下
封装违规 属性放在公有区域,外部可直接修改,破坏数据完整性
范式选择 简单任务用过程式,复杂业务逻辑用OO,新开发优先OO

构造器与方法调用 (★★★)

#abap-objects #oo-basics #constructor #method-call

概览表

项目 关键点
实例构造器 METHODS: constructor, 创建对象时自动调用
静态构造器 CLASS-METHODS: class_constructor, 类首次使用时自动调用
方法调用 显式/简写/函数式三种语法
ME 方法内的自引用

构造器 (Constructor)

实例构造器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
CLASS lcl_vehicle DEFINITION.
PUBLIC SECTION.
METHODS: constructor
IMPORTING
!iv_make TYPE string
!iv_model TYPE string.
ENDCLASS.

CLASS lcl_vehicle IMPLEMENTATION.
METHOD constructor.
make = iv_make.
model = iv_model.
ENDMETHOD.
ENDCLASS.

调用方式:

1
2
3
4
CREATE OBJECT vehicle
EXPORTING
iv_make = 'BMW'
iv_model = 'X5'.

关键规则:

  • 每个类最多一个实例构造器
  • 构造器不能重定义(REDEFINITION)
  • 构造器只能定义在 PUBLIC SECTION(一般情况下)
  • 实例化对象时自动调用

静态构造器

1
2
3
4
CLASS lcl_vehicle DEFINITION.
PUBLIC SECTION.
CLASS-METHODS: class_constructor.
ENDCLASS.

关键规则:

  • 无参数,不能有 IMPORTING/EXPORTING
  • 类首次被使用时自动调用(CREATE OBJECT 或访问静态组件)
  • 只执行一次
  • 不能显式调用
⚠️静态构造器的调用时机
静态构造器在类首次被访问时自动触发。应避免在静态构造器中访问其他类的静态属性,因为可能导致不可预期的初始化顺序。

方法调用语法

三种调用方式

方式 语法 适用场景
显式调用 CALL METHOD ref->meth EXPORTING ... 兼容旧代码
简写调用 ref->meth( iv_param = value ). 推荐方式
函数式调用 DATA(result) = ref->meth( ). 有RETURNING参数的方法

参数传递简写

1
2
3
4
5
6
7
8
9
10
11
12
13
" 无参数
ref->meth( ).

" 一个IMPORTING参数
ref->meth( value ). " 位置参数
ref->meth( iv_param = value ). " 命名参数

" 多个IMPORTING参数
ref->meth( EXPORTING iv_a = a iv_b = b ).
ref->meth( iv_a = a iv_b = b ). " 简写可省略EXPORTING

" 接收RETURNING值
DATA(count) = ref->get_count( ).

函数式方法 (Functional Method)

有 RETURNING 参数的方法可以像函数一样使用:

1
2
3
4
5
6
7
" 直接在表达式中使用
IF ref->is_valid( ) = abap_true.
WRITE: / ref->get_name( ).
ENDIF.

" 链式调用(7.0 EhP2+)
ref->get_vehicle( )->get_motor( )->get_power( ).

自引用 ME

1
2
3
4
METHOD some_method.
me->attribute = value. " 明确指向自身属性
CALL METHOD me->method. " 调用自身方法
ENDMETHOD.
  • ME 是预定义的引用变量
  • 在每个实例方法中自动可用
  • 指向当前对象实例本身
  • 常用于区分参数名和属性名同名的情况

私有方法与公有方法的协作

1
2
3
4
5
6
7
8
9
10
11
外部调用者
│
↓
┌──────────────────┐
│ 公有方法 │ ← 外部接口
│ (入口点) │
│ │ │
│ ↓ │
│ 私有方法 │ ← 内部实现细节
│ (辅助逻辑) │
└──────────────────┘
💡私有方法的作用
私有方法将复杂的实现细节隐藏在公有方法背后,实现真正的封装。

考试/测试模式

场景/关键词 答案
“构造器能重定义吗” 不能
“静态构造器参数” 不能有任何参数
“静态构造器何时调用” 类首次被使用时,自动调用一次
“ME的用途” 区分同名参数和属性,明确自引用
“函数式方法” 有 RETURNING 参数的方法
“链式调用” 7.0 EhP2+ 支持 ref->meth( )->meth2( )

调整 SAP 标准软件 (★★★)

#abap #abap-enhancement

概述表

术语 要点
原始对象 在其开发系统(”出生地”)中的对象
副本 通过传输到达另一个系统的对象
更正 修改原始对象
修复 修改副本
修改 修复 SAP 对象(客户系统)

四种调整选项

选项 描述 版本升级安全?
客户开发 在 Y*/Z* 命名空间中创建自有对象 是
自定义 通过维护事务配置系统属性 是
增强(首选) 与版本无关的调整 是
修改(最后手段) 直接修改 SAP 代码 否 — 升级时需要调整
⚠️修改与增强
增强始终是首选方案。修改在升级时需要进行修改调整(将旧修改版本与新 SAP 版本进行比较)。这既耗时又容易出错。

增强类型

程序出口(最重要)

  • 用户出口:较旧的技术
  • 客户出口:更结构化的方式
  • BTEs(业务交易事件)
  • BAdIs(业务附加项)

其他增强类型

类型 描述
菜单出口 SAP 菜单项链接到客户代码
屏幕出口 SAP 子屏幕区域用于自定义屏幕
字段文档 用自己的文本覆盖 F1 帮助
字段标签 覆盖数据元素标签
附加结构 向 SAP 透明表添加字段

原始对象和副本

1
2
3
开发系统 (原始对象) ──传输──→ 质量系统 (副本)
更正 = 修改原始对象 修复 = 修改副本
升级时的修改调整
📌原始对象不能被覆盖
原始对象永远不会被传输覆盖。

SSCR 注册

注册 用途
开发者密钥 每个开发者一次(用户 + 系统许可证)
对象密钥 每个被修改的 SAP 对象

考试/测试模式

场景/关键词 答案
“首选调整方式?” 增强(而非修改)
“为什么要避免修改?” 升级时需要调整
“原始对象可以被覆盖吗?” 不可以——永远不能
“更正与修复的区别?” 更正 = 修改原始对象;修复 = 修改副本
“附加结构?” 向 SAP 表添加字段而无需修改

相关笔记

面向对象编程模型 (★★★)

#abap-objects #oo-basics

概览表

项目 关键点
过程式模型 数据与函数分离,全局变量可被任意访问
函数组 封装数据与服务,但只能有一个实例
OO模型 封装 + 多实例化 + 继承 + 多态

过程式编程模型

数据和函数通常分开存储:

  • 全局变量存储数据
  • 子程序(Subroutines) 存储函数
  • 每个子程序都可以访问任何变量 → 无法保证一致的数据访问

典型过程式ABAP程序结构:

1
2
3
4
5
类型定义 + 数据声明          (数据)
├── Modularization Units (函数)
│ ├── Subroutines (FORM)
│ └── Function Modules
└── 全局数据无特殊保护
⚠️过程式模型的风险
主程序层面上,全局数据对象没有特殊保护。任何地方都可以读写全局变量。

使用函数组实现封装

函数组提供了一定程度的封装:

  • 函数组加载到独立内存区域
  • 主程序只能通过函数模块访问函数组的数据
  • 不能直接访问函数组的全局数据
1
2
3
4
5
6
7
8
9
┌─────────────────┐     ┌──────────────────┐
│ Main Program │ │ Function Group │
│ │────→│ Function Modules │
│ │调用 │ ├ INC_SPEED() │
│ │ │ ├ DEC_SPEED() │
│ │ │ └ GET_SPEED() │
│ │ ✗ │ Global Data: │
│ │────→│ SPEED (不可直接) │
└─────────────────┘ └──────────────────┘

OO编程的关键特性

特性 说明
封装 对象保护自身数据,外部只能通过公有方法访问
多实例化 同一个类可以创建多个独立的运行时实例
继承 子类继承父类的特征,可以扩展和修改
多态 同一接口可以有不同的实现

多实例化 — OO的核心优势

函数组的局限:一个程序中一个函数组只有一个实例。如果要管理多个”车辆”,需要额外的编程和管理工作。

OO编程:可以轻松创建多个独立对象实例:

1
2
3
4
5
6
7
CLASS LCL_VEHICLE 定义
├── 对象1: car (make=BMW, speed=100)
├── 对象2: truck (make=VW, speed=60)
├── 对象3: bus (make=Mercedes, speed=80)
└── 对象4: car (make=Audi, speed=120)
→ 所有对象共享相同数据结构和功能
→ 但各自有独立的数据值

内存管理

1
2
3
4
5
6
7
8
┌── Internal Session ──────────────────────┐
│ Main Program │
│ ├── 对象1 (LCL_VEHICLE) [独立数据区] │
│ ├── 对象2 (LCL_VEHICLE) [独立数据区] │
│ ├── 对象3 (LCL_VEHICLE) [独立数据区] │
│ └── 函数组 [独立数据区] │
│ → 所有区域相互隔离,数据受保护 │
└──────────────────────────────────────────┘

考试/测试模式

场景/关键词 答案
“函数组 vs 类的区别” 函数组只能单实例,类支持多实例化
“封装在过程式中的实现” 函数组可以封装,但不够灵活
“OO的主要优势” 封装 + 多实例 + 继承 + 多态
“对象存储在哪里” 与主程序相同的内部会话中,但数据区分离

SAP 列表查看器 (ALV) (★★★)

#abap #abap-dialog

概述表

类 用途
CL_SALV_TABLE 简单 ALV 显示
CL_GUI_ALV_GRID 自定义容器中的高级 ALV

简单 ALV (CL_SALV_TABLE)

1
2
3
4
5
6
7
DATA: go_alv TYPE REF TO cl_salv_table.

CALL METHOD cl_salv_table=>factory
IMPORTING r_salv_table = go_alv
CHANGING t_table = gt_flights.

go_alv->display( ).
  • 最少代码实现表格显示
  • 自动从 ABAP 字典获取列标题
  • 内置排序、筛选、汇总功能

带容器控件的高级 ALV

组件 角色
自定义容器 ALV 的屏幕区域
CL_GUI_ALV_GRID 功能完整的网格控件
字段目录 列定义
布局 显示设置

关键 ALV 方法

方法 用途
factory 创建 ALV 实例
display 显示 ALV
set_table_for_first_display 初始数据显示 (CL_GUI_ALV_GRID)
refresh_table_display 更新数据

考试/测试模式

场景/关键词 答案
“简单 ALV 类?” CL_SALV_TABLE
“高级 ALV 类?” CL_GUI_ALV_GRID
“ALV 列标题来自?” ABAP 字典定义

相关笔记

第 9 单元:SAP 软件调整练习(8 道题)

#practice #abap #abap-enhancement

相关概念

📌关键模式(点击展开)
关键词 答案
原始对象 对象的出生地
更正 修改原始对象
修复 修改副本
修改 在客户系统中修复 SAP 对象
首选方案 增强(而非修改)

问题 1 - 原始对象与副本 [recall]

原始对象和副本的区别是什么?

📌显示答案
原始对象位于其开发的系统(”出生地”)。副本是同一对象传输到另一个系统后的版本。

问题 2 - 更正与修复 [recall]

定义更正和修复。

📌显示答案
更正:修改原始对象(开发任务)。修复:修改副本(修复任务)。

问题 3 - 修改的问题 [recall]

为什么应该避免修改?

📌显示答案
在升级期间,修改过的对象可能被覆盖。需要进行修改调整——手动重新应用更改。既耗时又容易出错。

问题 4 - 增强的优势 [recall]

为什么增强优于修改?

📌显示答案
与版本无关——升级时无需调整。相同功能,无维护负担。

问题 5 - 四种选项 [recall]

列出调整 SAP 软件的四种选项。

📌显示答案
  1. 客户开发 — 在客户命名空间中创建自有对象
  2. 自定义 — 通过维护事务配置系统属性
  3. 增强 — 扩展 SAP 对象而不修改
  4. 修改 — 直接更改(最后手段)

问题 6 - 增强类型 [recall]

列举至少四种增强类型。

📌显示答案
程序出口(用户出口、客户出口、BTE、BAdI)、菜单出口、屏幕出口、附加结构、字段文档/标签覆盖。

问题 7 - SSCR 密钥 [application]

开发者需要修改 SAP 标准对象。需要哪些注册?

📌显示答案
  1. 开发者密钥(一次性,关联用户 + 系统许可证)
  2. 对象密钥(每个 SAP 对象:名称 + 类型 + 系统许可证)

问题 8 - 附加结构 [analysis]

附加结构与修改有什么区别?

📌显示答案
附加结构向表添加字段而不改变 SAP 对象。它是一种增强——在升级时无需调整即可保留。

📌模式总结(点击展开)
关键词 答案
原始对象 开发系统
副本 传输到另一个系统
更正 修改原始对象
修复 修改副本
修改 修复 SAP 对象
增强 与版本无关,首选方案
附加结构 无需修改即可添加字段
SSCR 开发者密钥 + 对象密钥

对象与引用 (★★★)

#abap-objects #oo-basics #class-definition

概览表

项目 关键点
引用变量 指向对象的指针,用 TYPE REF TO 声明
CREATE OBJECT 在内存中创建类的新实例
垃圾回收 无引用的对象自动被回收
自引用 ME 方法内指向当前对象自身的引用

引用变量

引用变量是指向对象的指针:

1
DATA: ref_vehicle TYPE REF TO lcl_vehicle.
  • 声明时引用变量为初始值 (不指向任何对象)
  • 使用 CREATE OBJECT 创建实际对象

创建对象

1
2
3
4
5
" 声明引用
DATA: vehicle TYPE REF TO lcl_vehicle.

" 创建对象实例
CREATE OBJECT vehicle.

对象在内存中的表示

1
2
3
4
5
6
引用变量:  vehicle ──────→ ┌───────────────────┐
│ LCL_VEHICLE 实例 │
│ make = "" │
│ model = "" │
│ speed = 0 │
└───────────────────┘
📌引用 vs 对象
  • 引用变量和对象是两个不同的东西
  • 多个引用变量可以指向同一个对象
  • 引用变量本身也可以是对象的属性(关联关系)

多个引用指向同一对象

1
2
3
4
5
DATA: ref1 TYPE REF TO lcl_vehicle,
ref2 TYPE REF TO lcl_vehicle.

CREATE OBJECT ref1.
ref2 = ref1. " ref1 和 ref2 指向同一个对象

访问对象组件

1
2
3
4
5
6
7
8
" 访问属性
WRITE: / vehicle->make.

" 调用方法
vehicle->set_type( iv_make = 'BMW' iv_model = 'X5' ).

" 静态组件访问
WRITE: / lcl_vehicle=>count. " 类名=>组件名
语法 用途 示例
ref->attr 通过引用访问实例属性 vehicle->make
ref->meth( ) 通过引用调用实例方法 vehicle->set_type( )
class=>attr 访问静态属性 lcl_vehicle=>count
class=>meth( ) 调用静态方法 lcl_vehicle=>get_count( )

垃圾回收 (Garbage Collection)

ABAP 运行时系统自动管理对象的生命周期:

  • 当对象没有任何引用指向它时,成为垃圾
  • 垃圾回收器会自动清理这些对象
  • 开发者不需要手动释放内存
1
2
3
ref1 ──→ [对象A]     ← 有引用,不会被回收
ref2 ──→ [对象B] ← 有引用,不会被回收
[对象C] ← 无引用,将被垃圾回收

对象作为属性(关联)

对象引用可以作为其他对象的属性,实现关联关系:

1
2
3
4
CLASS lcl_vehicle DEFINITION.
PRIVATE SECTION.
DATA: mo_motor TYPE REF TO lcl_motor. " 组合关系
ENDCLASS.

内表中存储对象引用

1
2
3
4
5
6
7
8
9
DATA: lt_vehicles TYPE TABLE OF REF TO lcl_vehicle.

" 添加引用到内表
APPEND vehicle TO lt_vehicles.

" 遍历
LOOP AT lt_vehicles INTO DATA(lo_veh).
lo_veh->display( ).
ENDLOOP.

考试/测试模式

场景/关键词 答案
“->” vs “=>” -> 用于实例组件,=> 用于静态组件
“对象何时被回收” 没有引用指向时自动回收
“引用变量初始值” 不指向任何对象(NULL引用)
“对象存在哪里” 与程序相同的内部会话中,独立数据区

类型转换与多态 (★★★)

#abap-objects #inheritance #casting #polymorphism

概览表

项目 关键点
Up-cast 子类→父类引用,隐式安全
Down-cast 父类→子类引用,显式 ?=,可能运行时错误
多态 同一接口不同实现,通过动态绑定实现
泛型调用 使用父类/接口引用统一调用

Up-cast (向上转型 / Widening Cast)

1
2
3
4
5
DATA: lo_vehicle TYPE REF TO lcl_vehicle,
lo_car TYPE REF TO lcl_car.

CREATE OBJECT lo_car.
lo_vehicle = lo_car. " Up-cast: 隐式,总是安全

特性

  • 使用 = 赋值
  • 隐式,编译器允许
  • 总是安全 — 子类一定是父类
  • 可见的组件减少(只能访问父类定义的组件)
  • 类型兼容性增加(可以接受更多动态类型)
1
2
3
转换前: lo_car     → 可访问 [Vehicle + Car 组件]
转换后: lo_vehicle → 只能访问 [Vehicle 组件]
视角变窄,但兼容性变宽
💡Up-cast 的典型用途
将不同子类的对象收集到一个统一类型的内表中:
1
2
3
4
5
6
DATA: lt_vehicles TYPE TABLE OF REF TO lcl_vehicle.
lt_vehicles = VALUE #(
( NEW lcl_car( ) ) " 自动 up-cast
( NEW lcl_truck( ) ) " 自动 up-cast
( NEW lcl_bus( ) ) " 自动 up-cast
).

Down-cast (向下转型 / Narrowing Cast)

1
2
3
4
5
6
DATA: lo_vehicle TYPE REF TO lcl_vehicle,
lo_car TYPE REF TO lcl_car.

CREATE OBJECT lo_car.
lo_vehicle = lo_car. " Up-cast
lo_car ?= lo_vehicle. " Down-cast: 需要显式 ?=

特性

  • 使用 ?= 赋值
  • 显式,开发者自己负责
  • 可能失败 — 如果实际对象不是目标类型
  • 失败时触发 CX_SY_MOVE_CAST_ERROR 异常
1
2
安全:  lo_vehicle 实际指向 lcl_car → ?= 成功
危险: lo_vehicle 实际指向 lcl_truck → ?= lcl_car → 运行时错误!

安全的 Down-cast

1
2
3
4
5
6
7
8
9
10
11
" 方法1: TRY-CATCH
TRY.
lo_car ?= lo_vehicle.
CATCH cx_sy_move_cast_error.
" 处理类型不匹配
ENDTRY.

" 方法2: RTTI 类型检查
IF cl_abap_classdescr=>get_relative_name( lo_vehicle ) = 'LCL_CAR'.
lo_car ?= lo_vehicle.
ENDIF.

多态 (Polymorphism)

多态是继承最重要的应用:

  • 通过父类引用调用方法
  • 实际执行的是子类的重定义实现
  • 运行时动态绑定
1
2
3
4
5
6
7
8
9
10
" 创建不同子类对象
DATA: lt_vehicles TYPE TABLE OF REF TO lcl_vehicle.
APPEND NEW lcl_car( ) TO lt_vehicles.
APPEND NEW lcl_truck( ) TO lt_vehicles.
APPEND NEW lcl_bus( ) TO lt_vehicles.

" 统一调用 — 多态!
LOOP AT lt_vehicles INTO DATA(lo_v).
lo_v->display( ). " 每个对象执行自己的 display 实现
ENDLOOP.

多态的工作原理

1
2
3
4
5
6
7
静态类型: lcl_vehicle          → 编译时检查 vehicle 组件
动态类型: 实际的 car/truck/bus → 运行时调用实际实现

lo_v->display( )
→ lo_v 指向 car? → 执行 lcl_car=>display( )
→ lo_v 指向 truck? → 执行 lcl_truck=>display( )
→ lo_v 指向 bus? → 执行 lcl_bus=>display( )

泛型调用 (Generic Calls)

将 up-cast 和多态结合,实现统一的处理逻辑:

1
2
3
4
5
6
7
8
" 方法参数使用父类类型
METHODS: process_vehicle
IMPORTING io_vehicle TYPE REF TO lcl_vehicle.

" 可以传入任何子类
process_vehicle( lo_car ).
process_vehicle( lo_truck ).
process_vehicle( lo_bus ).

Up-cast vs Down-cast 对比

特性 Up-cast Down-cast
方向 子→父 父→子
赋值符 = ?=
安全性 总是安全 可能失败
视角 变窄 变宽
兼容性 变宽 变窄
何时使用 收集不同子类 恢复具体类型

考试/测试模式

场景/关键词 答案
“up-cast赋值符” =,隐式安全
“down-cast赋值符” ?=,显式,可能失败
“多态的核心” 父类引用调用方法,运行时动态绑定到子类实现
“何时需要down-cast” 需要访问子类特有组件时
“down-cast失败” 触发 CX_SY_MOVE_CAST_ERROR
“泛型调用的实现” 方法参数使用父类/接口类型
0%