SAP ABAP 面向对象

原创已于 2023-03-29 16:39:40 修改 · 935 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#数据库

于 2023-02-21 11:55:58 首次发布

abap 专栏收录该内容

98 篇文章

订阅专栏

文章详细介绍了SAPABAP编程中的CHECK语句用法，以及面向对象编程的关键概念，包括类的定义与实现、继承、多态、接口、异常处理、模块化和事件处理。此外，还讨论了构造器、方法重写和变量作用域等重要概念。

CHECK语句

CHECK语句基于条件终止循环传递。如果CHECK语句中的条件被计算为false，则忽略CHECK语句之后的语句块中的所有剩余语句，并且下一个循环开始。 CHECK语句中的条件可以是任何逻辑表达式。
检查语句的语法是:

CHECK.

实例

Report YH_SEP_15.  
DO 5 TIMES.  
CHECK SY-INDEX BETWEEN 3 AND 4.  
Write / SY-INDEX.  
ENDDO.
上面的代码产生以下输出

3
4

一、面向对象

* 1.声明

* CLASS DEFINITION | IMPLEMENTATION | DEFERRED

* PUBLIC SECTION | PROTECTED | PRIVATE

* DATA | CLASS-DATA | METHODS | CLASS-METHODS

* TYPE REF TO | CREATE OBJECT

* 构造器：constructor | class_constructor

* 2.继承

* INHERITING FROM | REDEFINITION

* FRIENDS | ABSTRACT | FINAL

* me | super

* 3.多态

* = | ?=

* 4.接口

* INTERFACE | ALIAS

* 5.事件

* EVENTS XXX EXPORTING XXX | CLASS-EVENTS

* RAISE EVENTS XXX

* METHOD XXX FOR EVENT XXX OF XXX IMPORTING XXX

* SET HANDLER XXX FOR XXX | ALL INSTANCE

二、异常类

Exceptions

Class-Based

CX_STATIC_CHECK

CX_DYNAMIC_CHECK

CX_NO_CHECK

异常消息类

IF_T100_DYN_MSG

三、模块化

SE38、SE37、SE24

INCLUDE | MACRO

事件

LOAD-OF-PROGRAM | START-OF-SELECTION

FORM | FUNCTION MODULE | METHOD

四、新语法

* NEW | CAST | REF

* VALUE | CONV | EXACT

* CORRESPONDING | FILTER

* REDUCE

* COND | SWITCH

面向对象

class cl_demo definition."类的定义
public section.
data v1 type c.
methods m1.
class-data c1 type c."静态变量
class-methods cm1."静态方法

protected section.
data v2 type c.
methods m2.

private section.
data v3 type char25 Value 'Private Data'..
methods m3.
endclass.

class cl_demo implementation."类的实施
method m1."这里就不用methods而是method
v2 ='B'.
write v2.
endmethod.

method m2.
endmethod.

method m3.
endmethod.

method cm1.
write 'class-methods'.
endmethod.
endclass.

start-of-selection.
data cl_instance type ref to cl_demo."引用类型对象就是引用类型
create object cl_instance.
cl_instance->v1='a'."成员变量
cl_instance=>c1='B'."静态成员变量
cl_instance->m1( )."括号中有空格 方法 对象名->方法名( )
cl_demo=>cm1( )."静态方法 类名=>方法名( )

data:i1 type c,
e1 type c.
class cl_demo definition."类的定义
public section.
data v1 type c.
methods m1.
class-data c1 type c."静态变量
class-methods: cm1 importing i1 type c exporting e1 type c."静态方法 冒号可加可不加
*import输入即给函数的参数 exporting输出方法的返回值
protected section.
data v2 type c.
methods m2.

private section.
data v3 type char25 Value 'Private Data'..
methods m3.
endclass.

class cl_demo definition."类的定义
public section.
data v1 type c.
methods m1.
class-data c1 type c."静态变量
class-methods: cm1 value(i1) type c exporting value(e1) type c."静态方法 冒号可加可不加
*import输入即给函数的参数 exporting输出方法的返回值
*引用时不用创建变量直接传值就行了
protected section.
data v2 type c.
methods m2.

private section.
data v3 type char25 Value 'Private Data'..
methods m3.
endclass.

class cl_demo definition."类的定义
public section.
data v1 type c.
methods m1.
class-data c1 type c."静态变量
class-methods: cm1 importing i1 type c exporting e1 type c changing c1 type c returning value (r1) type c.
"静态方法 冒号可加可不加
*import输入即给函数的参数 exporting输出方法的返回值 changing 输入参数返回同一个参数
*changing c1 type c default 'A'给个默认值 optional不给c1任何值
*return 返回
protected section.
data v2 type c.
methods m2.

private section.
data v3 type char25 Value 'Private Data'..
methods m3.
endclass.
class cl_demo implementation."类的实施
method m1."这里就不用methods而是method
v2 ='B'.
write v2.
endmethod.

method m2.
endmethod.

method m3.
endmethod.

method cm1.
e1 =i1.
c1= i1.
r1= i1.
write 'class-methods'.
endmethod.
endclass.
start-of-selection.
data: e1 type c,
      c1 type c,
      r1 type c.
r1 =cl_demo=>cm1(exporting i1='A' importing e1 =e1 changing c1=c1).
write r1."结果为A
write cl_demo=>cm1(exporting i1='A' importing e1 =e1 changing c1=c1)."结果为A

构造器

class cl_demo definition."类的定义
public section.
methods constructor."构造器
endclass.
class cl_demo implementation."类的实施
method constructor.
message 'instance is create'type 's'.
endmethod.
endclass.
start-of-selection.
data cl_instance type ref to cl_demo.
create object cl_linstance."结果出现提示消息
*对象一旦被创建就会默认调用构造器

静态构造器

class cl_demo definition."类的定义
public section.
class-data c1 type c."静态变量
class-methods constructor.
endclass.
class cl_demo implementation."类的实施
class-method constructor.
message 'class is accessed' type 's'.
endmethod.
start-of-selection.
cl_demo=>c1='A'."结果提示上述消息
"静态构造器在类的成员就自动调用了

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.

ME操作员

当你在类的public节中声明任何类型的变量时，你可以在任何其他实现中使用它。变量可以在public section中用初始值声明。我们可以在一个具有不同值的方法中再次声明该变量。当我们在方法中写入变量时，系统将打印更改的值。要反映变量的先前值，我们必须使用“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

继承

访问	公开	保护	私密
同类	Yes	Yes	Yes
派生类	Yes	Yes	No
外面	Yes	No	No

Report ZINHERITAN_1. 
CLASS Parent Definition. 
PUBLIC Section. 
Data: w_public(25) Value 'This is public data'. 
Methods: ParentM. 
protected section."这个在继承类中也要保持范围约束
data v1 type c value 'A'.
ENDCLASS. 

CLASS Child Definition Inheriting From Parent. "Inheriting From继承
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

方法重写

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.
protected section


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. "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

抽象类抽象方法

Report ZPolymorphism1. 
CLASS class_prgm Definition Abstract. "抽象类
PUBLIC Section. 
Methods: prgm_type Abstract, "只能在继承后才能实现,在cl_demo类中的实施中不可以被实现
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

final 在class类后表示不能再被继承了

final在方法后面表示不能被重写了

class cl_demo1 definition inheriting from cl_demo final."不可继承
methods m2 final."不可重写
endclass.

friends的作用

friends 的作用能让类1 friends 类2 类2能随意访问类1中的成员变量方法无论他是private还是什么

class cl_friend definition.
endclass.
class cl_demo definition friends cl_friend.
endclass.

多态

类中定义的成员变量与自己方法中的变量重名时

me用于区分成员变量与成员方法中的局部变量重名

data iv1 type c.
endclass.
.......
method im1.
data iv1 type c.
 me-iv1 ='c'."这里表示成员变量iv1
iv1 = '0'.
endmethod.
endclass.

data cl_parent type ref to cl_demo.
cl_child type ref of cl_demo_01.
create object cl_parent.
create object cl_child.
cl_parent->m1().
cl_parent = cl_child."m1被重名
cl_parent->m1()."这里用的是子类重写的方法
cl_child ?=cl_parent."强制转型
cl_child->m1()."用的还是子类重写的方法

super用于区分父类与子类重名的方法,成员变量

super-成员变量

super->方法

super=>静态方法

接口

类似于ABAP中的类，接口充当对象的数据类型。接口的组件与类的组件相同。与类的声明不同，接口的声明不包括可见性部分。这是因为在接口声明中定义的组件总是集成在类的public visibility部分。

当两个类似的类具有相同名称的方法但功能彼此不同时，使用接口。接口可能看起来类似于类，但是接口中定义的函数在类中实现以扩展该类的范围。接口以及继承特性为多态性提供了基础。这是因为在接口中定义的方法在不同类中的行为可能不同。

以下是创建接口的一般格式:

INTERFACE <intf_name>. 
DATA..... 
CLASS-DATA..... 
METHODS..... 
CLASS-METHODS..... 
ENDINTERFACE.

在此语法中，< intf_name> 表示接口的名称。 DATA和CLASSDATA语句可以分别用于定义接口的实例和静态属性。 METHODS和CLASS-METHODS语句可以分别用于定义接口的实例和静态方法。由于接口的定义不包括实现类，因此没有必要在接口的声明中添加DEFINITION子句。

注意 - 接口的所有方法都是抽象的。它们是完全声明的，包括它们的参数接口，但是没有在接口中实现。所有想要使用接口的类都必须实现接口的所有方法。否则，该类将成为抽象类。

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

interface i1."接口
methods item.
endinterface.
class c_demo definition.
public section.
interfaces i1."这里注意是interfaces
aliases item for i1-itm1."取别名
endclass.
class c_demo implementation.
method i1~itm1.
message 'interface method' type 'I'.
endmethod.
endclass.
start-of-selection.
data cl_int type ref to i1..
data cl_paret type ref to cl_demo.
create object cl_parent.
cl_int = cl_parent."多态
cl_int->itm()."这里用别名与
cl_int->i1~itm1."效果一样

事件

创建事件

触发事件

响应事件:要用一个方法可在事件创建的类中也可在别的类中效果无差

class cl_demo definition.
public sction.
data v1 type c.
events ev1 exporting value(v1)type c."事件创建
methods m1.
endclass.
class cl_demo implementation.
method m1.
raise event ev1 exporting v1='A'.
endmethod.
endclass.
class cl_friend definition.
public section.
methods f1 for event  ev1 of cl_demo importing v1.
endclass.
class cl_frind implementation.
method f1.
message v1 type 'I'.
end method.
endclass.
start-of-selection.
data(ins_demo)=new cl_demo( )."这里是简易定义引用对象
data(ins_friend)= new cl_friend( ).
set handler ins_friend->f1 for all instances."所有事件
set handler ins_friend->f1 for ins_demo."将两个事件绑在一起
ins_demo->m1()."对具体的事件相应

事件可以有参数接口，但它只有输出参数。输出参数通过RAISE EVENT语句传递到事件处理程序方法，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