SAP ABAP – 快速指南
SAP ABAP – 快速指南
SAP ABAP – 概述
ABAP 代表高级业务应用程序编程，一种 4GL（第 4 代）语言。目前，它与 Java 一起被定位为 SAP 应用服务器编程的主要语言。
让我们从 SAP 系统的高层架构开始。典型 SAP 系统的三层客户端/服务器架构如下图所示。
的表示层包含可以用来控制SAP系统的任何输入设备。这可以是网络浏览器、移动设备等。所有的中央处理都在应用服务器中进行。应用服务器本身不仅仅是一个系统，它可以是处理系统的多个实例。服务器与通常保存在单独服务器上的数据库层通信，主要是出于性能原因和安全考虑。通信发生在系统的每一层之间，从表示层到数据库，然后备份链。
注意– ABAP 程序在应用程序服务器级别运行。软件的技术分发与其物理位置无关。这意味着基本上所有三个级别都可以安装在一台计算机上，或者每个级别都可以安装在不同的计算机或服务器上。
ABAP 程序驻留在 SAP 数据库中。它们在作为 SAP 内核一部分的运行时系统的控制下执行。运行时系统处理所有 ABAP 语句，控制流逻辑并响应用户事件。
因此，与 C++ 和 Java 不同，ABAP 程序不存储在单独的外部文件中。在数据库内部，ABAP 代码以两种形式存在 –
-
可以使用 ABAP 工作台工具查看和编辑的源代码。
-
生成的代码，这是一个二进制表示。如果您熟悉 Java，则此生成的代码有点类似于 Java 字节码。
运行时系统可以被认为是一个虚拟机，类似于 Java 虚拟机。ABAP 运行时系统的一个关键组件是将独立于数据库的语句 (Open SQL) 转换为底层数据库 (Native SQL) 能够理解的语句的数据库接口。SAP 可以使用多种数据库，并且相同的 ABAP 程序可以在所有这些数据库上运行。
SAP ABAP – 环境
报告是熟悉一般 ABAP 原则和工具的良好起点。ABAP 报告用于许多领域。在本章中，我们将看到编写一个简单的 ABAP 报告是多么容易。
你好 ABAP
让我们从常见的“Hello World”示例开始。
每个 ABAP 语句都以 ABAP 关键字开始，以句点结束。关键字必须至少由一个空格分隔。对 ABAP 语句使用一行还是多行都没有关系。
您需要使用 ABAP 编辑器输入代码，该编辑器是随 SAP NetWeaver 应用服务器 ABAP（也称为“AS ABAP”）提供的 ABAP 工具的一部分。
“AS ABAP”是一个应用服务器，拥有自己的数据库、ABAP 运行时环境和 ABAP 开发工具，如 ABAP Editor。AS ABAP 提供了一个独立于硬件、操作系统和数据库的开发平台。
使用 ABAP 编辑器
步骤 1 – 启动事务 SE38 以导航到 ABAP 编辑器（在下一章中讨论）。让我们开始创建一个报表，它是众多 ABAP 对象之一。
步骤 2 – 在编辑器的初始屏幕上，在输入字段 PROGRAM 中指定报告的名称。您可以将名称指定为 ZHELLO1。前面的 Z 对名称很重要。Z 确保您的报表位于客户命名空间中。
客户命名空间包括所有带有前缀 Y 或 Z 的对象。当客户或合作伙伴创建对象（如报表）时，总是使用它来区分这些对象与 SAP 的对象并防止名称与对象发生冲突。
第 3 步– 您可以用小写字母键入报告名称，但编辑器会将其更改为大写。因此 ABAP 对象的名称“不”区分大小写。
步骤 4 – 指定报告名称后，单击创建按钮。将弹出一个弹出窗口 ABAP：程序属性，您将提供有关报告的更多信息。
步骤 5 – 选择“可执行程序”作为报告类型，输入标题“我的第一个 ABAP 报告”，然后选择“保存”以继续。接下来会弹出 CREATE OBJECT DIRECTORY ENTRY 窗口。选择 LOCAL OBJECT 按钮，弹出窗口将关闭。
您可以通过在 REPORT 语句下方输入 WRITE 语句来完成您的第一个报告，以便完整的报告仅包含如下两行 –
REPORT ZHELLO1. WRITE 'Hello World'.
开始报告
我们可以使用键盘 (Ctrl + S) 或保存图标（命令字段旁边的右侧）来保存报告。ABAP 开发发生在 AS ABAP 中。
启动报告就像保存一样简单。单击 ACTIVATION 按钮（左侧开始图标旁边）并使用图标 DIRECT PROCESSING 或 F8 功能键启动报告。标题“我的第一个 ABAP 报告”以及输出“Hello World”也会显示出来。这是输出 –
My First ABAP Report Hello World
只要您不激活新报告或激活对现有报告的更改，它就与其用户无关。这在中央开发环境中很重要，您可以在该环境中处理其他开发人员在其项目中使用的对象。
查看现有代码
如果您查看程序字段并双击值 ZHELLO1，ABAP 编辑器将显示您的报告的代码。这称为前向导航。双击对象名称可在适当的工具中打开该对象。
SAP ABAP – 屏幕导航
为了理解 SAP ABAP，您需要具备登录、ABAP 编辑器、注销等屏幕的基本知识。本章重点介绍屏幕导航和标准工具栏功能。
登录画面
登录 SAP 服务器后，SAP 登录屏幕将提示输入用户 ID 和密码。您需要提供有效的用户 ID 和密码并按 Enter（用户 ID 和密码由系统管理员提供）。以下是登录界面。
工具栏图标
以下是 SAP 屏幕工具栏。
菜单栏– 菜单栏是对话框窗口的顶行。
标准工具栏– 此工具栏中提供了大多数标准功能，例如页顶、页尾、向上翻页、向下翻页和保存。
标题栏– 标题栏显示您当前所在的应用程序/业务流程的名称。
应用程序工具栏– 此处提供特定于应用程序的菜单选项。
命令字段– 我们可以在不浏览菜单事务的情况下启动应用程序，并将一些逻辑代码分配给业务流程。在命令字段中输入事务代码以直接启动应用程序。
ABAP 编辑器
您可以启动事务 SE38（在命令字段中输入 SE38）以导航到 ABAP 编辑器。
标准键和图标
退出键用于退出程序/模块或注销。它们还用于返回上次访问的屏幕。
以下是 SAP 中使用的标准退出键，如图所示。
以下是检查、激活和处理报告的选项。
注销
完成工作后退出 ABAP 编辑器或/和从 SAP 系统注销始终是一个好习惯。
SAP ABAP – 基本语法
声明
ABAP 源程序由注释和 ABAP 语句组成。ABAP 中的每个语句都以关键字开头并以句点结束，并且 ABAP 不区分大小写。
程序中的第一个非注释行以 REPORT 一词开头。报告将始终是创建的任何可执行程序的第一行。该语句后跟之前创建的程序名称。然后该线以句号终止。
语法是 –
REPORT [Program_Name]. [Statements…].
这允许语句根据需要在编辑器中占据尽可能多的行。例如，报告可能如下所示 –
REPORT Z_Test123_01.
语句由命令和任何变量和选项组成，以句点结尾。只要句号出现在语句末尾，就不会出现问题。正是这个时期标志着声明结束的地方。
我们来写代码。
在 REPORT 语句下方的行中，只需键入以下语句：Write ‘ABAP Tutorial’。
REPORT Z_Test123_01. Write 'This is ABAP Tutorial'.
撰写陈述时要考虑的四件事–
-
write 语句将引号中的内容写入输出窗口。
-
ABAP 编辑器将所有文本转换为大写，除了用单引号括起来的文本字符串。
-
与一些较旧的编程语言不同，ABAP 不关心语句在一行的何处开始。您可以利用这一点并通过使用缩进来指示代码块来提高程序的可读性。
-
ABAP 对语句的布局没有限制。也就是说，多个语句可以放在一行上，或者一个语句可以跨多行。
冒号符号
如果每个语句的开头相同，则可以将连续语句链接在一起。这是通过冒号 (:) 运算符和逗号完成的，它们用于终止单个语句，就像句点结束正常语句一样。
以下是可以保存一些按键的程序示例 –
WRITE 'Hello'. WRITE 'ABAP'. WRITE 'World'.
使用冒号符号，可以这样重写 –
WRITE: 'Hello',
'ABAP',
'World'.
与任何其他 ABAP 语句一样，布局无关紧要。这是一个同样正确的陈述 –
WRITE: 'Hello', 'ABAP', 'World'.
评论
可以通过以下两种方法之一在程序中的任何位置声明内联注释 –
-
整行注释通过在行的第一个位置放置星号 (*) 来表示，在这种情况下，系统将整行视为注释。评论不需要以句号结束，因为它们可能不会超过一行 –
* This is the comment line
-
部分行注释通过在语句后输入双引号 (“) 表示。双引号后面的所有文本都被系统视为注释。您不需要以句点终止部分行注释，因为它们可能不会扩展到更多不止一行 –
WRITE 'Hello'. "Here is the partial comment
注意– 注释代码不被 ABAP 编辑器大写。
抑制空白
NO-ZERO 命令跟在 DATA 语句之后。它抑制包含空格的数字字段的所有前导零。输出通常更容易让用户阅读。
例子
REPORT Z_Test123_01.
DATA: W_NUR(10) TYPE N.
MOVE 50 TO W_NUR.
WRITE W_NUR NO-ZERO.
上面的代码产生以下输出 –
50
注意– 如果没有 NO-ZERO 命令，输出为：0000000050
空行
SKIP 命令有助于在页面上插入空行。
例子
消息命令如下 –
WRITE 'This is the 1st line'. SKIP. WRITE 'This is the 2nd line'.
上述消息命令产生以下输出 –
This is the 1st line This is the 2nd line
我们可以使用 SKIP 命令插入多个空行。
SKIP number_of_lines.
输出将是由行数定义的几个空行。SKIP 命令还可以将光标定位在页面上所需的行上。
SKIP TO LINE line_number.
该命令用于在页面上下动态移动光标。通常，在此命令之后会出现 WRITE 语句，以将输出放在所需的行上。
插入行
ULINE 命令会自动在输出中插入一条水平线。也可以控制线的位置和长度。语法非常简单 –
ULINE.
例子
消息命令如下 –
WRITE 'This is Underlined'. ULINE.
上面的代码产生以下输出 –
This is Underlined (and a horizontal line below this).
留言
MESSAGE 命令显示由程序开头的 REPORT 语句中指定的消息 ID 定义的消息。消息 ID 是一个 2 个字符的代码，它定义了当使用 MESSAGE 命令时程序将访问哪一组 1,000 条消息。
消息编号从 000 到 999。与每个编号相关联的是最多 80 个字符的消息文本。调用消息号时，会显示相应的文本。
以下是与 Message 命令一起使用的字符 –
| Message | 类型 | 结果 |
|---|---|---|
| E | 错误 | 该消息出现并且应用程序在其当前点停止。如果程序在后台模式下运行，则取消作业并在作业日志中记录消息。 |
| W | 警告 | 该消息出现，用户必须按 Enter 才能继续应用程序。在后台模式下，消息记录在作业日志中。 |
| I | 信息 | 一个带有消息文本的弹出窗口打开，用户必须按 Enter 才能继续。在后台模式下，消息记录在作业日志中。 |
| A | 异常结束 | 此消息类取消用户当前正在使用的事务。 |
| S | 成功 | 这会在屏幕底部提供一条信息性消息。显示的信息本质上是积极的，仅用于用户反馈。该消息不会以任何方式阻碍程序。 |
| X | 中止 | 此消息中止程序并生成 ABAP 短转储。 |
错误消息通常用于阻止用户做他们不应该做的事情。警告消息通常用于提醒用户其行为的后果。信息消息为用户提供有用的信息。
例子
当我们为消息 ID AB 创建消息时，MESSAGE 命令 – MESSAGE E011 给出以下输出 –
EAB011 This report does not support sub-number summarization.
SAP ABAP – 数据类型
在ABAP中编程时，我们需要使用各种变量来存储各种信息。变量只不过是用于存储值的保留内存位置。这意味着当你创建一个变量时，你会在内存中保留一些空间。您可能喜欢存储各种数据类型的信息，如字符、整数、浮点数等。操作系统根据变量的数据类型分配内存并决定可以在保留内存中存储什么。
基本数据类型
ABAP 为程序员提供了丰富的固定长度和可变长度数据类型。下表列出了 ABAP 基本数据类型 –
| Type | 关键词 |
|---|---|
| Byte field | X |
| Text field | C |
| Integer | 一世 |
| Floating point | F |
| Packed number | 磷 |
| Text string | 细绳 |
可以使用一个或多个名称修改某些字段和数字，如下所示 –
- 字节
- 数字
- 性格似的
下表显示了数据类型、将值存储在内存中需要多少内存，以及可以存储在此类变量中的最小值和最大值。
| Type | 典型长度 | 典型范围 |
|---|---|---|
| X | 1 字节 | 任何字节值（00 到 FF） |
| C | 1 个字符 | 1 至 65535 |
| N (numeric text filed) | 1 个字符 | 1 至 65535 |
| D (character-like date) | 8 个字符 | 8 个字符 |
| T (character-like time) | 6 个字符 | 6 个字符 |
| I | 4字节 | -2147483648 转 2147483647 |
| F | 8 字节 | 2.2250738585072014E-308 到 1.7976931348623157E+308 正负 |
| P | 8 字节 | [-10^(2len -1) +1] 到 [+10^(2len -1) 1]（其中 len = 固定长度） |
| STRING | 多变的 | 任何字母数字字符 |
| XSTRING (byte string) | 多变的 | 任何字节值（00 到 FF） |
例子
REPORT YR_SEP_12. DATA text_line TYPE C LENGTH 40. text_line = 'A Chapter on Data Types'. Write text_line. DATA text_string TYPE STRING. text_string = 'A Program in ABAP'. Write / text_string. DATA d_date TYPE D. d_date = SY-DATUM. Write / d_date.
在本例中，我们有一个预定义长度为 40 的 C 类型字符串。STRING 是一种数据类型，可用于任何可变长度的字符串（文本字符串）。类型 STRING 数据对象通常应用于固定长度不重要的类似字符的内容。
上面的代码产生以下输出 –
A Chapter on Data Types A Program in ABAP 12092015
DATE 类型用于存储日期信息，可以存储如上图所示的八位数字。
复杂和引用类型
复杂类型分为结构类型和表类型。在结构类型中，基本类型和结构（即嵌入在结构中的结构）被组合在一起。您可以只考虑基本类型的分组。但是您必须了解结构嵌套的可用性。
当基本类型组合在一起时，可以将数据项作为分组数据项进行访问，或者可以访问各个基本类型数据项（结构字段）。表类型在其他编程语言中被称为数组。数组可以是简单数组或结构数组。在 ABAP 中，数组被称为内部表，与其他编程语言相比，它们可以通过多种方式声明和操作。下表显示了表征内部表的参数。
| S.No. | 参数及说明 |
|---|---|
| 1 |
Line or row type 内部表的行可以是基本类型、复杂类型或引用类型。 |
| 2 |
Key 指定一个字段或一组字段作为标识表行的内部表的键。键包含基本类型的字段。 |
| 3 |
Access method 描述 ABAP 程序如何访问单个表条目。 |
引用类型用于引用类、接口和运行时数据项的实例。ABAP OOP 运行时类型服务 (RTTS) 支持在运行时声明数据项。
SAP ABAP – 变量
变量是命名数据对象，用于在程序的分配内存区域中存储值。顾名思义，用户可以借助 ABAP 语句更改变量的内容。ABAP 中的每个变量都有一个特定的类型，它决定了变量内存的大小和布局；可以存储在该内存中的值范围；以及可以应用于变量的一组操作。
您必须先声明所有变量，然后才能使用它们。变量声明的基本形式是 –
DATA <f> TYPE <type> VALUE <val>.
这里 <f> 指定变量的名称。变量的名称最长可达 30 个字符。<type> 指定变量的类型。任何具有完全指定技术属性的数据类型都称为 <type>。<val> 指定 <f> 变量的初始值。如果您定义了一个基本的固定长度变量，DATA 语句会自动用特定于类型的初始值填充变量的值。<val> 的其他可能值可以是文字、常量或显式子句，例如 Is INITIAL。
以下是变量声明的有效示例。
DATA d1(2) TYPE C. DATA d2 LIKE d1. DATA minimum_value TYPE I VALUE 10.
在上面的代码片段中，d1是一个C类型的变量，d2是一个d1类型的变量，而minimum_value是一个ABAP整数类型I的变量。
本章将解释 ABAP 中可用的各种变量类型。ABAP 中有三种变量 –
- 静态变量
- 参考变量
- 系统变量
静态变量
-
静态变量在子程序、功能模块和静态方法中声明。
-
生命周期与声明的上下文相关联。
-
使用“CLASS-DATA”语句，您可以在类中声明变量。
-
“PARAMETERS”语句可用于声明链接到选择屏幕上的输入字段的基本数据对象。
-
您还可以使用“SELECT-OPTIONS”语句声明链接到选择屏幕上的输入字段的内部表。
以下是命名变量时使用的约定 –
-
不能使用诸如“t”和“,”之类的特殊字符来命名变量。
-
无法更改预定义数据对象的名称。
-
变量的名称不能与任何 ABAP 关键字或子句相同。
-
变量的名称必须传达变量的含义，无需进一步注释。
-
连字符保留用于表示结构的组成部分。因此，您应该避免在变量名称中使用连字符。
-
下划线字符可用于分隔复合词。
该程序显示了如何使用 PARAMETERS 语句声明变量 –
REPORT ZTest123_01. PARAMETERS: NAME(10) TYPE C, CLASS TYPE I, SCORE TYPE P DECIMALS 2, CONNECT TYPE MARA-MATNR.
这里，NAME 代表一个 10 个字符的参数，CLASS 指定一个整数类型的参数，默认大小以字节为单位，SCORE 代表一个压缩类型参数，值最多两位小数，CONNECT 指的是 ABAP 字典的 MARA-MATNF 类型.
上面的代码产生以下输出 –
参考变量
声明引用变量的语法是 –
DATA <ref> TYPE REF TO <type> VALUE IS INITIAL.
-
REF TO 加法声明了一个引用变量 ref。
-
REF TO 后面的规范指定引用变量的静态类型。
-
静态类型限制了 <ref> 可以引用的对象集。
-
引用变量的动态类型是它当前引用的数据类型或类。
-
静态类型总是更通用或与动态类型相同。
-
TYPE加法用于创建绑定引用类型并作为起始值，VALUE加法后只能指定IS INITIAL。
例子
CLASS C1 DEFINITION. PUBLIC SECTION. DATA Bl TYPE I VALUE 1. ENDCLASS. DATA: Oref TYPE REF TO C1 , Dref1 LIKE REF TO Oref, Dref2 TYPE REF TO I . CREATE OBJECT Oref. GET REFERENCE OF Oref INTO Dref1. CREATE DATA Dref2. Dref2→* = Dref1→*→Bl.
-
在上面的代码片段中，声明了一个对象引用 Oref 和两个数据引用变量 Dref1 和 Dref2。
-
两个数据引用变量都是完全类型化的，可以在操作数位置使用取消引用运算符 →* 取消引用。
系统变量
-
ABAP 系统变量可从所有 ABAP 程序访问。
-
这些字段实际上由运行时环境填充。
-
这些字段中的值指示系统在任何给定时间点的状态。
-
您可以在 SAP 的 SYST 表中找到系统变量的完整列表。
-
SYST 结构的各个字段可以通过使用“SYST-”或“SY-”来访问。
例子
REPORT Z_Test123_01.
WRITE:/'SY-ABCDE', SY-ABCDE,
/'SY-DATUM', SY-DATUM,
/'SY-DBSYS', SY-DBSYS,
/'SY-HOST ', SY-HOST,
/'SY-LANGU', SY-LANGU,
/'SY-MANDT', SY-MANDT,
/'SY-OPSYS', SY-OPSYS,
/'SY-SAPRL', SY-SAPRL,
/'SY-SYSID', SY-SYSID,
/'SY-TCODE', SY-TCODE,
/'SY-UNAME', SY-UNAME,
/'SY-UZEIT', SY-UZEIT.
上面的代码产生以下输出 –
SY-ABCDE ABCDEFGHIJKLMNOPQRSTUVWXYZ SY-DATUM 12.09.2015 SY-DBSYS ORACLE SY-HOST sapserver SY-LANGU EN SY-MANDT 800 SY-OPSYS Windows NT SY-SAPRL 700 SY-SYSID DMO SY-TCODE SE38 SY-UNAME SAPUSER SY-UZEIT 14:25:48
SAP ABAP – 常量和文字
文字是您在程序的源代码中创建的未命名数据对象。它们完全由它们的价值定义。您无法更改文字的值。常量是使用声明性语句静态创建的命名数据对象。常量是通过为其分配一个值来声明的，该值存储在程序的内存区域中。在程序执行期间不能更改分配给常量的值。这些固定值也可以被视为文字。有两种类型的文字 – 数字和字符。
数字文字
数字文字是可以带有前缀符号的数字序列。在数字文字中，没有小数分隔符，也没有带有尾数和指数的符号。
以下是一些数字文字的例子 –
183. -97. +326.
字符字面量
字符文字是 ABAP 程序源代码中用单引号括起来的字母数字字符序列。用引号括起来的字符文字具有预定义的 ABAP 类型 C，并被描述为文本字段文字。包含在“反引号”中的文字具有 ABAP 类型 STRING，并被描述为字符串文字。字段长度由字符数定义。
注意– 在文本字段文字中，尾随空白被忽略，但在字符串文字中它们被考虑在内。
以下是字符文字的一些示例。
文本字段文字
REPORT YR_SEP_12. Write 'Tutorials Point'. Write / 'ABAP Tutorial'.
字符串字段文字
REPORT YR_SEP_12. Write `Tutorials Point `. Write / `ABAP Tutorial `.
上述两种情况的输出相同 –
Tutorials Point ABAP Tutorial
注意– 当我们尝试更改常量的值时，可能会发生语法或运行时错误。在类或接口的声明部分声明的常量属于该类或接口的静态属性。
常数声明
我们可以在 CONSTANTS 语句的帮助下声明命名数据对象。
以下是语法 –
CONSTANTS <f> TYPE <type> VALUE <val>.
CONSTANTS 语句类似于 DATA 语句。
<f> 指定常量的名称。TYPE <type> 代表一个名为 <f> 的常量，它继承了与现有数据类型 <type> 相同的技术属性。VALUE <val> 为声明的常量名称 <f> 分配一个初始值。
注意– 我们应该在 CONSTANTS 语句中使用 VALUE 子句。子句“VALUE”用于在常量声明期间为其分配初始值。
我们有 3 种类型的常量，例如基本常量、复数常量和参考常量。以下语句显示了如何使用 CONSTANTS 语句定义常量 –
REPORT YR_SEP_12. CONSTANTS PQR TYPE P DECIMALS 4 VALUE '1.2356'. Write: / 'The value of PQR is:', PQR.
输出是 –
The value of PQR is: 1.2356
这里它指的是基本数据类型，称为基本常量。
以下是复数常量的示例 –
BEGIN OF EMPLOYEE, Name(25) TYPE C VALUE 'Management Team', Organization(40) TYPE C VALUE 'Tutorials Point Ltd', Place(10) TYPE C VALUE 'India', END OF EMPLOYEE.
在上面的代码片段中，EMPLOYEE 是一个复杂的常量，由 Name、Organization 和 Place 字段组成。
以下语句声明了一个常量引用 –
CONSTANTS null_pointer TYPE REF TO object VALUE IS INITIAL.
我们可以在比较中使用常量引用，或者我们可以将它传递给过程。
SAP ABAP – 操作员
ABAP 提供了一组丰富的操作符来操作变量。所有 ABAP 运算符都分为四类 –
- 算术运算符
- 比较运算符
- 按位运算符
- 字符串运算符
算术运算符
算术运算符在数学表达式中的使用方式与它们在代数中的使用方式相同。以下列表描述了算术运算符。假设整数变量 A 为 20，变量 B 为 40。
| S.No. | 算术运算符和描述 |
|---|---|
| 1 |
&plus (Addition) 在运算符的任一侧添加值。示例：A &plus B 将给出 60。 |
| 2 |
− (Subtraction) 从左手操作数中减去右手操作数。示例：A – B 将给出 -20。 |
| 3 |
* (Multiplication) 将运算符两侧的值相乘。示例：A * B 将给出 800。 |
| 4 |
/ (Division) 将左手操作数除以右手操作数。示例：B / A 将给出 2。 |
| 5 |
MOD (Modulus) 将左手操作数除以右手操作数并返回余数。示例：B MOD A 将给出 0。 |
例子
REPORT YS_SEP_08. DATA: A TYPE I VALUE 150, B TYPE I VALUE 50, Result TYPE I. Result = A / B. WRITE / Result.
上面的代码产生以下输出 –
3
比较运算符
让我们讨论不同操作数的各种类型的比较运算符。
| S.No. | 比较运算符和描述 |
|---|---|
| 1 |
= (equality test). Alternate form is EQ. 检查两个操作数的值是否相等，如果是，则条件为真。示例 (A = B) 不正确。 |
| 2 |
<> (Inequality test). Alternate form is NE. 检查两个操作数的值是否相等。如果值不相等，则条件变为真。示例 (A <> B) 为真。 |
| 3 |
> (Greater than test). Alternate form is GT. 检查左操作数的值是否大于右操作数的值。如果是，则条件变为真。示例 (A > B) 不正确。 |
| 4 |
< (Less than test). Alternate form is LT. 检查左操作数的值是否小于右操作数的值。如果是，则条件变为真。示例 (A < B) 为真。 |
| 5 |
>= (Greater than or equals) Alternate form is GE. 检查左操作数的值是否大于或等于右操作数的值。如果是，则条件变为真。示例 (A >= B) 不正确。 |
| 6 |
<= (Less than or equals test). Alternate form is LE. 检查左操作数的值是否小于或等于右操作数的值。如果是，则条件变为真。示例 (A <= B) 为真。 |
| 7 |
a1 BETWEEN a2 AND a3 (Interval test) 检查 a1 是否在 a2 和 a3 之间（含）。如果是，则条件变为真。示例 (A BETWEEN B AND C) 为真。 |
| 8 |
IS INITIAL 如果变量的内容没有改变并且已自动为其分配初始值，则条件变为真。示例 (A IS INITIAL) 不正确 |
| 9 |
IS NOT INITIAL 如果变量的内容已更改，则条件变为真。示例 (A IS NOT INITIAL) 为真。 |
注意– 如果变量的数据类型或长度不匹配，则执行自动转换。在比较不同数据类型的两个值时，对其中一个或两个值执行自动类型调整。转换类型由数据类型和数据类型的优先顺序决定。
以下是优先顺序 –
-
如果一个字段的类型为 I，则另一个字段将转换为类型 I。
-
如果一个字段的类型为 P，则另一个字段将转换为类型 P。
-
如果一个字段是D类型，则另一个字段被转换为D类型。但C和N类型没有转换，直接比较。T 型的情况类似。
-
如果一个字段的类型为 N 而另一个字段的类型为 C 或 X，则这两个字段都将转换为类型 P。
-
如果一个字段的类型为 C，另一个字段的类型为 X，则将 X 类型转换为类型 C。
示例 1
REPORT YS_SEP_08.
DATA: A TYPE I VALUE 115,
B TYPE I VALUE 119.
IF A LT B.
WRITE: / 'A is less than B'.
ENDIF
上面的代码产生以下输出 –
A is less than B
示例 2
REPORT YS_SEP_08.
DATA: A TYPE I.
IF A IS INITIAL.
WRITE: / 'A is assigned'.
ENDIF.
上面的代码产生以下输出 –
A is assigned.
按位运算符
ABAP 还提供了一系列按位逻辑运算符，可用于构建布尔代数表达式。可以使用括号等将位运算符组合在复杂的表达式中。
| S.No. | 按位运算符和描述 |
|---|---|
| 1 |
BIT-NOT 将十六进制数中的所有位翻转为相反值的一元运算符。例如，将此运算符应用于具有位级别值 10101010（例如“AA”）的十六进制数将得到 01010101。 |
| 2 |
BIT-AND 此二元运算符使用布尔 AND 运算符逐位比较每个字段。 |
| 3 |
BIT-XOR 使用布尔 XOR（异或）运算符逐位比较每个字段的二元运算符。 |
| 4 |
BIT-OR 使用布尔 OR 运算符逐位比较每个字段的二元运算符。 |
例如，以下真值表显示了对字段 A 和字段 B 中包含的两个位值应用布尔 AND、OR 或 XOR 运算符时生成的值。
| Field A | 场B | 和 | 要么 | 异或 |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
字符串运算符
以下是字符串运算符列表 –
| S.No. | 字符串运算符和描述 |
|---|---|
| 1 |
CO (Contains Only) 检查 A 是否仅由 B 中的字符组成。 |
| 2 |
CN (Not Contains ONLY) 检查 A 是否包含不在 B 中的字符。 |
| 3 |
CA (Contains ANY) 检查 A 是否至少包含 B 的一个字符。 |
| 4 |
NA (NOT Contains Any) 检查 A 是否不包含 B 的任何字符。 |
| 5 |
CS (Contains a String) 检查 A 是否包含字符串 B。 |
| 6 |
NS (NOT Contains a String) 检查 A 是否不包含字符串 B。 |
| 7 |
CP (Contains a Pattern) 它检查 A 是否包含 B 中的模式。 |
| 8 |
NP (NOT Contains a Pattern) 它检查 A 是否不包含 B 中的模式。 |
例子
REPORT YS_SEP_08.
DATA: P(10) TYPE C VALUE 'APPLE',
Q(10) TYPE C VALUE 'CHAIR'.
IF P CA Q.
WRITE: / 'P contains at least one character of Q'.
ENDIF.
上面的代码产生以下输出 –
P contains at least one character of Q.
SAP ABAP – 循环控制
可能存在需要多次执行代码块的情况。通常，语句是按顺序执行的：首先执行函数中的第一条语句，然后是第二条，依此类推。
编程语言提供了允许更复杂的执行路径的各种控制结构。一个循环语句使我们能够执行语句或语句组多次，下面是大多数编程语言的循环语句的一般形式。
ABAP 编程语言提供以下类型的循环来处理循环需求。
| S.No. | 循环类型和描述 |
|---|---|
| 1 | WHILE loop
当给定条件为真时，重复一个语句或一组语句。它在执行循环体之前测试条件。 |
| 2 | Do loop
DO 语句对于将特定任务重复特定次数很有用。 |
| 3 | Nested loop
您可以在任何另一个 WHILE 或 DO 循环中使用一个或多个循环。 |
循环控制语句
循环控制语句改变其正常顺序的执行。ABAP 包括允许提前结束循环的控制语句。它支持以下控制语句。
| S.No. | 控制声明和描述 |
|---|---|
| 1 | CONTINUE
使循环跳过其主体的其余部分并开始下一个循环传递。 |
| 2 | CHECK
如果条件为假，则 CHECK 之后的其余语句将被忽略，系统开始下一个循环。 |
| 3 | EXIT
完全终止循环并将执行转移到紧跟在循环之后的语句。 |
SAP ABAP – 决策
决策结构具有一个或多个要由程序评估或测试的条件，以及要执行的一个或多个语句（如果条件确定为真），以及可选的要执行的其他语句（如果条件成立）确定为假。
以下是在大多数编程语言中发现的典型决策结构的一般形式 –
ABAP 编程语言提供了以下类型的决策语句。
| S.No. | 声明和说明 |
|---|---|
| 1 | IF Statement
IF 语句由一个逻辑表达式和一个或多个语句组成。 |
| 2 | IF.. Else Statement
IF 语句后可以跟一个可选的 ELSE 语句，该语句在表达式为假时执行。 |
| 3 | Nested IF Statement
您可以在另一个 IF 或 ELSEIF 语句中使用一个 IF 或 ELSEIF 语句。 |
| 4 | CASE Control Statement
当我们需要比较两个或多个字段或变量时使用 CASE 语句。 |
SAP ABAP – 字符串
在 ABAP 编程中广泛使用的字符串是一个字符序列。
我们使用数据类型 C 变量来保存字母数字字符，最少 1 个字符，最多 65,535 个字符。默认情况下，它们向左对齐。
创建字符串
以下声明和初始化创建了一个由单词“Hello”组成的字符串。字符串的大小正好是单词“Hello”中的字符数。
Data my_Char(5) VALUE 'Hello'.
以下程序是创建字符串的示例。
REPORT YT_SEP_15. DATA my_Char(5) VALUE 'Hello'. Write my_Char.
上面的代码产生以下输出 –
Hello
字符串长度
为了找到字符串的长度，我们可以使用STRLEN语句。STRLEN() 函数返回字符串中包含的字符数。
例子
REPORT YT_SEP_15.
DATA: title_1(10) VALUE 'Tutorials',
length_1 TYPE I.
length_1 = STRLEN( title_1 ).
Write: / 'The Length of the Title is:', length_1.
上面的代码产生以下输出 –
The Length of the Title is: 9
ABAP 支持各种操作字符串的语句。
| S.No. | 声明和目的 |
|---|---|
| 1 |
CONCATENATE 两根弦连接起来形成第三根弦。 |
| 2 |
CONDENSE 此语句删除空格字符。 |
| 3 |
STRLEN 用于查找字段的长度。 |
| 4 |
REPLACE 用于替换字符。 |
| 5 |
SEARCH 在字符串中运行搜索。 |
| 6 |
SHIFT 用于向左或向右移动字符串的内容。 |
| 7 |
SPLIT 用于将一个字段的内容拆分为两个或多个字段。 |
以下示例使用了上述一些语句 –
例子
REPORT YT_SEP_15.
DATA: title_1(10) VALUE 'Tutorials',
title_2(10) VALUE 'Point',
spaced_title(30) VALUE 'Tutorials Point Limited',
sep,
dest1(30),
dest2(30).
CONCATENATE title_1 title_2 INTO dest1.
Write: / 'Concatenation:', dest1.
CONCATENATE title_1 title_2 INTO dest2 SEPARATED BY sep.
Write: / 'Concatenation with Space:', dest2.
CONDENSE spaced_title.
Write: / 'Condense with Gaps:', spaced_title.
CONDENSE spaced_title NO-GAPS.
Write: / 'Condense with No Gaps:', spaced_title.
上面的代码产生以下输出 –
Concatenation: TutorialsPoint Concatenation with Space: Tutorials Point Condense with Gaps: Tutorials Point Limited Condense with No Gaps: TutorialsPointLimited
注意–
-
在串联的情况下，“sep”在字段之间插入一个空格。
-
CONDENSE 语句删除字段之间的空格，但只留下 1 个字符的空格。
-
‘NO-GAPS’ 是删除所有空格的 CONDENSE 语句的可选补充。
SAP ABAP – 日期和时间
ABAP 隐式引用公历，在世界大部分地区都有效。我们可以将输出转换为国家特定的日历。日期是相对于日历指定为精确日、周或月的时间。时间被指定为相对于一天的精确秒或分钟。ABAP 总是以 24 小时格式节省时间。输出可以具有特定于国家/地区的格式。日期和时间通常被解释为在当前时区有效的本地日期。
ABAP 提供两种内置类型来处理日期和时间 –
- D 数据类型
- T 数据类型
以下是基本格式 –
DATA: date TYPE D,
time TYPE T.
DATA: year TYPE I,
month TYPE I,
day TYPE I,
hour TYPE I,
minute TYPE I,
second TYPE I.
这两种类型都是固定长度的字符类型，格式分别为 YYYYMMDD 和 HHMMSS。
时间戳
除了这些内置类型之外，其他两种类型TIMESTAMP和TIMESTAMPL正在许多标准应用程序表中用于以 UTC 格式存储时间戳。下表显示了 ABAP 中可用的基本日期和时间类型。
| S.No. | 数据类型和描述 |
|---|---|
| 1 |
D 格式为 YYYYMMDD 的内置固定长度日期类型。例如，值 20100913 表示日期 2010 年 9 月 13 日。 |
| 2 |
T HHMMSS 形式的内置固定长度时间类型。例如，值 102305 表示时间 10:23:05 AM。 |
| 3 |
TIMESTAMP（P 型 – 长度 8 无小数） 此类型用于以 YYYYMMDDhhmmss 形式表示短时间戳。例如，值 20100913102305 表示日期 2010 年 9 月 13 日上午 10:23:05。 |
| 4 |
TIMESTAMPL（P 型 – 长度为 11 位小数点 7） TIMESTAMPL 以 YYYYMMDDhhmmss,mmmuuun 形式表示长时间戳。这里附加的数字“mmmuuun”代表秒的分数。 |
当前日期和时间
以下代码片段检索当前系统日期和时间。
REPORT YR_SEP_15. DATA: date_1 TYPE D. date_1 = SY-DATUM. Write: / 'Present Date is:', date_1 DD/MM/YYYY. date_1 = date_1 + 06. Write: / 'Date after 6 Days is:', date_1 DD/MM/YYYY.
上面的代码产生以下输出 –
Present Date is: 21.09.2015 Date after 6 Days is: 27.09.2015
变量 date_1 被分配了当前系统日期 SY-DATUM 的值。接下来，我们将日期值增加 6。就 ABAP 中的日期计算而言，这意味着我们将日期对象的日期部分增加 6 天。ABAP 运行时环境足够智能，可以在到达月末时滚动日期值。
时间计算的工作方式类似于日期计算。以下代码使用基本时间算法将当前系统时间增加 75 秒。
REPORT YR_SEP_15.
DATA: time_1 TYPE T.
time_1 = SY-UZEIT.
Write /(60) time_1 USING EDIT MASK
'Now the Time is: __:__:__'.
time_1 = time_1 + 75.
Write /(60) time_1 USING EDIT MASK
'A Minute and a Quarter from Now, it is: __:__:__'.
上面的代码产生以下输出 –
Now the Time is 11:45:05 A Minute and a Quarter from Now, it is: 11:46:20
使用时间戳
您可以使用GET TIME STAMP检索当前系统时间并将其存储在时间戳变量中，如以下代码所示。GET TIME STAMP 语句根据所使用的时间戳数据对象的类型以长格式或短格式存储时间戳。时间戳值使用 UTC 标准进行编码。
REPORT YR_SEP_12. DATA: stamp_1 TYPE TIMESTAMP, stamp_2 TYPE TIMESTAMPL. GET TIME STAMP FIELD stamp_1. Write: / 'The short time stamp is:', stamp_1 TIME ZONE SY-ZONLO. GET TIME STAMP FIELD stamp_2. Write: / 'The long time stamp is:', stamp_2 TIME ZONE SY-ZONLO.
上面的代码产生以下输出 –
The short time stamp is: 18.09.2015 11:19:40 The long time stamp is: 18.09.2015 11:19:40,9370000
在上面的示例中，我们使用 WRITE 语句的 TIME ZONE 添加来显示时间戳。此添加根据指定时区的规则格式化时间戳的输出。系统字段 SY-ZONLO 用于显示用户首选项中配置的本地时区。
SAP ABAP – 格式化数据
ABAP 提供各种类型的格式化选项来格式化程序的输出。例如，您可以创建一个列表，其中包含不同颜色或格式样式的各种项目。
WRITE 语句是用于在屏幕上显示数据的格式化语句。WRITE 语句有不同的格式选项。WRITE 语句的语法是 –
WRITE <format> <f> <options>.
在此语法中，<format> 表示输出格式规范，它可以是一个正斜杠 (/)，表示从新行开始显示输出。除了正斜杠之外，格式规范还包括列号和列长度。例如，WRITE/04 (6) 语句显示新行从第 4 列开始，列长度为 6，而 WRITE 20 语句显示当前行的第 20 列。参数 <f> 表示数据变量或编号文本。
下表描述了用于格式化的各种子句 –
| S.No. | 条款和说明 |
|---|---|
| 1 |
LEFT-JUSTIFIED 指定输出左对齐。 |
| 2 |
CENTERED 表示输出居中。 |
| 3 |
RIGHT-JUSTIFIED 指定输出右对齐。 |
| 4 |
UNDER <g> 输出直接在字段 <g> 下开始。 |
| 5 |
NO-GAP 指定字段 <f> 后的空白被拒绝。 |
| 6 |
USING EDIT MASK <m> 表示格式模板 <m> 的规范。不使用编辑掩码：这指定在 ABAP 词典中指定的格式模板已停用。 |
| 7 |
NO-ZERO 如果字段仅包含零，则它们将被空白替换。 |
以下是数字类型字段的格式选项 –
| S.No. | 条款和说明 |
|---|---|
| 1 |
NO-SIGN 指定屏幕上不显示前导符号。 |
| 2 |
EXPONENT <e> 指定在类型 F（浮点字段）中，指数在 <e> 中定义。 |
| 3 |
ROUND <r> 类型 P 字段（压缩数字数据类型）首先乘以 10**(-r)，然后四舍五入为整数值。 |
| 4 |
CURRENCY <c> 表示根据存储在 TCURX 数据库表中的货币 <c> 值进行格式化。 |
| 5 |
UNIT <u> 指定根据 T006 数据库表中为类型 P 指定的 <u> 单位固定小数位数。 |
| 6 |
DECIMALS <d> 指定小数点后必须显示的位数 <d>。 |
例如，下表显示了日期字段的不同格式选项 –
| Formatting Option | 例子 |
|---|---|
| DD/MM/YY | 13/01/15 |
| MM/DD/YY | 15 年 1 月 13 日 |
| DD/MM/YYYY | 13/01/2015 |
| MM/DD/YYYY | 01/13/2015 |
| DDMMYY | 130115 |
| MMDDYY | 011315 |
| YYMMDD | 150113 |
这里DD代表两位数的日期，MM代表两位数的月份，YY代表两位数的年份，YYYY代表四位数的年份。
让我们看一下实现上述一些格式选项的 ABAP 代码示例 –
REPORT ZTest123_01. DATA: n(9) TYPE C VALUE 'Tutorials', m(5) TYPE C VALUE 'Point'. WRITE: n, m. WRITE: / n, / m UNDER n. WRITE: / n NO-GAP, m. DATA time TYPE T VALUE '112538'. WRITE: / time, /(8) time Using EDIT MASK '__:__:__'.
上面的代码产生以下输出 –
Tutorials Point Tutorials Point TutorialsPoint 112538 11:25:38
SAP ABAP – 异常处理
一个例外是程序的执行过程中出现的问题。当发生异常时，程序的正常流程被打乱，程序应用程序异常终止，不推荐，因此需要处理这些异常。
异常提供了一种将控制从程序的一个部分转移到另一个部分的方法。ABAP 异常处理建立在三个关键字之上——RAISE、TRY、CATCH 和 CLEANUP。假设一个块将引发异常，一个方法使用 TRY 和 CATCH 关键字的组合来捕获异常。TRY – CATCH 块放置在可能生成异常的代码周围。以下是使用 TRY – CATCH 的语法 –
TRY. Try Block <Code that raises an exception> CATCH Catch Block <exception handler M> . . . . . . . . . CATCH Catch Block <exception handler R> CLEANUP. Cleanup block <to restore consistent state> ENDTRY.
RAISE – 引发异常以表明发生了一些异常情况。通常，异常处理程序会尝试修复错误或找到替代解决方案。
TRY – TRY 块包含要处理其异常的应用程序编码。这个语句块是按顺序处理的。它可以包含进一步的控制结构和过程调用或其他 ABAP 程序。后面跟着一个或多个 catch 块。
CATCH – 程序在程序中要处理问题的位置使用异常处理程序捕获异常。CATCH 关键字表示捕获异常。
CLEANUP – CLEANUP 块的语句在 TRY 块中发生异常时执行，该异常未被同一 TRY – ENDTRY 构造的处理程序捕获。在 CLEANUP 子句中，系统可以将对象恢复到一致状态或释放外部资源。也就是说，可以针对 TRY 块的上下文执行清理工作。
引发异常
异常可以在方法、功能模块、子例程等的任何位置引发。有两种方法可以引发异常 –
-
ABAP 运行时系统引发的异常。
例如 Y = 1 / 0。这将导致 CX_SY_ZERODIVIDE 类型的运行时错误。
-
程序员提出的异常。
同时引发和创建异常对象。使用第一个场景中已经存在的异常对象引发异常。语法是：RAISE EXCEPTION exep。
捕捉异常
处理程序用于捕获异常。
让我们看一下代码片段 –
DATA: result TYPE P LENGTH 8 DECIMALS 2, exref TYPE REF TO CX_ROOT, msgtxt TYPE STRING. PARAMETERS: Num1 TYPE I, Num2 TYPE I. TRY. result = Num1 / Num2. CATCH CX_SY_ZERODIVIDE INTO exref. msgtxt = exref→GET_TEXT( ). CATCH CX_SY_CONVERSION_NO_NUMBER INTO exref. msgtxt = exref→GET_TEXT( ).
在上面的代码片段中，我们试图将 Num1 除以 Num2 以获得浮点类型变量的结果。
可能会产生两种类型的异常。
-
数字转换错误。
-
除以零异常。处理程序捕获 CX_SY_CONVERSION_NO_NUMBER 异常以及 CX_SY_ZERODIVIDE 异常。这里使用异常类的GET_TEXT()方法来获取异常的描述。
异常的属性
以下是异常的五个属性和方法 –
| S.No. | 属性和描述 |
|---|---|
| 1 |
Textid 用于为异常定义不同的文本，也会影响 get_text 方法的结果。 |
| 2 |
Previous 该属性可以存储允许您构建异常链的原始异常。 |
| 3 |
get_text 这将根据异常的系统语言将文本表示作为字符串返回。 |
| 4 |
get_longtext 这将异常的文本表示的 long 变体作为字符串返回。 |
| 5 |
get_source_position 给出引发异常的程序名称和行号。 |
例子
REPORT ZExceptionsDemo. PARAMETERS Num_1 TYPE I. DATA res_1 TYPE P DECIMALS 2. DATA orf_1 TYPE REF TO CX_ROOT. DATA txt_1 TYPE STRING. start-of-selection. Write: / 'Square Root and Division with:', Num_1. write: /. TRY. IF ABS( Num_1 ) > 150. RAISE EXCEPTION TYPE CX_DEMO_ABS_TOO_LARGE. ENDIF. TRY. res_1 = SQRT( Num_1 ). Write: / 'Result of square root:', res_1. res_1 = 1 / Num_1. Write: / 'Result of division:', res_1. CATCH CX_SY_ZERODIVIDE INTO orf_1. txt_1 = orf_1→GET_TEXT( ). CLEANUP. CLEAR res_1. ENDTRY. CATCH CX_SY_ARITHMETIC_ERROR INTO orf_1. txt_1 = orf_1→GET_TEXT( ). CATCH CX_ROOT INTO orf_1. txt_1 = orf_1→GET_TEXT( ). ENDTRY. IF NOT txt_1 IS INITIAL. Write / txt_1. ENDIF. Write: / 'Final Result is:', res_1.
在此示例中，如果数字大于 150，则会引发异常 CX_DEMO_ABS_TOO_LARGE。上面的代码为数字 160 生成以下输出。
Square Root and Division with: 160 The absolute value of number is too high Final Result is: 0.00
SAP ABAP – 字典
如您所知，SQL 可以分为两部分 –
- DML（数据操作语言）
- DDL（数据定义语言）
DML 部分由SELECT、INSERT、UPDATE、DELETE 等查询和更新命令组成，ABAP 程序处理SQL 的DML 部分。DDL部分由CREATE TABLE、CREATE INDEX、DROP TABLE、ALTER TABLE等命令组成，ABAP Dictionary处理SQL的DDL部分。
ABAP Dictionary 可以看作是驻留在 SAP 数据库中的元数据（即关于数据的数据）以及由数据库维护的元数据。字典用于创建和管理数据定义以及创建表、数据元素、域、视图和类型。
ABAP字典中的基本类型
ABAP 字典中的基本类型如下 –
-
数据元素通过定义数据类型、长度和可能的小数位来描述基本类型。
-
具有可以具有任何类型的组件的结构。
-
表类型描述了内部表的结构。
Dictionary 环境中的各种对象可以在 ABAP 程序中引用。字典被称为全局区域。Dictionary 中的对象对所有 ABAP 程序都是全局的，ABAP 程序中的数据可以通过引用这些 Dictionary 全局对象来声明。
Dictionary 支持用户自定义类型的定义，这些类型用于 ABAP 程序。它们还定义了数据库对象的结构，例如表、视图和索引。当对象被激活时，这些对象在其字典定义中的底层数据库中自动创建。词典还提供了诸如搜索帮助之类的编辑工具和诸如锁定对象之类的锁定工具。
字典任务
ABAP 字典实现以下功能 –
- 强制执行数据完整性。
- 无冗余地管理数据定义。
- 与 ABAP 开发工作台的其余部分紧密集成。
例子
任何复杂的用户定义类型都可以从字典中的 3 种基本类型构建。客户数据存储在结构“客户”中，包含名称、地址和电话组件，如下图所示。Name 也是一个包含 First name 和 Last name 组件的结构。这两个组件都是基本的，因为它们的类型是由数据元素定义的。
组件 Address 的类型由一个结构体定义，该结构体的组件也是结构体，Telephone 组件由表类型定义，因为客户可以有多个电话号码。类型用于 ABAP 程序，也用于定义功能模块的接口参数类型。
SAP ABAP – 域
在 ABAP 字典中定义数据的三个基本对象是域、数据元素和表。域用于字段类型和长度等表字段的技术定义，数据元素用于语义定义（简短描述）。数据元素描述了特定业务上下文中域的含义。它主要包含屏幕中的字段帮助和字段标签。
域被分配给数据元素，数据元素又被分配给表字段或结构字段。例如，MATNR 域（CHAR 材料编号）被分配给 MATNR_N、MATNN 和 MATNR_D 等数据元素，并且这些被分配给许多表字段和结构字段。
创建域
在创建新域之前，请检查任何现有域是否具有表字段中所需的相同技术规范。如果是这样，我们应该使用该现有域。让我们讨论创建域的过程。
步骤 1 – 转到事务 SE11。
步骤 2 – 在 ABAP 词典的初始屏幕中选择域的单选按钮，然后输入域的名称，如下面的屏幕截图所示。单击创建按钮。您可以在客户命名空间下创建域，并且对象的名称始终以“Z”或“Y”开头。
步骤 3 – 在域维护屏幕的短文本字段中输入描述。在这种情况下，它是“客户域”。注意– 在您输入此属性之前，您不能输入任何其他属性。
步骤 4 – 在“定义”选项卡的“格式”块中输入数据类型、字符数和小数位。按输出长度上的键，它会建议并显示输出长度。如果覆盖建议的输出长度，则在激活域时可能会看到警告。您可以填写Convers。如果需要，常规、签名和小写字段。但这些总是可选的属性。
步骤 5 – 选择值范围选项卡。如果域被限制为只有固定值，则输入固定值或区间。如果系统必须在为引用此域的字段定义外键时建议此表作为检查表，则定义值表。但所有这些都是可选属性。
第 6 步– 保存您的更改。出现创建对象目录条目弹出窗口并要求提供包。您可以输入您正在使用的包名称。如果您没有任何包，那么您可以在对象导航器中创建它，或者您可以使用本地对象按钮保存您的域。
步骤 7 – 激活您的域。单击“激活”图标（火柴棒图标）或按 CTRL + F3 以激活域。出现一个弹出窗口，列出 2 个当前不活动的对象，如下面的快照所示 –
步骤 8 – 此时，将激活名为“DOMA”、名称为 ZSEP_18 的顶部条目。当它突出显示时，单击绿色勾号按钮。此窗口消失，状态栏将显示消息“对象已激活”。
如果在激活域时出现错误消息或警告，则会自动显示激活日志。激活日志显示有关激活流程的信息。您也可以使用 Utilities(M) → Activation log 调用激活日志。
SAP ABAP – 数据元素
数据元素描述 ABAP 数据字典中的各个字段。它们是复杂类型的最小不可分单位，用于定义表的字段类型、结构组件或行类型。有关表格字段含义的信息以及有关编辑相应屏幕字段的信息可以分配给数据元素。此信息可自动用于引用数据元素的所有屏幕字段。数据元素描述基本类型或引用类型。
创建数据元素
在创建新数据元素之前，您需要检查任何现有数据元素是否具有表字段中所需的相同语义规范。如果是这样，您可以使用该现有数据元素。您可以为数据元素分配预定义的类型、域或引用类型。
以下是创建数据元素的过程 –
步骤 1 – 转到事务 SE11。
步骤 2 – 在 ABAP 词典的初始屏幕中选择数据类型的单选按钮，然后输入数据元素的名称，如下所示。
步骤 3 – 单击创建按钮。您可以在客户命名空间下创建数据元素，并且对象的名称始终以“Z”或“Y”开头。
步骤 4 – 检查 CREATE TYPE 弹出窗口上的数据元素单选按钮，该按钮显示三个单选按钮。
步骤 5 – 单击绿色复选标记图标。您将被定向到数据元素的维护屏幕。
步骤 6 – 在数据元素维护屏幕的短文本字段中输入描述。在这种情况下，它是“客户数据元素”。注意– 在您输入此属性之前，您不能输入任何其他属性。
步骤 7 – 为数据元素分配类型。您可以通过检查基本类型来创建基本数据元素，或者通过检查引用类型来创建参考数据元素。您可以将数据元素分配给基本类型中的域或预定义类型，并在引用类型中使用引用类型名称或对预定义类型的引用。
步骤 8 – 在“字段标签”选项卡中输入短文本、中文本、长文本和标题的字段。您可以按 Enter 键，系统会自动为这些标签生成长度。
第 9 步– 保存您的更改。出现创建对象目录条目弹出窗口并要求提供包。您可以输入您正在使用的包名称。如果您没有任何包，那么您可以在对象导航器中创建它，或者您可以使用本地对象按钮保存您的数据元素。
步骤 10 – 激活您的数据元素。单击激活图标（火柴棒图标）或按 CTRL + F3 以激活数据元素。将出现一个弹出窗口，列出 2 个当前不活动的对象，如下面的屏幕截图所示。
步骤 11 – 此时，将激活名为 Z_CUST 的标有“DTEL”的顶部条目。当它突出显示时，单击绿色勾号按钮。此窗口消失，状态栏将显示消息“对象已激活”。
如果在激活数据元素时出现错误消息或警告，则会自动显示激活日志。激活日志显示有关激活流程的信息。您也可以使用 Utilities(M) → Activation log 调用激活日志。
SAP ABAP – 表格
表格可以独立于 ABAP Dictionary 中的数据库进行定义。当在 ABAP Dictionary 中激活表时，也会在数据库中创建其字段的类似副本。ABAP Dictionary 中定义的表会自动转换为与数据库兼容的格式，因为表的定义取决于 SAP 系统使用的数据库。
一张表可以包含一个或多个字段，每个字段都定义了其数据类型和长度。存储在表中的大量数据分布在表中定义的几个字段中。
表字段的类型
一张表由很多字段组成，每个字段又包含很多元素。下表列出了表格字段的不同元素 –
| S.No. | 元素和描述 |
|---|---|
| 1 |
Field name 这是为最多可包含 16 个字符的字段指定的名称。字段名称可以由数字、字母和下划线组成。它必须以字母开头。 |
| 2 |
Key flag 确定字段是否属于关键字段。 |
| 3 |
Field type 为字段分配数据类型。 |
| 4 |
Field length 可在字段中输入的字符数。 |
| 5 |
Decimal places 定义小数点后允许的位数。此元素仅用于数字数据类型。 |
| 6 |
Short text 描述相应字段的含义。 |
在 ABAP 字典中创建表
步骤 1 – 转到事务 SE11，选择“数据库表”单选按钮，然后输入要创建的表的名称。在我们的例子中，我们输入了名称 ZCUSTOMERS1。单击创建按钮。词典：维护表屏幕出现。此处默认选择“交付和维护”选项卡。
步骤 2 – 在“简短描述”字段中输入解释性短文本。
步骤 3 – 单击交付类别字段旁边的搜索帮助图标。选择“A [应用程序表（主数据和交易数据）]”选项。
步骤 4 – 从“数据浏览器/表视图维护”下拉菜单中选择“允许显示/维护”选项。词典：维护表屏幕出现。
步骤 5 – 选择字段选项卡。包含与字段选项卡相关的选项的屏幕出现。
步骤 6 – 在字段列中输入表字段的名称。字段名称可以包含字母、数字和下划线，但它必须始终以字母开头且长度不得超过 16 个字符。
要创建的字段还必须具有数据元素，因为它们从定义的数据元素中获取属性，例如数据类型、长度、小数位和短文本。
步骤 7 – 如果您希望该字段成为表键的一部分，请选择键列。让我们创建诸如 CLIENT、CUSTOMER、NAME、TITLE 和 DOB 之类的字段。
步骤 8 – 第一个字段很重要，它标识与记录相关联的客户端。输入“Client”作为字段，“MANDT”作为数据元素。系统自动填写数据类型、长度、小数和短描述。通过选中“密钥”框，“客户”字段成为关键字段。
第 9 步– 下一个字段是“客户”。选中该框以使其成为关键字段并输入新的数据元素“ZCUSTNUM”。单击保存按钮。
第 10 步– 由于数据元素“ZCUSTNUM”尚不存在，因此必须创建它。双击新数据元素，将出现“创建数据元素”窗口。对此回答“是”，将出现“维护数据元素”窗口。
步骤 11 – 在简短描述区域中输入“客户编号”。应为新数据元素定义名为“域”的基本数据类型。所以输入’ZCUSTD1’，双击它并同意保存所做的更改。选择“是”以创建域并在“简短描述”框中键入域的描述。
“定义”选项卡会自动打开。第一个字段是“数据类型”。
步骤 12 – 在框内单击并从下拉菜单中选择“NUMC”类型。在“编号”中输入数字 8。字符”字段（最多 8 个字符）并在“小数位数”区域输入 0。必须选择输出长度 8，然后按 Enter。“NUMC”字段的描述必须重新出现，以确认这是一个有效的条目。
步骤 13 – 单击保存按钮并激活对象。
步骤 14 – 按 F3 返回“维护/更改数据元素”屏幕。创建四个字段标签，如下面的快照所示。在此之后，保存并激活元素。
步骤 15 – 按后退按钮返回表维护屏幕。客户列具有正确的数据类型、长度、小数和简短描述。这表明成功创建了数据元素以及使用的域。
同样，我们需要创建三个附加字段，例如 NAME、TITLE 和 DOB。
步骤 16 – 从工具栏中选择“技术设置”。为“数据类”选择 APPL0，为“大小”类别字段选择第一个大小类别 0。在缓冲选项的情况下，必须选择“不允许缓冲”。
步骤 17 – 单击保存。回到桌子上并激活它。出现以下屏幕。
表“ZCUSTOMERS1”被激活。
SAP ABAP – 结构
结构是一种数据对象，它由一个接一个存储在内存中的任何数据类型的组件组成。
结构对于绘制屏幕字段以及处理具有由离散数量的字段定义的一致格式的数据非常有用。
一个结构在运行时可能只有一条记录，但一个表可以有许多记录。
创建结构
步骤 1 – 转到事务 SE11。
步骤 2 – 单击屏幕上的“数据类型”选项。输入名称“ZSTR_CUSTOMER1”并单击“创建”按钮。
步骤 3 – 在下一个屏幕中选择“结构”选项，然后按 Enter。您可以看到“维护/更改结构”向导。
步骤 4 – 输入简短描述，如下面的快照所示。
步骤 5 – 输入组件（字段名称）和组件类型（数据元素）。
注意：这里的组件名称按照 SAP 建议以 Z 开头。让我们使用我们已经在数据库表中创建的数据元素。
步骤 6 – 在提供所有组件和组件类型后，您需要保存、检查和激活。
出现以下屏幕 –
第 7 步– 当此“ZSTR_CUSTOMER1”突出显示时，单击绿色勾号按钮。此窗口消失，状态栏将显示消息“活动”。
该结构现在已激活，如下面的快照所示 –
SAP ABAP – 视图
视图仅充当数据库表。但它不会占用存储空间。视图的作用类似于虚拟表——一个没有任何物理存在的表。视图是通过组合一个或多个包含有关应用程序对象信息的表的数据来创建的。使用视图，您可以表示表中包含的数据的子集，也可以将多个表连接到一个虚拟表中。
与应用程序对象相关的数据通过使用数据库视图分布在多个表中。他们使用内连接条件来连接不同表的数据。维护视图用于显示和修改存储在应用程序对象中的数据。每个维护视图都有一个与之关联的维护状态。
我们使用投影视图来屏蔽不需要的字段并仅在表格中显示相关字段。投影视图必须在单个透明表上定义。一个投影视图只包含一个表。我们无法定义投影视图的选择条件。
创建视图
步骤 1 – 在 ABAP 词典的初始屏幕上选择查看单选按钮。输入要创建的视图的名称，然后单击“创建”按钮。我们输入的视图名称为 ZVIEW_TEST。
步骤 2 – 在选择视图类型时选择投影视图单选按钮，然后单击复制按钮。出现“词典：更改视图”屏幕。
Step 3 – 在 Short Description 字段中输入简短描述，并在 Basis Table 字段中输入要使用的表的名称，如下面的快照所示。
步骤 4 – 单击“表字段”按钮以在投影视图中包含 ZCUSTOMERS1 表的字段。
第 5 步– 从表 ZCUSTOMERS1 屏幕中选择字段出现。选择您希望包含在投影视图中的字段，如下面的快照所示。
步骤 6 – 单击“复制”按钮后，投影视图的所有选定字段都显示在“字典：更改视图”屏幕上。
步骤 7 – 选择维护状态选项卡以定义访问方法。从“数据浏览器/表视图维护”的下拉菜单中选择只读单选按钮和“限制显示/维护允许”选项。
步骤 8 – 保存并激活它。在“词典：更改视图”屏幕中，选择实用程序(M) > 内容以显示 ZVIEW_TEST 的选择屏幕。
步骤 9 – 单击执行图标。投影视图的输出如下面的屏幕截图所示。
表 ZCUSTOMERS1 包含 5 个字段。此处显示的字段为 3（客户、客户编号和名称），有 4 个条目。客户编号从 100001 到 100004，并带有适当的名称。
SAP ABAP – 搜索帮助
Search Help 是 ABAP Dictionary 的另一个存储库对象，用于以列表的形式显示字段的所有可能值。此列表也称为命中列表。您可以从此命中列表中选择要在字段中输入的值，而不是手动输入值，这样既乏味又容易出错。
创建搜索帮助
步骤 1 – 转到事务 SE11。选择搜索帮助的单选按钮。输入要创建的搜索帮助的名称。让我们输入名称 ZSRCH1。单击“创建”按钮。
步骤 2 – 系统将提示创建搜索帮助类型。选择基本搜索帮助，这是默认设置。将出现创建基本搜索帮助的屏幕，如下面的屏幕截图所示。
Step 3 – 在选择方法中，我们需要指出我们的数据源是表还是视图。在我们的例子中，它恰好是一张桌子。该表是 ZCUSTOMERS1。它是从选择列表中选择的。
步骤 4 – 输入选择方法后，下一个字段是对话框类型。这控制了限制性对话框的外观。有一个包含三个选项的下拉列表。让我们选择“立即显示值”选项。
步骤 5 – 接下来是参数区域。对于每个搜索帮助参数或字段，必须根据要求输入这些列字段。
-
搜索帮助参数– 这是来自数据源的字段。表中的字段列在选择列表中。将输入参与搜索帮助的字段，每行一个字段。让我们包括两个字段 CUSTOMER 和 NAME。这两个字段如何参与在其余列中指明。
-
导入– 此字段是一个复选框，用于指示搜索帮助参数是否为导入参数。导出或导入参考搜索帮助。
-
导出– 此字段是一个复选框，用于指示搜索帮助参数是否为导出参数。导出将字段值从选择列表传输到屏幕字段。
-
LPos – 它的值控制搜索帮助参数或字段在选择列表中的物理位置。如果输入值 1，该字段将出现在选择列表的第一个位置，依此类推。
-
SPos – 它控制搜索帮助参数或字段在限制性对话框中的物理位置。如果输入值 1，该字段将出现在限制性对话框的第一个位置，依此类推。
-
数据元素– 默认情况下，每个搜索帮助参数或字段都分配了一个数据元素，该数据元素在数据源（表或视图）中分配给它。此数据元素名称出现在显示模式中。
步骤 6 – 执行一致性检查并激活搜索帮助。按F8执行。出现“测试搜索帮助 ZSRCH1”屏幕，如下面的屏幕截图所示。
第 7 步– 让我们在客户的“准备输入”屏幕字段中输入数字 100004。按 Enter。
显示客户编号 100004 和名称“STEPHEN”。
SAP ABAP – 锁定对象
Lock Object 是 ABAP Dictionary 提供的一项功能，用于同步多个程序对相同数据的访问。在特定程序的帮助下访问数据记录。SAP中使用锁对象来避免数据插入或更改数据库时的不一致。要锁定其数据记录的表必须在锁定对象中定义，以及它们的关键字段。
锁定机制
以下是使用锁定机制完成的两个主要功能 –
-
一个程序可以与其他程序就它正在读取或更改的数据记录进行通信。
-
程序可以防止自己读取刚刚被另一个程序更改的数据。
甲锁定请求首先由程序产生。然后这个请求进入 Enqueue 服务器并在锁表中创建锁。Enqueue 服务器设置了锁，程序最终准备好访问数据。
创建锁对象
步骤 1 – 转到事务 SE11。将打开以下屏幕。
步骤 2 – 单击“锁定对象”单选按钮。输入以 E 开头的锁对象名称，然后单击“创建”按钮。这里我们使用 EZLOCK12。
步骤 3 – 输入简短描述字段并单击表选项卡。
Step 4 – 在 Name 字段中输入表名，然后选择锁定模式为 Write Lock。
步骤 5 – 单击锁定参数选项卡，将出现以下屏幕。
步骤 6 – 保存并激活。自动生成2个功能模块。要检查功能模块，我们可以使用 Go to → Lock Modules。
步骤 7 – 单击锁定模块，将打开以下屏幕。
锁对象创建成功。
锁定对象中包含的表的关键字段称为锁定参数，它们在功能模块中用作输入参数。这些参数用于设置和删除锁对象定义生成的锁。
SAP ABAP – 模块化
使您的程序尽可能独立且易于阅读是一种很好的做法。只需将每个任务放置在其单独的模块中，尝试将大型复杂的任务拆分为更小更简单的任务，开发人员可以专注于这些模块而不会受到其他干扰。
在 SAP ABAP 环境中，模块化涉及将程序组织成模块化单元，也称为逻辑块。它减少了冗余并提高了程序可读性，即使在您创建程序时以及随后的维护周期中也是如此。模块化还使相同代码的可重用性再次成为可能。与基于 OOPS 的语言相比，基于 OOPS 的语言具有相对更多的内置模块化功能，因此 ABAP 使开发人员必须模块化，即相对更多地组织程序。一旦一小部分模块化代码完成、调试等，随后就不必返回，开发人员可以继续关注其他问题。
ABAP 程序由称为模块化处理块的处理块组成。他们是 –
-
从程序外部和 ABAP 运行时环境调用的处理块（即事件块和对话模块）。
-
处理从 ABAP 程序调用的块。
除了使用处理块进行模块化外，源代码模块还用于通过宏和包含程序来模块化您的源代码。
源代码级别的模块化 –
- 本地宏
- 全局包含程序
通过处理从 ABAP 程序调用的块进行模块化 –
- 子程序
- 功能模块
模块化源代码意味着在模块中放置一系列 ABAP 语句。模块化的源代码可以根据用户的要求在程序中调用。源代码模块增强了 ABAP 程序的可读性和可理解性。创建单独的源代码模块还可以防止人们不得不一遍又一遍地重复编写相同的语句，这反过来又使第一次通过它的人更容易理解代码。
SAP ABAP – 子程序
子例程是可重用的代码段。它是程序中的一个模块化单元，其中以源代码的形式封装了一个功能。您可以将程序的一部分分页到子程序，以便更好地了解主程序，并多次使用相应的语句序列，如下图所示。
我们有3个不同的节目X的源代码块。每个块都有相同的 ABAP 语句。基本上，它们是相同的代码块。为了使这段代码更易于维护，我们可以将代码封装成一个子程序。我们可以在我们的程序中多次调用这个子程序。可以使用 Form 和 EndForm 语句定义子例程。
以下是子程序定义的一般语法。
FORM <subroutine_name>. <statements> ENDFORM.
我们可以使用 PERFORM 语句调用子程序。控制跳转到子例程 <subroutine_name> 中的第一个可执行语句。当遇到 ENDFORM 时，控制跳回到 PERFORM 语句之后的语句。
例子
步骤 1 – 转到事务 SE80。打开现有程序，然后右键单击程序。在这种情况下，它是“ZSUBTEST”。
步骤 2 – 选择创建，然后选择子程序。在字段中写入子程序名称，然后单击继续按钮。子程序名称为“Sub_Display”，如下面的屏幕截图所示。
第 3 步– 在 FORM 和 ENDFORM 语句块中编写代码。子程序已成功创建。
我们需要包含 PERFORM 语句来调用子程序。让我们来看看代码 –
REPORT ZSUBTEST. PERFORM Sub_Display. * Form Sub_Display * --> p1 text * <-- p2 text FORM Sub_Display. Write: 'This is Subroutine'. Write: / 'Subroutine created successfully'. ENDFORM. " Sub_Display
步骤 4 – 保存、激活并执行程序。上面的代码产生以下输出 –
Subroutine Test: This is Subroutine Subroutine created successfully
因此，使用子例程使您的程序更加面向功能。它将程序的任务拆分为子功能，以便每个子程序负责一个子功能。您的程序变得更容易维护，因为对功能的更改通常只需要在子程序中实现。
SAP ABAP – 宏
如果我们想在一个程序中多次重用同一组语句，我们需要将它们包含在一个宏中。例如，宏可用于长计算或编写复杂的 WRITE 语句。我们只能在定义它的程序中使用宏。宏定义应在程序中使用宏之前进行。
宏是基于占位符设计的。占位符的作用类似于 C 语言中的指针。您可以在 DEFINE…END-OF-DEFINITION 语句中定义宏。
以下是宏定义的基本语法 –
DEFINE <macro_name>. <statements> END-OF-DEFINITION. ...... <macro_name> [<param1> <param2>....].
需要先定义一个宏，然后再调用它。<param1>…. 替换宏定义中包含的 ABAP 语句中的占位符 &1…。
宏定义中占位符的最大数量为九个。也就是说，当程序执行时，SAP 系统用适当的语句替换宏，并且占位符 &1、&2、….&9 被参数 param1、param2、….param9 替换。我们可以在另一个宏中调用一个宏，但不是同一个宏。
例子
转到事务 SE38。创建一个新程序 ZMACRO_TEST 以及短文本字段中的描述，以及适当的属性，例如类型和状态，如下面的屏幕截图所示 –
以下是代码 –
REPORT ZMACRO_TEST. DEFINE mac_test. WRITE: 'This is Macro &1'. END-OF-DEFINITION. PARAMETERS: s1 type C as checkbox. PARAMETERS: s2 type C as checkbox. PARAMETERS: s3 type C as checkbox default 'X'. START-OF-SELECTION. IF s1 = 'X'. mac_test 1. ENDIF. IF s2 = 'X'. mac_test 2. ENDIF. IF s3 = 'X'. mac_test 3. ENDIF.
我们有 3 个复选框。在执行程序时，让我们选中 S2 复选框。
上面的代码产生以下输出 –
A Macro Program This is Macro 2
如果所有复选框都被选中，代码会产生以下输出 –
A Macro Program This is Macro 1 This is Macro 2 This is Macro 3
SAP ABAP – 功能模块
功能模块构成了 SAP 系统的主要部分，因为多年来 SAP 一直使用功能模块对代码进行模块化，允许他们自己、他们的开发人员以及他们的客户重用代码。
功能模块是包含一组带有导入和导出参数的可重用语句的子程序。与 Include 程序不同，功能模块可以独立执行。SAP 系统包含多个预定义的功能模块，可以从任何 ABAP 程序中调用。功能组充当许多逻辑上属于一起的功能模块的容器。例如，人力资源薪资系统的功能模块将被放在一个功能组中。
要了解如何创建功能模块，必须探索功能构建器。您可以找到事务代码为 SE37 的函数生成器。只需键入带有通配符的功能模块名称的一部分，以演示可以搜索功能模块的方式。键入 *amount*，然后按 F4 键。
搜索结果将显示在新窗口中。功能模块显示在蓝色背景的行中，其功能组显示在粉红色的行中。您可以使用对象导航器屏幕（事务 SE80）进一步查看功能组 ISOC。您可以看到功能模块列表以及功能组中保存的其他对象。让我们考虑功能模块 SPELL_AMOUNT。该功能模块将数字转换为文字。
创建新程序
步骤 1 – 转到事务 SE38 并创建一个名为 Z_SPELLAMOUNT 的新程序。
步骤 2 – 输入一些代码，以便可以设置参数，其中可以输入值并将其传递给功能模块。此处的文本元素 text-001 显示为“输入值”。
第 3 步– 要为此编写代码，请使用 CTRL+F6。此后，将出现一个窗口，其中“CALL FUNCTION”是列表中的第一个选项。在文本框中输入“spell_amount”并单击“继续”按钮。
步骤 4 – 一些代码是自动生成的。但是我们需要增强 IF 语句以包含一个代码来向屏幕写入一条消息，说“功能模块返回的值是：sy-subrc”并添加 ELSE 语句，以便在函数执行时写出正确的结果模块成功。这里，必须设置一个新变量来保存从功能模块返回的值。我们将其称为“结果”。
以下是代码 –
REPORT Z_SPELLAMOUNT. data result like SPELL. selection-screen begin of line. selection-screen comment 1(15) text-001. parameter num_1 Type I. selection-screen end of line. CALL FUNCTION 'SPELL_AMOUNT' EXPORTING AMOUNT = num_1 IMPORTING IN_WORDS = result. IF SY-SUBRC <> 0. Write: 'Value returned is:', SY-SUBRC. else. Write: 'Amount in words is:', result-word. ENDIF.
步骤 5 – 功能模块返回的变量称为 IN_WORDS。在名为“result”的程序中设置相应的变量。通过使用 LIKE 语句来引用称为 SPELL 的结构来定义 IN_WORDS。
步骤 6 – 保存、激活并执行程序。输入一个值，如下面的屏幕截图所示，然后按 F8。
上面的代码产生以下输出 –
Spelling the Amount Amount in words is: FIVE THOUSAND SIX HUNDRED EIGHTY
SAP ABAP – 包括程序
包含程序是用于模块化源代码的全局存储库对象。它们允许您在不同的程序中使用相同的源代码。包含程序还允许您以有序的方式管理复杂的程序。为了在另一个程序中使用包含程序，我们使用以下语法 –
INCLUDE <program_name>.
INCLUDE 语句与将包含程序 <program_name> 的源代码复制到另一个程序中具有相同的效果。由于include程序不能独立运行，它必须被内置到其他程序中。您还可以嵌套包含程序。
以下是编写包含程序代码时的一些限制 –
- 包含程序不能调用自己。
- 包含程序必须包含完整的语句。
以下是创建和使用包含程序的步骤 –
步骤 1 – 创建要包含在 ABAP 编辑器中的程序 (Z_TOBEINCLUDED)。要包含在 ABAP 编辑器中的代码是 –
PROGRAM Z_TOBEINCLUDED.
Write: / 'This program is started by:', SY-UNAME,
/ 'The Date is:', SY-DATUM,
/ 'Time is', SY-UZEIT.
步骤 2 – 将程序类型设置为包含程序，如下面的屏幕截图所示。
步骤 3 – 单击“保存”按钮并将程序保存在名为 ZINCL_PCKG 的包中。
第 4 步– 创建另一个必须使用程序 Z_TOBEINCLUDED 的程序。这里我们创建了另一个名为 Z_INCLUDINGTEST 的程序，并将该程序的类型指定为可执行程序。
步骤 5 – Z_INCLUDINGTEST 程序的编码在 INCLUDE 语句的帮助下包括 Z_TOBEINCLUDED 程序，如下面的代码所示。
REPORT Z_INCLUDINGTEST. INCLUDE Z_TOBEINCLUDED.
步骤 6 – 保存、激活并执行程序。
上面的代码产生以下输出 –
This program is started by: SAPUSER The Date is: 06.10.2015 Time is 13:25:11
SAP ABAP – Open SQL 概述
Open SQL 表示 ABAP 语句的子集，可以直接访问当前 AS ABAP 的中央数据库中的数据。Open SQL 语句映射了所有数据库系统都支持的 ABAP 中 SQL 的数据操作语言功能。
Open SQL 的语句在数据库接口的 Open SQL 接口中转换为数据库特定的 SQL。然后将它们传输到数据库系统并执行。Open SQL 语句可用于访问在 ABAP 字典中声明的数据库表。默认情况下访问 AS ABAP 的中央数据库，也可以通过辅助数据库连接访问其他数据库。
每当在 ABAP 程序中使用这些语句中的任何一个时，检查执行的操作是否成功是很重要的。如果试图将一条记录插入到数据库表中，但没有正确插入，了解这一点非常重要，以便在程序中采取适当的行动。这可以使用已经使用过的系统字段来完成，即 SY-SUBRC。当一条语句成功执行时，SY-SUBRC 字段将包含一个值 0，因此可以检查这一点，如果出现，可以继续执行程序。
DATA 语句用于声明工作区。让我们将其命名为“wa_customers1”。与其为此声明一种数据类型，不如声明几个组成表的字段。最简单的方法是使用 LIKE 语句。
插入语句
wa_customers1 工作区在此处声明为类似于 ZCUSTOMERS1 表，采用相同的结构，但本身不成为表。该工作区只能存储一条记录。声明后，可以使用 INSERT 语句将工作区和它保存的记录插入到表中。此处的代码将显示为“INSERT ZCUSTOMERS1 FROM wa_customers1”。
工作区必须填充一些数据。使用 ZCUSTOMERS1 表中的字段名称。这可以通过向前导航、双击代码中的表名称或通过打开一个新会话并使用事务 SE11 来完成。然后可以将表的字段复制并粘贴到 ABAP 编辑器中。
以下是代码片段 –
DATA wa_customers1 LIKE ZCUSTOMERS1. wa_customers1-customer = '100006'. wa_customers1-name = 'DAVE'. wa_customers1-title = 'MR'. wa_customers1-dob = '19931017'. INSERT ZCUSTOMERS1 FROM wa_customers1.
然后可以按如下方式使用 CHECK 语句。这意味着如果记录插入正确，系统会说明这一点。如果不是，则将显示不等于零的 SY-SUBRC 代码。以下是代码片段 –
IF SY-SUBRC = 0. WRITE 'Record Inserted Successfully'. ELSE. WRITE: 'The return code is ', SY-SUBRC. ENDIF.
检查程序，保存，激活代码，然后进行测试。输出窗口应显示为“记录插入成功”。
清除声明
CLEAR 语句允许清除字段或变量以在其位置插入新数据，从而允许重复使用。CLEAR 语句通常用于程序中，它允许多次使用现有字段。
在前面的代码片段中，工作区结构已填充数据以创建要插入到 ZCUSTOMERS1 表中的新记录，然后执行验证检查。如果我们想插入一条新记录，必须使用 CLEAR 语句，以便它可以再次用新数据填充。
更新声明
如果要同时更新表中的一个或多个现有记录，请使用 UPDATE 语句。与 INSERT 语句类似，声明了一个工作区，其中填充了新数据，然后在程序执行时将这些数据放入记录中。先前使用 INSERT 语句创建的记录将在此处更新。只需编辑存储在 NAME 和 TITLE 字段中的文本。然后在新行上，使用与 INSERT 语句相同的结构，这次使用 UPDATE 语句，如下面的代码片段所示 –
DATA wa_customers1 LIKE ZCUSTOMERS1. wa_customers1-customer = '100006'. wa_customers1-name = 'RICHARD'. wa_customers1-title = 'MR'. wa_customers1-dob = '19931017'. UPDATE ZCUSTOMERS1 FROM wa_customers1.
当执行 UPDATE 语句时，您可以在 ABAP 字典中查看数据浏览器以查看记录已成功更新。
修改声明
MODIFY 语句可以被认为是 INSERT 和 UPDATE 语句的组合。它可用于插入新记录或修改现有记录。在修改输入到工作区的数据中的记录时，它遵循与前两个语句类似的语法。
执行此语句时，将根据表中的字段检查所涉及的关键字段。如果已存在具有这些关键字段值的记录，则将对其进行更新。如果没有，则将创建一个新记录。
以下是创建新记录的代码片段 –
CLEAR wa_customers1. DATA wa_customers1 LIKE ZCUSTOMERS1. wa_customers1-customer = '100007'. wa_customers1-name = 'RALPH'. wa_customers1-title = 'MR'. wa_customers1-dob = '19910921'. MODIFY ZCUSTOMERS1 FROM wa_customers1.
在此示例中，使用 CLEAR 语句以便可以将新条目放入工作区，然后添加客户（编号）100007。由于这是一个新的、唯一的键字段值，因此将插入一条新记录，并执行另一项验证检查。
执行此操作并在数据浏览器中查看数据时，将为客户编号 100007 (RALPH) 创建一个新记录。
上面的代码产生以下输出（表格内容） –
SAP ABAP – 本机 SQL 概述
术语“Native SQL”是指可以静态传输到数据库接口的 Native SQL 接口的所有语句。本机 SQL 语句不属于 ABAP 的语言范围，也不遵循 ABAP 语法。ABAP 仅包含用于隔离可以列出本机 SQL 语句的程序部分的语句。
在原生 SQL 中，主要可以使用特定于数据库的 SQL 语句。这些从原生 SQL 接口原封不动地传输到数据库系统并执行。可以使用相关数据库的完整 SQL 语言范围，并且不必在 ABAP 词典中声明寻址的数据库表。还有一小组特定于 SAP 的本机 SQL 语句，它们由本机 SQL 接口以特定方式处理。
要使用本机 SQL 语句，您必须在它之前使用 EXEC SQL 语句并以 ENDEXEC 语句结束。
以下是语法 –
EXEC SQL PERFORMING <form>. <Native SQL statement> ENDEXEC.
这些语句在 ABAP 程序中定义了一个区域，其中可以列出一个或多个 Native SQL 语句。输入的语句被传递到 Native SQL 接口，然后按如下方式处理 –
-
所有对寻址数据库系统的程序接口有效的 SQL 语句都可以在 EXEC 和 ENDEXEC 之间列出，特别是 DDL（数据定义语言）语句。
-
这些 SQL 语句从 Native SQL 接口传递到数据库系统，基本上没有改变。语法规则由数据库系统指定，尤其是数据库对象的区分大小写规则。
-
如果语法允许在单个语句之间使用分隔符，则可以在 EXEC 和 ENDEXEC 之间包含许多本机 SQL 语句。
-
可以在 EXEC 和 ENDEXEC 之间指定 SAP 特定的本地 SQL 语言元素。这些语句不是直接从 Native SQL 接口传递到数据库，而是经过适当的转换。
例子
SPFLI 是一个标准的 SAP 表，用于存储航班时刻表信息。这在 R/3 SAP 系统中可用，具体取决于版本和发行级别。您可以在将表名称 SPFLI 输入到相关 SAP 事务（例如 SE11 或 SE80）中时查看此信息。您还可以通过使用这两个事务来查看该数据库表中包含的数据。
REPORT ZDEMONATIVE_SQL.
DATA: BEGIN OF wa,
connid TYPE SPFLI-connid,
cityfrom TYPE SPFLI-cityfrom,
cityto TYPE SPFLI-cityto,
END OF wa.
DATA c1 TYPE SPFLI-carrid VALUE 'LH'.
EXEC SQL PERFORMING loop_output.
SELECT connid, cityfrom, cityto
INTO :wa
FROM SPFLI
WHERE carrid = :c1
ENDEXEC.
FORM loop_output.
WRITE: / wa-connid, wa-cityfrom, wa-cityto.
ENDFORM.
上面的代码产生以下输出 –
0400 FRANKFURT NEW YORK 2402 FRANKFURT BERLIN 0402 FRANKFURT NEW YORK
SAP ABAP – 内部表
内部表实际上是一个临时表，它包含正在执行的 ABAP 程序的记录。内部表仅存在于 SAP 程序的运行时。它们用于通过使用 ABAP 语言处理大量数据。当您需要从数据库表中检索数据时，我们需要在 ABAP 程序中声明一个内部表。
内部表中的数据按行和列存储。每行称为一行，每列称为一个字段。在一个内部表中，所有记录都具有相同的结构和键。使用索引或键访问内部表的各个记录。由于内表一直存在到相关的程序正在执行，当程序执行终止时，内表的记录将被丢弃。因此内部表可以用作临时存储区域或临时缓冲区，可以根据需要修改数据。这些表只在运行时占用内存，在声明时不占用内存。
内部表只在程序运行时存在，因此在编写代码时，内部表的结构必须使程序可以使用它。您会发现内部表的操作方式与结构相同。主要区别在于结构只有一行，而内部表可以根据需要有任意多行。
内部表可以由多个字段组成，对应于表的列，就像在 ABAP 字典中使用多个字段创建表一样。键字段也可以与内部表一起使用，并且在创建这些内部表时，它们提供了更大的灵活性。对于内部表，可以指定一个非唯一键，允许存储任意数量的非唯一记录，并允许在需要时存储重复记录。
内部表的大小或它包含的行数不是固定的。内表的大小根据与内表相关联的程序的要求而变化。但建议保持内部表尽可能小。这是为了避免系统在处理大量数据时运行缓慢。
内部表有多种用途 –
-
它们可用于保存稍后可在程序中使用的计算结果。
-
内部表还可以保存记录和数据，以便可以快速访问这些数据，而不必从数据库表中访问这些数据。
-
它们用途广泛。它们可以使用任意数量的其他已定义结构来定义。
例子
假设用户想要从一个或多个大表中创建各种客户的联系号码列表。用户首先创建一个内表，从客户表中选择相关数据，然后将数据放入内表中。其他用户可以直接访问和使用这个内部表来检索所需的信息，而不是在程序运行时编写数据库查询来执行每个操作。
SAP ABAP – 创建内部表
DATA 语句用于声明一个内表。必须告诉程序表的开始和结束位置。所以使用BEGIN OF 语句然后声明表名。在此之后，使用 OCCURS 加法，后跟一个数字，这里是 0。OCCURS 告诉 SAP 正在创建一个内部表，0 表示它最初不包含任何记录。然后它会随着数据填充而扩展。
以下是语法 –
DATA: BEGIN OF <internal_tab> Occurs 0,
让我们在新行上创建字段。例如，创建声明为 LIKE ZCUSTOMERS1-name 的“name”。创建另一个名为“dob”的字段，例如 ZCUSTOMERS1-dob。最初为内部表中的字段名称赋予与在别处创建的其他字段相同的名称是很有用的。最后，用“END OF <internal_tab>”声明内部表的结尾。如以下代码所示 –
DATA: BEGIN OF itab01 Occurs 0, name LIKE ZCUSTOMERS1-name, dob LIKE ZCUSTOMERS1-dob, END OF itab01.
这里的“itab01”是在 SAP 中创建临时表时常用的简写。OCCURS 子句用于通过声明表的字段来定义内部表的主体。使用 OCCURS 子句时，如果需要，您可以指定数字常量“n”来确定额外的默认内存。OCCUR 0 子句使用的默认内存大小为 8 KB。现在内部表的结构已经创建，可以编写代码用记录填充它。
可以使用或不使用标题行来创建内部表。要创建带有标题行的内部表，请在内部表定义中的 OCCURS 子句之前使用 BEGIN OF 子句或在 OCCURS 子句之后使用 WITH HEADER LINE 子句。要创建没有标题行的内部表，请使用不带 BEGIN OF 子句的 OCCURS 子句。
您还可以使用 TYPES 语句将内部表创建为本地数据类型（仅在当前程序的上下文中使用的数据类型）。此语句使用 TYPE 或 LIKE 子句来引用现有表。
创建内部表作为本地数据类型的语法是 –
TYPES <internal_tab> TYPE|LIKE <internal_tab_type> OF <line_type_itab> WITH <key> INITIAL SIZE <size_number>.
这里<internal_tab_type> 指定了一个内表<internal_tab> 的表类型，而<line_type_itab> 指定了一个内表的一行的类型。在TYPES 语句中，可以使用TYPE 子句将内表的行类型指定为数据类型，使用LIKE 子句将行类型指定为数据对象。为内部表指定一个键是可选的，如果用户没有指定一个键，SAP 系统定义一个带有任意键的表类型。
INITIAL SIZE <size_number> 通过为其分配初始内存量来创建内部表对象。在前面的语法中，INITIAL SIZE 子句为 size_number 表行保留了内存空间。每当声明一个内部表对象时，表的大小不属于表的数据类型。
注意– 第一次填充内部表时消耗的内存要少得多。
例子
步骤 1 – 通过执行 SE38 事务代码打开 ABAP 编辑器。出现 ABAP 编辑器的初始屏幕。
步骤 2 – 在初始屏幕中，输入程序名称，选择源代码单选按钮，然后单击创建按钮以创建新程序。
步骤 3 – 在“ABAP：程序属性”对话框中，在“标题”字段中输入程序的简短描述，从“属性”组框中的“类型”下拉菜单中选择“可执行程序”选项。单击保存按钮。
第 4 步– 在 ABAP 编辑器中编写以下代码。
REPORT ZINTERNAL_DEMO. TYPES: BEGIN OF CustomerLine, Cust_ID TYPE C, Cust_Name(20) TYPE C, END OF CustomerLine. TYPES mytable TYPE SORTED TABLE OF CustomerLine WITH UNIQUE KEY Cust_ID. WRITE:/'The mytable is an Internal Table'.
步骤 5 – 像往常一样保存、激活和执行程序。
在此示例中，mytable 是一个内部表，并且在 Cust_ID 字段上定义了一个唯一键。
上面的代码产生以下输出 –
The mytable is an Internal Table.
SAP ABAP – 填充内部表
在内部表中，填充包括选择、插入和追加等功能。本章重点介绍 INSERT 和 APPEND 语句。
插入语句
INSERT 语句用于将单行或一组行插入到内部表中。
以下是向内部表添加单行的语法 –
INSERT <work_area_itab> INTO <internal_tab> INDEX <index_num>.
在此语法中，INSERT 语句在 internal_tab 内部表中插入一个新行。可以在 internal_tab 参数前使用 work_area_itab INTO 表达式插入新行。当使用 work_area_itab INTO 表达式时，新行取自 work_area_itab 工作区并插入到 internal_tab 表中。但是，当没有使用 work_area_itab INTO 表达式插入行时，该行取自 internal_tab 表的标题行。
使用INDEX子句在内部表中插入新行时，插入行后的行的索引号加1。如果内部表包含<index_num> – 1行，则在插入行后的行的索引号加1。桌子的尽头。当 SAP 系统成功地向内部表添加一行时，SY-SUBRC 变量设置为 0。
例子
以下是使用插入语句的示例程序。
REPORT ZCUSLIST1.
DATA: BEGIN OF itable1 OCCURS 4,
F1 LIKE SY-INDEX,
END OF itable1.
DO 4 TIMES.
itable1-F1 = sy-index.
APPEND itable1.
ENDDO.
itable1-F1 = -96.
INSERT itable1 INDEX 2.
LOOP AT itable1.
Write / itable1-F1.
ENDLOOP.
LOOP AT itable1 Where F1 ≥ 3.
itable1-F1 = -78.
INSERT itable1.
ENDLOOP.
Skip.
LOOP AT itable1.
Write / itable1-F1.
ENDLOOP.
上面的代码产生以下输出 –
1 96- 2 3 4 1 96- 2 78- 3 78- 4
在上面的示例中，DO 循环将包含数字 1 到 4 的 4 行附加到它。标题行组件 itable1-F1 已分配值 -96。Insert 语句将标题行作为新行插入正文中的第 3 行之前。现有的第 3 行在插入后变为第 4 行。LOOP AT 语句从内部表中检索那些 F1 值大于或等于 3 的行。在每一行之前，Insert 语句从它的标题行插入一个新行。在插入之前，F1 组件已更改为包含 -78。
每条插入语句执行后，系统都会重新索引插入语句下面的所有行。当您在大型内部表的顶部附近插入行时，这会引入开销。如果您需要向大型内部表中插入行块，请准备另一个包含要插入行的表并使用插入行。
在 itable1 的循环内的 itable1 中插入新行时，它不会立即影响内部表。它实际上在下一个循环传递中生效。在当前行之后插入一行时，表会在 ENDLOOP 处重新索引。sy-tabix 递增，下一个循环处理 sy-tabix 指向的行。例如，如果您在第二轮循环中并在第 3 行之前插入一条记录。执行 endloop 时，新行变为第 3 行，旧行 3 变为第 4 行，依此类推。Sy-tabix 加 1，下一个循环处理新插入的记录。
附加声明
APPEND 语句用于向现有的内部表添加单行或一行。此语句从工作区复制一行并将其插入到内部表中的最后一行之后。工作区可以是标题行，也可以是与内部表的行具有相同结构的任何其他字段字符串。以下是用于在内部表中附加一行的 APPEND 语句的语法 –
APPEND <record_for_itab> TO <internal_tab>.
在此语法中，<record_for_itab> 表达式可以由 <work_area_itab> 工作区表示，该工作区可转换为线型或由 INITIAL LINE 子句表示。如果用户使用 <work_area_itab> 工作区，SAP 系统会在 <internal_tab> 内部表中添加一个新行，并用工作区的内容填充它。INITIAL LINE 子句附加一个空行，其中包含表结构的每个字段的初始值。在每个 APPEND 语句之后，SY-TABIX 变量包含附加行的索引号。
无论表中是否已存在具有相同键的行，使用非唯一键将行附加到标准表和排序表都有效。换句话说，可能会出现重复条目。但是，如果用户尝试将重复条目添加到具有唯一键的排序表中，或者如果用户通过向排序表追加行来违反排序表的排序顺序，则会发生运行时错误。
例子
REPORT ZCUSLIST1.
DATA: BEGIN OF linv Occurs 0,
Name(20) TYPE C,
ID_Number TYPE I,
END OF linv.
DATA table1 LIKE TABLE OF linv.
linv-Name = 'Melissa'.
linv-ID_Number = 105467.
APPEND linv TO table1.
LOOP AT table1 INTO linv.
Write: / linv-name, linv-ID_Number.
ENDLOOP.
上面的代码产生以下输出 –
Melissa 105467
SAP ABAP – 复制内部表
当我们从带有标题行的内部表中读取记录时，该记录会从表本身移动到标题行中。然后是我们的程序使用的标题行。这同样适用于创建新记录。它是您使用的标题行，新记录从它发送到表体本身。
要复制记录，我们可以使用 SELECT 语句从表中选择所有记录，然后使用 MOVE 语句将记录从原始表中移动到新的内部表中到名称对应的字段中。
以下是 MOVE 语句的语法 –
MOVE <table_field> TO <internal_tab_field>.
例子
REPORT ZCUSLIST1.
TABLES: ZCUSTOMERS1.
DATA: BEGIN OF itab01 Occurs 0,
name LIKE ZCUSTOMERS1-name,
dob LIKE ZCUSTOMERS1-dob,
END OF itab01.
Select * FROM ZCUSTOMERS1.
MOVE ZCUSTOMERS1-name TO itab01-name.
MOVE ZCUSTOMERS1-dob TO itab01-dob.
ENDSELECT.
Write: / itab01-name, itab01-dob.
上面的代码产生以下输出 –
MARGARET 02.11.1994
select 循环一次填充每个字段，使用 MOVE 语句将数据从一个表的字段移动到另一个字段。在上面的示例中，使用 MOVE 语句将 ZCUSTOMERS1 表的内容移动到内部表中的相应字段。您只需一行代码即可完成此操作。您可以使用 MOVECORRESPONDING 语句。
以下是 MOVE-CORRESPONDING 语句的语法 –
MOVE-CORRESPONDING <table_name> TO <internal_tab>.
它告诉系统将数据从 ZCUSTOMERS1 的字段移动到 itab01 中的相应字段。
例子
REPORT ZCUSTOMERLIST.
TABLES: ZCUSTOMERS1.
DATA: Begin of itab01 occurs 0,
customer LIKE ZCUSTOMERS1-customer,
name LIKE ZCUSTOMERS1-name,
title LIKE ZCUSTOMERS1-title,
dob LIKE ZCUSTOMERS1-dob,
END OF itab01.
SELECT * from ZCUSTOMERS1.
MOVE-Corresponding ZCUSTOMERS1 TO itab01.
APPEND itab01.
ENDSELECT.
LOOP AT itab01.
Write: / itab01-name, itab01-dob.
ENDLOOP.
上面的代码产生以下输出 –
MARK 21.05.1981 JAMES 14.08.1977 AURIELE 19.06.1990 STEPHEN 22.07.1985 MARGARET 02.11.1994
这是因为两者都有匹配的字段名称。使用此语句时，您需要确保两个字段都具有匹配的数据类型和长度。此处已使用 LIKE 语句完成此操作。
SAP ABAP – 读取内部表
我们可以使用 READ TABLE 语句的以下语法来读取表的行 –
READ TABLE <internal_table> FROM <work_area_itab>.
在此语法中，<work_area_itab> 表达式表示与 <internal_table> 表的行类型兼容的工作区。我们可以使用 WITH KEY 子句在 READ 语句中指定搜索键，但不能指定表键，如以下语法所示 –
READ TABLE <internal_table> WITH KEY = <internal_tab_field>.
这里内表的整行都用作搜索关键字。将表格整行的内容与<internal_tab_field> 字段的内容进行比较。如果<internal_tab_field> 字段的值与表的线型不兼容，则根据表的线型转换这些值。搜索键允许您在内部表中查找没有结构化行类型的条目，即行是单个字段或内部表类型的条目。
READ 语句的以下语法用于通过使用 COMPARING 子句指定工作区或字段符号 –
READ TABLE <internal_table> <key> INTO <work_area_itab> [COMPARING <F1> <F2>...<Fn>].
当使用 COMPARING 子句时，结构化线型的指定表字段 <F1>、<F2>….<Fn> 与工作区的相应字段进行比较，然后再传输。如果指定了 ALL FIELDS 子句，SAP 系统将比较所有组件。当 SAP 系统根据一个键找到一个条目时，SY-SUBRC 变量的值被设置为 0。另外，如果比较的内容，SY-SUBRC 变量的值被设置为 2 或 4。字段不相同或 SAP 系统找不到条目。但是，无论比较的结果如何，只要找到条目，SAP 系统就会将该条目复制到目标工作区中。
例子
REPORT ZREAD_DEMO. */Creating an internal table DATA: BEGIN OF Record1, ColP TYPE I, ColQ TYPE I, END OF Record1. DATA mytable LIKE HASHED TABLE OF Record1 WITH UNIQUE KEY ColP. DO 6 Times. Record1-ColP = SY-INDEX. Record1-ColQ = SY-INDEX + 5. INSERT Record1 INTO TABLE mytable. ENDDO. Record1-ColP = 4. Record1-ColQ = 12. READ TABLE mytable FROM Record1 INTO Record1 COMPARING ColQ. WRITE: 'SY-SUBRC =', SY-SUBRC. SKIP. WRITE: / Record1-ColP, Record1-ColQ.
上面的代码产生以下输出 –
SY-SUBRC = 2 4 9
在上面的例子中，mytable 是一个哈希表类型的内部表，Record1 为工作区，ColP 为唯一键。最初，mytable 由六行填充，其中 ColP 字段包含 SY-INDEX 变量的值，ColQ 字段包含 (SY-INDEX + 5) 值。
Record1 工作区分别填充了 4 和 12 作为 ColP 和 ColQ 字段的值。READ 语句使用 COMPARING 子句将 ColP 键字段的值与 Record1 工作区中的值进行比较后读取表的行，然后将读取行的内容复制到工作区中。SY-SUBRC变量的值显示为2是因为ColP字段中的值为4时，ColQ中的值不是12，而是9。
SAP ABAP – 删除内部表
DELETE 语句用于从内部表中删除一条或多条记录。通过指定表键或条件或通过查找重复条目来删除内部表的记录。如果内部表具有非唯一键并包含重复条目，则表中的第一个条目将被删除。
以下是使用 DELETE 语句从内部表中删除记录或行的语法 –
DELETE TABLE <internal_table> FROM <work_area_itab>.
在上面的语法中，<work_area_itab> 表达式是一个工作区，它应该与<internal_table> 内部表的类型兼容。删除操作是根据可以从工作区组件中获取的默认键执行的。
您还可以使用以下语法在 DELETE TABLE 语句中显式指定表键 –
DELETE TABLE <internal_table> WITH TABLE KEY <K1> = <F1>………… <Kn> = <Fn>.
在此语法中，<F1>、<F2>….<Fn> 是内部表的字段，<K1>、<K2>….<Kn> 是表的关键字段。DELETE 语句用于根据表达式<K1> = <F1>, <K2> = <F2>…<Kn> = <Fn> 删除<internal_table> 表的记录或行。
注意– 如果 <F1>、<F2>….<Fn> 字段的数据类型与 <K1>、<K2>…<Kn> 关键字段不兼容，则 SAP 系统会自动转换它们转换为兼容格式。
例子
REPORT ZDELETE_DEMO. DATA: BEGIN OF Line1, ColP TYPE I, ColQ TYPE I, END OF Line1. DATA mytable LIKE HASHED TABLE OF Line1 WITH UNIQUE KEY ColP. DO 8 TIMES. Line1-ColP = SY-INDEX. Line1-ColQ = SY-INDEX + 4. INSERT Line1 INTO TABLE mytable. ENDDO. Line1-ColP = 1. DELETE TABLE mytable: FROM Line1, WITH TABLE KEY ColP = 3. LOOP AT mytable INTO Line1. WRITE: / Line1-ColP, Line1-ColQ. ENDLOOP.
上面的代码产生以下输出 –
2 6 4 8 5 9 6 10 7 11 8 12
在这个例子中，mytable 有两个字段，ColP 和 ColQ。最初，mytable 由八行填充，其中 ColP 包含值 1、2、3、4、5、6、7 和 8。ColQ 包含值 5、6、7、8、9、10、11 和12 因为 ColP 值每次都增加 4。
DELETE语句用于删除mytable中ColP键域值为1或3的行。删除后，mytable的ColP域包含值2、4、5、6、7、8，如图在输出中。ColQ 字段包含值 6、8、9、10、11 和 12。
SAP ABAP – 面向对象
面向对象简化了软件设计，使其更易于理解、维护和重用。面向对象编程(OOP) 代表了编写软件的一种不同的思维方式。OOP 的美妙之处在于它的简单性。OOP 的表现力使得按时交付高质量的软件组件变得更加容易。
由于解决方案是根据现实世界的对象设计的，因此程序员和业务分析师就使用公共领域语言的设计交换想法和信息变得更加容易。这些沟通方面的改进有助于揭示隐藏的需求、识别风险并提高正在开发的软件的质量。面向对象的方法侧重于代表现实世界中抽象或具体事物的对象。这些对象由它们的特性和特性定义，特性和特性由它们的内部结构和它们的属性（数据）表示。这些对象的行为由方法（即功能）描述。
让我们比较面向过程和面向对象的编程 –
| Features | 面向过程的方法 | 面向对象的方法 |
|---|---|---|
| Emphasis | 重点是任务。 | 重点是完成这些任务的事情。 |
| Modularization | 程序可以分为称为函数的较小程序。 | 程序被组织成类和对象，功能被嵌入到类的方法中。 |
| Data security | 大多数功能共享全局数据。 | 数据可以隐藏，外部来源无法访问。 |
| Extensibility | 修改和扩展现有功能更耗时。 | 可以在需要时毫不费力地添加新数据和功能。 |
ABAP 最初是作为一种过程语言开发的（类似于早期的过程编程语言，如 COBOL）。但是 ABAP 现在已经通过引入 ABAP 对象适应了面向对象范式的原则。ABAP 中的面向对象概念，如类、对象、继承和多态，与其他现代面向对象语言（如 Java 或 C++）的概念基本相同。
随着面向对象开始形成，每个类都承担特定的角色分配。这种分工有助于简化整体编程模型，允许每个班级专门解决手头问题的特定部分。这样的类具有很高的内聚性，并且每个类的操作都以某种直观的方式密切相关。
面向对象的主要特点是 –
- 有效的编程结构。
- 现实世界的实体可以很好地建模。
- 强调数据安全和访问。
- 最大限度地减少代码冗余。
- 数据抽象和封装。
SAP ABAP – 对象
对象是一种特殊的变量，具有不同的特征和行为。对象的特性或属性用于描述对象的状态，行为或方法表示对象执行的动作。
对象是类的模式或实例。它代表一个现实世界的实体，如人或编程实体，如变量和常量。例如，帐户和学生是现实世界实体的示例。但是计算机的硬件和软件组件是编程实体的示例。
对象具有以下三个主要特征 –
- 有状态。
- 拥有独一无二的身份。
- 可能会也可能不会显示该行为。
对象的状态可以描述为一组属性及其值。例如，银行帐户具有一组属性，例如帐号、名称、帐户类型、余额以及所有这些属性的值。对象的行为是指在一段时间内其属性发生的变化。
每个对象都有一个唯一标识，可用于将其与其他对象区分开来。两个对象可能表现出相同的行为，它们可能具有也可能不具有相同的状态，但它们永远不会具有相同的身份。两个人可能具有相同的姓名、年龄和性别，但他们并不完全相同。同样，对象的身份在其整个生命周期中永远不会改变。
对象可以通过发送消息来相互交互。对象包含数据和操作数据的代码。在类的帮助下，对象也可以用作用户定义的数据类型。对象也称为类型类的变量。定义一个类后，您可以创建属于该类的任意数量的对象。每个对象都与创建它的类型类的数据相关联。
创建对象
对象创建通常包括以下步骤 –
-
创建引用类的引用变量。其语法是 –
DATA: <object_name> TYPE REF TO <class_name>.
-
从引用变量创建对象。其语法是 –
CREATE Object: <object_name>.
例子
REPORT ZDEMO_OBJECT. CLASS Class1 Definition. Public Section. DATA: text1(45) VALUE 'ABAP Objects.'. METHODS: Display1. ENDCLASS. CLASS Class1 Implementation. METHOD Display1. Write:/ 'This is the Display method.'. ENDMETHOD. ENDCLASS. START-OF-SELECTION. DATA: Class1 TYPE REF TO Class1. CREATE Object: Class1. Write:/ Class1->text1. CALL METHOD: Class1->Display1.
上面的代码产生以下输出 –
ABAP Objects. This is the Display method.
SAP ABAP – 类
类用于指定对象的形式，它将数据表示和操作该数据的方法组合到一个整洁的包中。类中的数据和函数称为类的成员。
类定义和实现
当你定义一个类时，你定义了一个数据类型的蓝图。这实际上并没有定义任何数据，但它确实定义了类名的含义，类的对象将包含什么，以及可以对这样的对象执行哪些操作。也就是说，它定义了对象的抽象特征，例如属性、字段和属性。
以下语法显示了如何定义一个类 –
CLASS <class_name> DEFINITION. .......... .......... ENDCLASS.
类定义以关键字 CLASS 开头，后跟类名、DEFINITION 和类主体。类的定义可以包含类的各种组件，例如属性、方法和事件。当我们在类声明中声明方法时，方法实现必须包含在类实现中。以下语法显示了如何实现一个类 –
CLASS <class_name> IMPLEMENTATION. ........... .......... ENDCLASS.
注意– 类的实现包含其所有方法的实现。在 ABAP 对象中，类的结构包含诸如属性、方法、事件、类型和常量等组件。
属性
属性是类的数据字段，可以具有任何数据类型，例如 C、I、F 和 N。它们在类声明中声明。这些属性可以分为两类：实例属性和静态属性。一个实例属性定义对象的实例特定的状态。不同对象的状态不同。使用 DATA 语句声明实例属性。
静态属性定义类的所有实例共享的类的公共状态。也就是说，如果您更改类的一个对象中的静态属性，则该更改对类的所有其他对象也是可见的。静态属性是使用 CLASS-DATA 语句声明的。
方法
方法是表示类中对象行为的函数或过程。类的方法可以访问类的任何属性。方法的定义还可以包含参数，以便您可以在调用方法时为这些参数提供值。方法的定义在类声明中声明，并在类的实现部分实现。METHOD 和 ENDMETHOD 语句用于定义方法的实现部分。以下语法显示了如何实现一个方法 –
METHOD <m_name>. .......... .......... ENDMETHOD.
在此语法中，<m_name> 表示方法的名称。注意– 您可以使用 CALL METHOD 语句调用方法。
访问属性和方法
类组件可以在控制如何访问这些组件的公共、私有或受保护的可见性部分中定义。私有可见性部分用于拒绝从类外部访问组件。此类组件只能从类内部访问，例如方法。
可以从任何上下文访问公共可见性部分中定义的组件。默认情况下，一个类的所有成员都是私有的。实际上，我们在私有部分定义数据，在公共部分定义相关方法，以便可以从类外部调用它们，如下面的程序所示。
-
在一个类的 Public 部分中声明的属性和方法可以被该类和任何其他类、程序的子类访问。
-
当属性和方法在类的 Protected 部分中声明时，这些属性和方法只能由该类和子类（派生类）访问。
-
当属性和方法在类的 Private 部分声明时，这些属性和方法只能由该类访问，而不能由任何其他类访问。
例子
Report ZAccess1.
CLASS class1 Definition.
PUBLIC Section.
Data: text1 Type char25 Value 'Public Data'.
Methods meth1.
PROTECTED Section.
Data: text2 Type char25 Value 'Protected Data'.
PRIVATE Section.
Data: text3 Type char25 Value 'Private Data'.
ENDCLASS.
CLASS class1 Implementation.
Method meth1.
Write: / 'Public Method:',
/ text1,
/ text2,
/ text3.
Skip.
EndMethod.
ENDCLASS.
Start-Of-Selection.
Data: Objectx Type Ref To class1.
Create Object: Objectx.
CALL Method: Objectx→meth1.
Write: / Objectx→text1.
上面的代码产生以下输出 –
Public Method: Public Data Protected Data Private Data Public Data
静态属性
静态属性用语句 CLASS-DATA 声明。所有的对象或实例都可以使用类的静态属性。静态属性可以在类名的帮助下直接访问，如 class_name⇒name_1 = ‘Some Text’。
例子
以下是我们要打印行号为 4 到 8 次的文本的程序。我们定义了一个类 class1，并在公共部分声明了 CLASS-DATA（静态属性）和一个方法。实现类和方法后，我们直接访问Start-Of-Selection事件中的静态属性。然后我们只需创建类的实例并调用该方法。
Report ZStatic1.
CLASS class1 Definition.
PUBLIC Section.
CLASS-DATA: name1 Type char45,
data1 Type I.
Methods: meth1.
ENDCLASS.
CLASS class1 Implementation.
Method meth1.
Do 4 Times.
data1 = 1 + data1.
Write: / data1, name1.
EndDo.
Skip.
EndMethod.
ENDCLASS.
Start-Of-Selection.
class1⇒name1 = 'ABAP Object Oriented Programming'.
class1⇒data1 = 0.
Data: Object1 Type Ref To class1,
Object2 Type Ref To class1.
Create Object: Object1, Object2.
CALL Method: Object1→meth1,
Object2→meth1.
上面的代码产生以下输出 –
构造函数
构造函数是在创建对象或访问类的组件时自动调用的特殊方法。每当创建对象时都会触发构造函数，但是我们需要调用一个方法来触发通用方法。在下面的示例中，我们声明了两个公共方法 method1 和构造函数。这两种方法都有不同的操作。在创建类的对象时，构造函数方法会触发其操作。
例子
Report ZConstructor1.
CLASS class1 Definition.
PUBLIC Section.
Methods: method1, constructor.
ENDCLASS.
CLASS class1 Implementation.
Method method1.
Write: / 'This is Method1'.
EndMethod.
Method constructor.
Write: / 'Constructor Triggered'.
EndMethod.
ENDCLASS.
Start-Of-Selection.
Data Object1 Type Ref To class1.
Create Object Object1.
上面的代码产生以下输出 –
Constructor Triggered
方法中的 ME 运算符
当您在类的公共部分声明任何类型的变量时，您可以在任何其他实现中使用它。变量可以在公共部分用初始值声明。我们可以在具有不同值的方法中再次声明该变量。当我们在方法内部写入变量时，系统将打印更改后的值。为了反映变量的先前值，我们必须使用“ME”运算符。
在这个程序中，我们声明了一个公共变量 text1 并用一个值初始化。我们再次声明了相同的变量，但实例化了不同的值。在方法内部，我们使用“ME”运算符编写该变量以获取先前启动的值。我们通过直接声明来获取更改后的值。
例子
Report ZMEOperator1.
CLASS class1 Definition.
PUBLIC Section.
Data text1 Type char25 Value 'This is CLASS Attribute'.
Methods method1.
ENDCLASS.
CLASS class1 Implementation.
Method method1.
Data text1 Type char25 Value 'This is METHOD Attribute'.
Write: / ME→text1,
/ text1.
ENDMethod.
ENDCLASS.
Start-Of-Selection.
Data objectx Type Ref To class1.
Create Object objectx.
CALL Method objectx→method1.
上面的代码产生以下输出 –
This is CLASS Attribute This is METHOD Attribute
SAP ABAP – 继承
面向对象编程中最重要的概念之一是继承。继承允许我们根据另一个类来定义一个类，这使得创建和维护应用程序更容易。这也提供了重用代码功能和快速实现时间的机会。
创建类时，程序员可以指定新类应继承现有类的成员，而不是编写全新的数据成员和方法。这个现有的类称为基类或超类，新类称为派生类或子类。
-
一个类的对象可以获取另一个类的属性。
-
派生类继承超类的数据和方法。但是，它们可以覆盖方法并添加新方法。
-
继承的主要优点是可重用性。
继承关系是通过在类定义语句中添加“INHERITING FROM”来指定的。
以下是语法 –
CLASS <subclass> DEFINITION INHERITING FROM <superclass>.
例子
Report ZINHERITAN_1. CLASS Parent Definition. PUBLIC Section. Data: w_public(25) Value 'This is public data'. Methods: ParentM. ENDCLASS. CLASS Child Definition Inheriting From Parent. PUBLIC Section. Methods: ChildM. ENDCLASS. CLASS Parent Implementation. Method ParentM. Write /: w_public. EndMethod. ENDCLASS. CLASS Child Implementation. Method ChildM. Skip. Write /: 'Method in child class', w_public. EndMethod. ENDCLASS. Start-of-selection. Data: Parent Type Ref To Parent, Child Type Ref To Child. Create Object: Parent, Child. Call Method: Parent→ParentM, child→ChildM.
上面的代码产生以下输出 –
This is public data Method in child class This is public data
访问控制和继承
派生类可以访问其基类的所有非私有成员。因此，子类的成员函数不应访问的超类成员应在超类中声明为私有。我们可以根据谁可以通过以下方式访问它们来总结不同的访问类型 –
| Access | 民众 | 受保护 | 私人的 |
|---|---|---|---|
| Same calss | 是的 | 是的 | 是的 |
| Derived class | 是的 | 是的 | 不 |
| Outside class | 是的 | 不 | 不 |
当从超类派生类时，它可以通过公共、保护或私有继承来继承。继承的类型由上面解释的访问说明符指定。我们很少使用受保护或私有继承，但通常使用公共继承。在使用不同类型的继承时应用以下规则。
-
公共继承– 从公共超类派生类时，超类的公共成员成为子类的公共成员，超类的受保护成员成为子类的受保护成员。超类的私有成员永远不能直接从子类访问，但可以通过调用超类的公共成员和受保护成员来访问。
-
受保护的继承– 从受保护的超类派生时，超类的公共和受保护成员成为子类的受保护成员。
-
私有继承– 从私有超类派生时，超类的公共和受保护成员成为子类的私有成员。
重新定义子类中的方法
超类的方法可以在子类中重新实现。重新定义方法的一些规则 –
-
继承方法的重定义语句必须与原始方法的定义在同一节中。
-
如果你重新定义一个方法，在子类中不需要再次输入它的接口，只需要输入方法名即可。
-
在重新定义的方法中，您可以使用超级引用访问直接超类的组件。
-
伪引用 super 只能在重新定义的方法中使用。
例子
Report Zinheri_Redefine.
CLASS super_class Definition.
Public Section.
Methods: Addition1 importing g_a TYPE I
g_b TYPE I
exporting g_c TYPE I.
ENDCLASS.
CLASS super_class Implementation.
Method Addition1.
g_c = g_a + g_b.
EndMethod.
ENDCLASS.
CLASS sub_class Definition Inheriting From super_class.
Public Section.
METHODS: Addition1 Redefinition.
ENDCLASS.
CLASS sub_class Implementation.
Method Addition1.
g_c = g_a + g_b + 10.
EndMethod.
ENDCLASS.
Start-Of-Selection.
Parameters: P_a Type I, P_b TYPE I.
Data: H_Addition1 TYPE I.
Data: H_Sub TYPE I.
Data: Ref1 TYPE Ref TO sub_class.
Create Object Ref1.
Call Method Ref1→Addition1 exporting g_a = P_a
g_b = P_b
Importing g_c = H_Addition1.
Write:/ H_Addition1.
执行 F8 后，如果我们输入值 9 和 10，上面的代码会产生以下输出 –
Redefinition Demo 29
SAP ABAP – 多态性
术语多态性的字面意思是“多种形式”。从面向对象的角度来看，多态与继承一起工作，使得继承树中的各种类型可以互换使用。也就是说，当存在类的层次结构并且它们通过继承相关时，就会发生多态性。ABAP 多态性意味着对方法的调用将导致执行不同的方法，具体取决于调用该方法的对象的类型。
以下程序包含一个抽象类“class_prgm”、2 个子类（class_procedural 和 class_OO）和一个测试驱动程序类“class_type_approach”。在这个实现中，类方法“start”允许我们显示编程的类型及其方法。如果您仔细查看方法“start”的签名，您会发现它接收到一个 class_prgm 类型的导入参数。但是，在 Start-Of-Selection 事件中，此方法已在运行时使用 class_procedural 和 class_OO 类型的对象调用。
例子
Report ZPolymorphism1. CLASS class_prgm Definition Abstract. PUBLIC Section. Methods: prgm_type Abstract, approach1 Abstract. ENDCLASS. CLASS class_procedural Definition Inheriting From class_prgm. PUBLIC Section. Methods: prgm_type Redefinition, approach1 Redefinition. ENDCLASS. CLASS class_procedural Implementation. Method prgm_type. Write: 'Procedural programming'. EndMethod. Method approach1. Write: 'top-down approach'. EndMethod. ENDCLASS. CLASS class_OO Definition Inheriting From class_prgm. PUBLIC Section. Methods: prgm_type Redefinition, approach1 Redefinition. ENDCLASS. CLASS class_OO Implementation. Method prgm_type. Write: 'Object oriented programming'. EndMethod. Method approach1. Write: 'bottom-up approach'. EndMethod. ENDCLASS. CLASS class_type_approach Definition. PUBLIC Section. CLASS-METHODS: start Importing class1_prgm Type Ref To class_prgm. ENDCLASS. CLASS class_type_approach IMPLEMENTATION. Method start. CALL Method class1_prgm→prgm_type. Write: 'follows'. CALL Method class1_prgm→approach1. EndMethod. ENDCLASS. Start-Of-Selection. Data: class_1 Type Ref To class_procedural, class_2 Type Ref To class_OO. Create Object class_1. Create Object class_2. CALL Method class_type_approach⇒start Exporting class1_prgm = class_1. New-Line. CALL Method class_type_approach⇒start Exporting class1_prgm = class_2.
上面的代码产生以下输出 –
Procedural programming follows top-down approach Object oriented programming follows bottom-up approach
ABAP 运行时环境在分配导入参数 class1_prgm 期间执行隐式收缩转换。此功能有助于通用实现“开始”方法。与对象引用变量相关联的动态类型信息允许 ABAP 运行时环境将方法调用与对象引用变量指向的对象中定义的实现动态绑定。例如，“class_type_approach”类中方法“start”的导入参数“class1_prgm”指的是一个永远无法单独实例化的抽象类型。
每当使用具体的子类实现（例如 class_procedural 或 class_OO）调用该方法时，class1_prgm 引用参数的动态类型将绑定到这些具体类型之一。因此，对方法 ‘prgm_type’ 和 ‘approach1’ 的调用指的是 class_procedural 或 class_OO 子类中提供的实现，而不是类 ‘class_prgm’ 中提供的未定义抽象实现。
SAP ABAP – 封装
封装是一种面向对象编程 (OOP) 的概念，它将数据和操作数据的函数绑定在一起，并保护两者免受外部干扰和误用。数据封装导致了数据隐藏的重要 OOP 概念。封装是一种将数据和使用它们的函数捆绑在一起的机制，而数据抽象是一种只暴露接口并向用户隐藏实现细节的机制。
ABAP 通过创建称为类的用户定义类型来支持封装和数据隐藏的属性。如前所述，一个类可以包含私有成员、受保护成员和公共成员。默认情况下，类中定义的所有项目都是私有的。
按接口封装
封装实际上意味着可以在不同的类中修改一个属性和方法。因此数据和方法可以有不同的形式和逻辑，可以隐藏到单独的类中。
让我们考虑按接口封装。当我们需要在不同的类中创建具有不同功能的一种方法时使用接口。这里不需要更改方法的名称。必须在不同的类实现中实现相同的方法。
例子
以下程序包含接口 inter_1。我们已经声明了属性和方法 method1。我们还定义了两个类，如 Class1 和 Class2。所以我们必须在两个类实现中实现方法“method1”。我们在不同的类中以不同的方式实现了方法“method1”。在开始选择中，我们为两个类创建了两个对象 Object1 和 Object2。然后，我们通过不同的对象调用该方法以获取在单独的类中声明的函数。
Report ZEncap1.
Interface inter_1.
Data text1 Type char35.
Methods method1.
EndInterface.
CLASS Class1 Definition.
PUBLIC Section.
Interfaces inter_1.
ENDCLASS.
CLASS Class2 Definition.
PUBLIC Section.
Interfaces inter_1.
ENDCLASS.
CLASS Class1 Implementation.
Method inter_1~method1.
inter_1~text1 = 'Class 1 Interface method'.
Write / inter_1~text1.
EndMethod.
ENDCLASS.
CLASS Class2 Implementation.
Method inter_1~method1.
inter_1~text1 = 'Class 2 Interface method'.
Write / inter_1~text1.
EndMethod.
ENDCLASS.
Start-Of-Selection.
Data: Object1 Type Ref To Class1,
Object2 Type Ref To Class2.
Create Object: Object1, Object2.
CALL Method: Object1→inter_1~method1,
Object2→inter_1~method1.
上面的代码产生以下输出 –
Class 1 Interface method Class 2 Interface method
封装的类对外界没有太多的依赖。此外，它们与外部客户端的交互是通过稳定的公共接口进行控制的。也就是说，封装的类和它的客户是松散耦合的。大多数情况下，具有明确定义接口的类可以插入到另一个上下文中。如果设计正确，封装的类将成为可重用的软件资产。
设计策略
我们中的大多数人都通过惨痛的经验学会了默认情况下将类成员设为私有，除非我们真的需要公开它们。这只是很好的封装。这种智慧最常应用于数据成员，也同样适用于所有成员。
SAP ABAP – 接口
类似于 ABAP 中的类，接口充当对象的数据类型。接口的组件与类的组件相同。与类的声明不同，接口的声明不包括可见性部分。这是因为在接口声明中定义的组件总是集成在类的公共可见性部分中。
当两个相似的类具有相同名称的方法，但功能彼此不同时，将使用接口。接口可能看起来与类相似，但接口中定义的函数在类中实现以扩展该类的范围。接口和继承特性为多态性提供了基础。这是因为在接口中定义的方法在不同的类中的行为可能不同。
以下是创建界面的一般格式 –
INTERFACE <intf_name>. DATA..... CLASS-DATA..... METHODS..... CLASS-METHODS..... ENDINTERFACE.
在此语法中，<intf_name> 表示接口的名称。DATA 和 CLASSDATA 语句可分别用于定义接口的实例和静态属性。METHODS 和 CLASS-METHODS 语句可分别用于定义接口的实例方法和静态方法。由于接口的定义不包括实现类，因此无需在接口声明中添加 DEFINITION 子句。
注意– 接口的所有方法都是抽象的。它们是完整声明的，包括它们的参数接口，但未在接口中实现。所有要使用接口的类都必须实现该接口的所有方法。否则，该类将成为抽象类。
我们在类的实现部分使用以下语法 –
INTERFACE <intf_name>.
在此语法中，<intf_name> 表示接口的名称。请注意，必须在类的公共部分中使用此语法。
以下语法用于在类的实现中实现接口的方法 –
METHOD <intf_name~method_m>. <statements>. ENDMETHOD.
在此语法中，<intf_name~method_m> 表示 <intf_name> 接口的方法的完整声明名称。
例子
Report ZINTERFACE1. INTERFACE my_interface1. Methods msg. ENDINTERFACE. CLASS num_counter Definition. PUBLIC Section. INTERFACES my_interface1. Methods add_number. PRIVATE Section. Data num Type I. ENDCLASS. CLASS num_counter Implementation. Method my_interface1~msg. Write: / 'The number is', num. EndMethod. Method add_number. ADD 7 TO num. EndMethod. ENDCLASS. CLASS drive1 Definition. PUBLIC Section. INTERFACES my_interface1. Methods speed1. PRIVATE Section. Data wheel1 Type I. ENDCLASS. CLASS drive1 Implementation. Method my_interface1~msg. Write: / 'Total number of wheels is', wheel1. EndMethod. Method speed1. Add 4 To wheel1. EndMethod. ENDCLASS. Start-Of-Selection. Data object1 Type Ref To num_counter. Create Object object1. CALL Method object1→add_number. CALL Method object1→my_interface1~msg. Data object2 Type Ref To drive1. Create Object object2. CALL Method object2→speed1. CALL Method object2→my_interface1~msg.
上面的代码产生以下输出 –
The number is 7 Total number of wheels is 4
在上面的示例中，my_interface1 是包含 ‘msg’ 方法的接口的名称。接下来，定义并实现两个类，num_counter 和 drive1。这两个类都实现了 ‘msg’ 方法以及定义其各自实例行为的特定方法，例如 add_number 和 speed1 方法。
注意– add_number 和 speed1 方法特定于相应的类。
SAP ABAP – 对象事件
一个事件是一组在一个类被定义为触发其他类的事件处理结果。当一个事件被触发时，我们可以调用任意数量的事件处理程序方法。触发器与其处理程序方法之间的链接实际上是在运行时动态决定的。
在正常的方法调用中，调用程序确定需要调用对象或类的哪个方法。由于不是为每个事件都注册固定的处理程序方法，在事件处理的情况下，处理程序方法确定需要触发的事件。
一个类的事件可以通过使用 RAISE EVENT 语句触发同一个类的事件处理程序方法。对于事件，可以使用 FOR EVENT 子句在相同或不同的类中定义事件处理程序方法，如以下语法所示 –
FOR EVENT <event_name> OF <class_name>.
与类的方法类似，事件可以有参数接口，但只有输出参数。输出参数由接收它们作为输入参数的 RAISE EVENT 语句传递给事件处理程序方法。事件通过使用 SET HANDLER 语句在程序中动态链接到其处理程序方法。
当事件被触发时，应该在所有处理类中执行适当的事件处理程序方法。
例子
REPORT ZEVENT1. CLASS CL_main DEFINITION. PUBLIC SECTION. DATA: num1 TYPE I. METHODS: PRO IMPORTING num2 TYPE I. EVENTS: CUTOFF. ENDCLASS. CLASS CL_eventhandler DEFINITION. PUBLIC SECTION. METHODS: handling_CUTOFF FOR EVENT CUTOFF OF CL_main. ENDCLASS. START-OF-SELECTION. DATA: main1 TYPE REF TO CL_main. DATA: eventhandler1 TYPE REF TO CL_eventhandler. CREATE OBJECT main1. CREATE OBJECT eventhandler1. SET HANDLER eventhandler1→handling_CUTOFF FOR main1. main1→PRO( 4 ). CLASS CL_main IMPLEMENTATION. METHOD PRO. num1 = num2. IF num2 ≥ 2. RAISE EVENT CUTOFF. ENDIF. ENDMETHOD. ENDCLASS. CLASS CL_eventhandler IMPLEMENTATION. METHOD handling_CUTOFF. WRITE: 'Handling the CutOff'. WRITE: / 'Event has been processed'. ENDMETHOD. ENDCLASS.
上面的代码产生以下输出 –
Handling the CutOff Event has been processed
SAP ABAP – 报表编程
一个报告是数据的有组织结构的介绍。许多数据库管理系统包括一个报告编写器，使您能够设计和生成报告。SAP 应用程序支持报告创建。
经典报告是通过在循环内使用 WRITE 语句中的输出数据创建的。它们不包含任何子报告。SAP 还提供了一些标准报告，例如用于跨客户端复制表的 RSCLTCOP 和用于显示实例参数的 RSPARAM。
这些报告仅包含一个屏幕作为输出。我们可以使用INITIALIZATON & TOP-OF-PAGE等各种事件来创建经典报告，每个事件在经典报告的创建过程中都有自己的重要性。这些事件中的每一个都与特定的用户操作相关联，并且仅在用户执行该操作时触发。
以下是描述事件和描述的表格 –
| S.No. | 事件和描述 |
|---|---|
| 1 |
INITIALIZATON 在显示选择屏幕之前触发。 |
| 2 |
AT SELECTION-SCREEN 在处理选择屏幕上的用户输入后触发。此事件在执行程序之前验证用户输入。在处理用户输入之后，选择屏幕保持在活动模式。 |
| 3 |
START-OF-SELECTION 选择画面处理结束后才触发；也就是说，当用户单击选择屏幕上的执行图标时。 |
| 4 |
END-OF-SELECTION 在 START-OF-SELECTON 事件中的最后一条语句执行后触发。 |
| 5 |
TOP-OF-PAGE 由第一个 WRITE 语句触发以在新页面上显示数据。 |
| 6 |
END-OF-PAGE 触发以在报表中的页面末尾显示文本。请注意，此事件是创建报告时的最后一个事件，应与 REPORT 语句的 LINE-COUNT 子句结合使用。 |
例子
让我们创建一个经典报告。我们将在 ABAP 编辑器中使用一系列语句来显示存储在标准数据库 MARA（包含一般材料数据）中的信息。
REPORT ZREPORT2
LINE-SIZE 75
LINE-COUNT 30(3)
NO STANDARD PAGE HEADING.
Tables: MARA.
TYPES: Begin of itab,
MATNR TYPE MARA-MATNR,
MBRSH TYPE MARA-MBRSH,
MEINS TYPE MARA-MEINS,
MTART TYPE MARA-MTART,
End of itab.
DATA: wa_ma TYPE itab,
it_ma TYPE STANDARD TABLE OF itab.
SELECT-OPTIONS: MATS FOR MARA-MATNR OBLIGATORY.
INITIALIZATION.
MATS-LOW = '1'.
MATS-HIGH = '500'.
APPEND MATS.
AT SELECTION-SCREEN. .
IF MATS-LOW = ' '.
MESSAGE I000(ZKMESSAGE).
ELSEIF MATS-HIGH = ' '.
MESSAGE I001(ZKMESSAGE).
ENDIF.
TOP-OF-PAGE.
WRITE:/ 'CLASSICAL REPORT CONTAINING GENERAL MATERIAL DATA
FROM THE TABLE MARA' COLOR 7.
ULINE.
WRITE:/ 'MATERIAL' COLOR 1,
24 'INDUSTRY' COLOR 2,
38 'UNITS' COLOR 3,
53 'MATERIAL TYPE' COLOR 4.
ULINE.
END-OF-PAGE.
START-OF-SELECTION.
SELECT MATNR MBRSH MEINS MTART FROM MARA
INTO TABLE it_ma WHERE MATNR IN MATS.
LOOP AT it_ma into wa_ma.
WRITE:/ wa_ma-MATNR,
25 wa_ma-MBRSH,
40 wa_ma-MEINS,
55 wa_ma-MTART.
ENDLOOP.
END-OF-SELECTION.
ULINE.
WRITE:/ 'CLASSICAL REPORT HAS BEEN CREATED' COLOR 7.
ULINE.
SKIP.
上面的代码产生以下输出，其中包含来自标准表 MARA 的一般材料数据 –
SAP ABAP – 对话编程
对话编程处理多个对象的开发。所有这些对象都分层链接到主程序，并按顺序执行。对话程序开发利用了 ABAP 工作台中的工具。这些工具与标准 SAP 应用程序开发中使用的工具相同。
以下是对话程序的主要组成部分 –
- 屏幕
- 模块池
- 子程序
- 菜单
- 交易
工具集
对话程序应该由对象浏览器（事务：SE80）开发，以便所有对象都链接到主程序，而不必明确指向每个对象。先进的导航技术增强了从一个物体移动到另一个物体的过程。
屏幕由屏幕属性、屏幕布局、字段和流逻辑组成。模块池由放置在对话程序的包含程序中的模块化语法组成。这些模块可以由流逻辑调用，由对话处理器处理。
创建一个新的对话程序
步骤 1 – 在事务 SE80 中，从下拉列表中选择“程序”并为您的自定义 SAP 程序输入一个 Z 名称作为“ZSCREENEX”。
步骤 2 – 按 Enter，选择“With TOP INCL”并单击“Yes”按钮。
第 3 步– 输入顶部的名称，包括“ZSCRTOP”，然后单击绿色勾号。
步骤 4 – 在属性屏幕中，只需输入标题并单击保存按钮。
向对话程序添加屏幕
步骤 1 – 要向程序添加屏幕，请右键单击程序名称并选择选项创建 → 屏幕。
步骤 2 – 输入屏幕编号“0211”，然后单击绿色勾号。
步骤 3 – 在下一个屏幕中，输入一个简短的标题，设置为普通屏幕类型，然后单击顶部应用程序工具栏上的保存按钮。
屏幕布局和添加“Hello World”文本
步骤 1 – 单击应用程序工具栏中的布局按钮，将出现 Screen Painter 窗口。
第 2 步– 添加文本字段并输入一些文本，例如“Hello World”。
步骤 3 – 保存并激活屏幕。
创建交易
步骤 1 – 要为您的程序创建事务代码，只需右键单击程序名称并选择选项创建 → 事务并输入事务代码作为“ZTRANEX”。
第 2 步– 输入您刚刚创建的交易文本、程序和屏幕（ZSCREENEX 和 0211），然后勾选“GUI 支持”部分中的“SAPGUI for Windows”复选框。
执行程序
保存并激活所有内容。您可以执行该程序。当程序执行时，您输入的文本将显示在屏幕上，如下面的屏幕截图所示。
SAP ABAP – 智能表单
SAP Smart Forms 工具可用于打印和发送文档。该工具可用于为 Internet 开发表单、PDF 文件、电子邮件和文档。该工具提供了一个界面来构建和维护表单的布局和逻辑。SAP 还提供一系列用于业务流程的表格，例如客户关系管理 (CRM)、销售和分销 (SD)、财务会计 (FI) 和人力资源 (HR) 中使用的表格。
该工具允许您使用简单的图形工具而不是使用任何编程工具来修改表单。这意味着没有编程知识的用户可以毫不费力地使用业务流程的数据配置这些表单。
在 Smart Form 中，数据是从静态和动态表中检索的。表格标题和小计由触发事件指定，然后在最终输出之前对数据进行排序。智能表单允许您合并可以作为表单的一部分或作为背景显示的图形。如果需要，您还可以在打印表单时隐藏背景图形。
SAP系统中可用的标准智能表单的一些示例如下 –
-
SF_EXAMPLE_01 代表一张发票，其中包含一个客户航班预订的表格输出。
-
SF_EXAMPLE_02 表示类似于 SF_EXAMPLE_01 的发票，但带有小计。
-
SF_EXAMPLE_03 指定类似于 SF_EXAMPLE_02 的发票，但可以在应用程序中选择多个客户。
创建表单
让我们使用 SAP Smart Forms 工具创建一个表单。您还将学习如何在智能表单中添加节点并在本教程中测试表单。在这里，我们从创建 SF_EXAMPLE_01 表单的副本开始。SF_EXAMPLE_01 表单是 SAP 系统中可用的标准智能表单。
步骤 1 – 智能表单生成器是用于构建智能表单的主界面。它在 SAP Smart Forms 的初始屏幕上可用。我们需要在命令字段中键入“SMARTFORMS”事务代码以打开 SAP Smart Forms 的初始屏幕。在此屏幕中，在表单字段中输入表单名称 SF_EXAMPLE_01。
步骤 2 – 选择智能表单 → 复制或单击复制图标以打开复制表单或文本对话框。
步骤 3 – 在目标对象字段中，输入新表单的名称。名称必须以 Y 或 Z 字母开头。在这种情况下，表单的名称是“ZSMM1”。
步骤 4 – 单击“继续”图标或在“复制表单”或“文本”对话框中按 Enter 键，以便将 ZSMM1 表单创建为预定义表单 SF_EXAMPLE_01 的副本。
步骤 5 – 单击保存图标。表单名称显示在 SAP Smart Forms 初始屏幕上的表单字段中。
步骤 6 – 单击 SAP Smart Forms 初始屏幕上的创建按钮。ZSMM1 表单出现在表单生成器中。
步骤 7 – 使用主窗口创建第一个草稿页面。新表单的所有组件都基于 SF_EXAMPLE_01 预定义表单。您只需单击导航菜单中的节点即可查看其内容。
在表单中创建文本节点
步骤 1 – 在 SAP Form Builder 屏幕的更改模式下打开一个表单，然后右键单击 First Page 节点中的 Main Window 选项，然后从上下文菜单中选择 Create → Text。
步骤 2 – 将文本字段中的文本修改为“My_Text”，将含义字段中的文本修改为“Text_Demo”。在 Form Builder 中心框架的文本编辑框中输入文本“Hello TutorialsPoint…..”，如下面的快照所示 –
步骤 3 – 单击“保存”按钮以保存节点。
步骤 4 – 通过分别单击“激活”和“测试”图标来激活和测试节点。出现函数生成器的初始屏幕。
步骤 5 – 通过单击激活和执行图标激活和测试功能模块。功能模块的参数显示在Function Builder 的初始画面中。
步骤 6 – 通过单击“执行”图标执行功能模块。出现打印对话框。
步骤 7 – 将输出设备指定为“LP01”，然后单击“打印预览”按钮。
上述步骤将产生以下输出 –
SAP ABAP – SAPscripts
SAP 系统的 SAPscript 工具可用于构建和管理发票和采购订单等业务表单。SAPscript 工具提供了大量模板，可以在很大程度上简化业务表单的设计。
SAP 系统随附随 SAP 标准客户端（通常为客户端 000）提供的标准 SAPscript 表单。以下是客户端 000 提供的标准 SAPscript 表单的一些示例 –
| S.No. | 表单名称和描述 |
|---|---|
| 1 |
RVORDER01 销售订单确认表 |
| 2 |
RVDELNOTE 包装清单 |
| 3 |
RVINVOICE01 发票 |
| 4 |
MEDRUCK 采购订单 |
| 5 |
F110_PRENUM_CHCK 预编号支票 |
SAPscript 表单的结构由 2 个主要组件组成 –
内容– 这可以是文本（业务数据）或图形（公司徽标）。
布局– 这是由一组显示表单内容的窗口定义的。
SAPscript – 表单绘制工具
Form Painter 工具提供 SAPscript 表单的图形布局和各种操作表单的功能。在以下示例中，我们将在从标准 SAPscript 表单 RVINVOICE01 复制其布局结构后创建一个发票表单，并通过访问 Form Painter 工具显示其布局。
步骤 1 – 打开表单刷。您可以通过导航 SAP 菜单或使用 SE71 事务代码来请求屏幕。
步骤 2 – 在 Form Painter 的请求屏幕中，分别在 Form 和 Language 字段中输入 SAPscript 表单的名称和语言。让我们在这些字段中分别输入“RVINVOICE01”和“EN”。
步骤 3 – 在子对象组框中选择页面布局单选按钮。
步骤 4 – 选择实用程序 → 从客户端复制以创建 RVINVOICE01 表单的副本。出现“在客户端之间复制表单”屏幕。
第 5 步– 在“在客户端之间复制表单”屏幕中，在“表单名称”字段中输入表单的原始名称“RVINVOICE01”，在“源客户端”字段中输入源客户端“000”的编号，以及在目标表单字段中将目标表单设为“ZINV_01”。确保其他设置保持不变。
步骤 6 – 接下来，单击“在客户端之间复制表单”屏幕中的执行图标。出现“创建对象目录条目”对话框。单击保存图标。
ZINV_01 表单是从 RVINVOICE01 表单复制的，并显示在“在客户端之间复制表单”屏幕中，如下面的快照所示 –
步骤 7 – 单击后退图标两次并导航回 Form Painter: Request 屏幕，其中包含复制的表单 ZINV_01 的名称。
步骤 8 – 单击“显示”按钮后，将出现“表单 ZINV_01：页面优先布局”窗口和“表单：更改页面布局：ZINV_01”屏幕，如下面的屏幕截图所示。
步骤 9 – ‘Form ZINV_01: Layout of Page FIRST’ 窗口显示了表单的初始布局。表单的布局包含五个窗口：HEADER、ADDRESS、INFO、INFO1 和 MAIN。这些窗口的描述可以在 PC 编辑器中访问。
例如，只需选择主窗口并单击“表单：更改页面布局：ZINV_01”屏幕中的文本图标，您就可以查看所有边距值，如下面的屏幕截图所示 –
SAP ABAP – 客户退出
客户出口可被视为 SAP 标准程序的挂钩。我们不需要访问密钥来编写代码，也不需要修改 SAP 标准程序。这些出口没有任何功能，它们是空的。可以添加业务逻辑以满足各种客户需求。但是，并非所有程序都可以使用客户退出。
标准交易的客户退出
就标准交易而言，以下是查找客户出口的步骤。让我们确定 MM01（Material Master Creation）中可用的客户出口。
步骤 1 – 转到事务 MM01 并通过转到菜单栏 → 系统 → 状态来识别 MM01 的程序名称，如上图所示。
步骤 2 – 从弹出屏幕中获取程序名称。程序名称是“SAPLMGMM”。
步骤 3 – 转到事务 SE38，输入程序名称并单击显示。
步骤 4 – 导航至 → 属性并找出此程序名称的包。
包名是“MGA”。
步骤 5 – 转到通常用于识别客户退出的事务代码 SMOD。导航到实用程序→查找（或）您可以直接在事务代码 SMOD 上按 Ctrl 加 F。
步骤 6 – 转到“查找出口”屏幕后，输入我们之前获得的包名称，然后按 F8（执行）按钮。
上述步骤生成以下输出，其中包含 Material Master Creation 中可用的退出列表。
SAP ABAP – 用户退出
如果标准 SAP 提取器不提供预期数据或所需功能（例如在授权或时间检查中），则在提取中使用用户出口。用户出口通常用于销售和分销 (SD) 模块。SAP 在销售、运输、运输和计费领域提供了许多出口。用户出口旨在在标准 SAP 无法满足所有需求时进行一些更改。
为了能够访问每个销售领域的可用退出，请使用以下路径转到 IMG：IMG → 销售和分销 → 系统修改 → 用户退出。SD 领域中每个出口的文档都得到了详尽的解释。
例如，如果您想在销售单据处理（合同、报价单或销售订单）中查找用户退出，请按照上述路径继续展开销售中的用户退出→用户退出节点。单击图标文档以查看销售文档处理中可用的所有用户退出。
| S.No. | 用户退出和描述 |
|---|---|
| 1 |
USEREXIT_FIELD_MODIFICATION 用于修改屏幕属性。 |
| 2 |
USEREXIT_SAVE_DOCUMENT 当用户点击保存时帮助执行操作。 |
| 3 |
USEREXIT_SAVE_DOCUMENT_PREPARE 检查输入字段、在字段中放置任何值或向用户显示弹出窗口和确认文档非常有用。 |
| 4 |
USEREXIT_MOVE_FIELD_TO_VBAK 当用户标题更改移动到标题工作区时使用。 |
| 5 |
USEREXIT_MOVE_FIELD_TO_VBAP 当用户项目更改移动到 SAP 项目工作区时使用。 |
用户出口与客户出口的用途相同，但它们仅可用于 SD 模块。出口实现为对功能模块的调用。用户出口是对 SAP 标准程序的修改。
例子
REPORT ZUSEREXIT1.
TABLES:
TSTC, TSTCT,
TADIR, TRDIR, TFDIR, ENLFDIR,
MODSAPT, MODACT.
DATA:
JTAB LIKE TADIR OCCURS 0 WITH HEADER LINE,
field1(30),
v_devclass LIKE TADIR-devclass.
PARAMETERS:
P_TCODE LIKE TSTC-tcode OBLIGATORY.
SELECT SINGLE *
FROM TSTC
WHERE tcode EQ P_TCODE.
IF SY-SUBRC EQ 0.
SELECT SINGLE *
FROM TADIR
WHERE pgmid = 'R3TR' AND
object = 'PROG' AND
obj_name = TSTC-pgmna.
MOVE TADIR-devclass TO v_devclass.
IF SY-SUBRC NE 0.
SELECT SINGLE *
FROM TRDIR
WHERE name = TSTC-pgmna.
IF TRDIR-subc EQ 'F'.
SELECT SINGLE *
FROM TFDIR
WHERE pname = TSTC-pgmna.
SELECT SINGLE *
FROM ENLFDIR
WHERE funcname = TFDIR-funcname.
SELECT SINGLE *
FROM TADIR
WHERE pgmid = 'R3TR' AND
object = 'FUGR' AND
obj_name EQ ENLFDIR-area.
MOVE TADIR-devclass TO v_devclass.
ENDIF.
ENDIF.
SELECT *
FROM TADIR
INTO TABLE JTAB
WHERE pgmid = 'R3TR' AND
object = 'SMOD' AND
devclass = v_devclass.
SELECT SINGLE *
FROM TSTCT
WHERE sprsl EQ SY-LANGU AND
tcode EQ P_TCODE.
FORMAT COLOR COL_POSITIVE INTENSIFIED OFF.
WRITE:/(19) 'Transaction Code - ',
20(20) P_TCODE,
45(50) TSTCT-ttext.
SKIP.
IF NOT JTAB[] IS INITIAL.
WRITE:/(95) SY-ULINE.
FORMAT COLOR COL_HEADING INTENSIFIED ON.
WRITE:/1 SY-VLINE,
2 'Exit Name',
21 SY-VLINE ,
22 'Description',
95 SY-VLINE.
WRITE:/(95) SY-ULINE.
LOOP AT JTAB.
SELECT SINGLE * FROM MODSAPT
WHERE sprsl = SY-LANGU AND
name = JTAB-obj_name.
FORMAT COLOR COL_NORMAL INTENSIFIED OFF.
WRITE:/1 SY-VLINE,
2 JTAB-obj_name HOTSPOT ON,
21 SY-VLINE ,
22 MODSAPT-modtext,
95 SY-VLINE.
ENDLOOP.
WRITE:/(95) SY-ULINE.
DESCRIBE TABLE JTAB.
SKIP.
FORMAT COLOR COL_TOTAL INTENSIFIED ON.
WRITE:/ 'No of Exits:' , SY-TFILL.
ELSE.
FORMAT COLOR COL_NEGATIVE INTENSIFIED ON.
WRITE:/(95) 'User Exit doesn’t exist'.
ENDIF.
ELSE.
FORMAT COLOR COL_NEGATIVE INTENSIFIED ON.
WRITE:/(95) 'Transaction Code Does Not Exist'.
ENDIF.
AT LINE-SELECTION.
GET CURSOR FIELD field1.
CHECK field1(4) EQ 'JTAB'.
SET PARAMETER ID 'MON' FIELD sy-lisel+1(10).
CALL TRANSACTION 'SMOD' AND SKIP FIRST SCREEN.
在处理时，输入事务代码“ME01”并按 F8（执行）按钮。上面的代码产生以下输出 –
SAP ABAP – 业务插件
在某些情况下，需要在软件应用程序中预定义特殊功能以增强各种应用程序的功能。有许多 Microsoft Excel 插件可以改进 MS Excel 的功能。同样，SAP 通过提供称为 BADI 的业务插件来促进一些预定义的功能。
BADI 是一种增强技术，可帮助 SAP 程序员、用户或特定行业向 SAP 系统中的现有程序添加一些附加代码。我们可以使用标准或定制的逻辑来改进 SAP 系统。必须首先定义 BADI，然后实施以增强 SAP 应用程序。在定义 BADI 时，会创建一个接口。BADI 由该接口实现，而接口又由一个或多个适配器类实现。
BADI 技术在两个方面不同于其他增强技术 –
- 增强技术只能实施一次。
- 许多客户可以同时使用这种增强技术。
您还可以创建过滤器 BADI，这意味着 BADI 是基于过滤数据定义的，这是增强技术无法实现的。SAP 7.0 版重新定义了 BADI 的概念，目标如下 –
-
通过在 ABAP 语言中添加两个新元素，即“GET BADI”和“CALL BADI”，增强 SAP 系统中的标准应用程序。
-
提供更灵活的功能，例如上下文和过滤器，以增强 SAP 系统中的标准应用程序。
创建 BADI 时，它包含一个界面和其他附加组件，例如用于菜单增强和屏幕增强的功能代码。BADI 创建允许客户在标准 SAP 应用程序中包含他们自己的增强功能。增强、接口和生成的类位于适当的应用程序开发命名空间中。
因此，可以将 BADI 视为使用 ABAP 对象在 SAP 组件中创建“预定义点”的增强技术。这些预定义点随后由各个行业解决方案、国家变体、合作伙伴和客户实施，以满足他们的特定要求。SAP 实际上在 4.6A 版中引入了 BADI 增强技术，并且在 7.0 版中再次重新实现了该技术。
SAP ABAP – Web Dynpro
Web Dynpro (WD) for ABAP 是 SAP AG 开发的 SAP 标准用户界面技术。它可用于在利用 SAP 开发工具和概念的 SAP ABAP 环境中开发基于 Web 的应用程序。它提供了一个前端 Web 用户界面，可直接连接到后端 SAP R/3 系统以访问数据和报告功能。
用于 ABAP 的 Web Dynpro 由一个运行时环境和一个图形开发环境组成，其中包含集成在 ABAP 工作台中的特定开发工具（交易：SE80）。
Web Dynpro 的架构
下图显示了 Web Dynpro 的整体架构 –
以下是关于 Web Dynpro 需要记住的几点 –
-
Web Dynpro 是用于用户界面的 SAP NetWeaver 编程模型。
-
所有 Web Dynpro 应用程序都是按照模型视图控制器 (MVC) 编程模型构建的。
-
该模型定义了主系统的接口，Web Dynpro 应用程序可以访问系统数据。
-
视图负责在 Web 浏览器中显示数据。
-
控制器位于视图和模型之间。控制器格式化要在视图中显示的模型数据。它处理用户输入的用户条目并将它们返回给模型。
优点
Web Dynpro 为应用程序开发人员提供以下优势 –
-
图形工具的使用大大减少了实施工作。
-
通过使用组件重用和更好的可维护性。
-
使用 Web Dynpro 工具可以轻松更改布局和导航。
-
支持用户界面可访问性。
-
完全集成在 ABAP 开发环境中。
Web Dynpro 组件和窗口
该组件是 Web Dynpro 应用程序项目的全局单元。创建 Web Dynpro 组件是开发新 Web Dynpro 应用程序的第一步。创建组件后，它充当 Web Dynpro 对象列表中的一个节点。您可以在一个组件中创建任意数量的组件视图，并将它们组合到任意数量的相应 Web Dynpro 窗口中。
每个 Web Dynpro 组件中至少包含一个 Web Dynpro 窗口。Web Dynpro 窗口嵌入了在前端 Web 应用程序中显示的所有视图。该窗口在 ABAP 工作台的窗口编辑器中进行处理。
笔记
-
组件视图显示应用程序的所有管理详细信息，包括描述、创建者的姓名、创建日期和分配的开发包。
-
Web Dynpro 应用程序是 ABAP Workbench 对象列表中的独立对象。窗口和应用程序之间的交互是由给定窗口的界面视图创建的。
