面向对象

标签：

类CLASS

类分为局部类与全局类。全局类是通过ABAP工作中的类创建工具 Class Bulider 开发的（事务码为 SE24），主要保存在Class pool系统类库中，可供所有ABAP程序使用；而在程序内部（如报表程序内）定义的类则一般只应用于本程序，除了使用范围不同外，其它都是一样的；在使用类时系统首先会寻找程序内部定义的局部类，不存在时才去寻找全局类。

ABAP中的类定义是由类的声明与类的实现两部分组成

声明DEFINITION 

CLASS class DEFINITION  [class_options]. 
    [PUBLICSECTION. 
      [components]] 
    [PROTECTEDSECTION. 
      [components]] 
    [PRIVATESECTION. 
      [components]] 
ENDCLASS.

类的所有成员变量和成员方法都必须在“DEFINITION”部分进行声明，在声明时需指定成员的可见性。类的属性成员在类的声明部分定义，而类的方法则需要在类的声明和实现两部分才能完成定义：在声明部分说明方法的参数接口，在实现部分则通过ABAP代码完成具体功能。

类的方法需要在类的声明和实现两部分都要进行定义，在类的声明部分说明方法的参数接口，在类的实现部分则说明了具体的功能。

类的成员有三种可见范围：公共的、保护的、私有的：

o    公共部分PUBLIC：公共部分定义的类成员可以被所有的外部对象使用，包括类的方法及其派生类中定义的方法，公共部分的成员（特别是方法）构成了类对外接口

o    保护部分PROTECTED：保护部分定义的类成员只能被类及其派生类中的方法使用，对其他类或程序不可见了

o    私有部分PRIVATE：私有部分定义的类成员只能被该类自身其他成员所访问

一般不在类的公有部分定义类的属性，因为公有的可以直接被外界修改，违背了面向对象的封装原则。如果要将数据定义公共区，则一般是常量，不需要修改的，如圆周率。所以类的属性一般定义在私有或保护区

class_options

...[PUBLIC] 
    [INHERITING FROM superclass] 
    [ABSTRACT] 
    [FINAL] 
    [CREATE {PUBLIC|PROTECTED|PRIVATE}] 
    [SHAREDMEMORYENABLED] 
    [FORTESTING] 
    [[GLOBAL] FRIENDS class1 class2 ... 
intf1  intf2  ...].

PUBLIC

该选项是由Class Builder在创建时生成，只能在class pool上使用，不能用在程序中的局部类中

继承INHERITING FROM

在定义类时（不是现实时），使用INHERTING FROM选项指定从哪个类继承：

CLASS <subclass> DEFINITION INHERITING FROM<superclass>.

父类只能是那些non-final class，并且可见

每个类只能有一个父类，但可以有多个子类，像Java一样，属于单继承

如果未指定此选项，则默认会继承内置的、空的、抽象的object类。且每个继承树的根都是会是object

只有父类的public、protected的组件会继承过来，且继承过来后不会改变其原父类中的可见性。在子类中可以重写父类中继续过来的方法（属性字段没有重写这一说法的）

在重写REDEFINITION父类方法时，不可修改父类中定义的可见性，这与Java不同（java重写时是可以将可见性范围扩大）

继承树上的所有public 、protected组件都会被继承过来，且在同一个same namespace中，所以自定义的属性字段组件（指public、protected可见性属性）不能与继承过来的同名（Java中子类可以重新定义父类中的可见的同名属性，这样会覆盖父类中同名的属性字段，但ABAP根本就不可以这样），但方法是可以重写的；另外，由于父类Private的属性不能继承过来，所在可以在子类中定义同名的属性（此时public、protected、private可见性都可以）

子类和基类中的公有成员以及被保护成员具有共同的命名空间，因此不能重名，而私有成员则在不同类之间可以出现重名的情况

由于public、protected修饰的组件都是可以被子类继承的，所以若在子类定义同名的方法，则一定要定义成REDEFINITION，否则编译无法通过

父类静态的public、protected组件成员也是可以被子类继承的

基类是子类的泛化（Generalization），子类是基类的特殊化（Specialization）

从父类继承过来的方法（在子类中未重写），可以访问父类中的Private成员（与Java是一样的）

ABAP中的继承与Java一样，属于单继承，但可同时实现多个接口

抽象类ABSTRACT

定义为抽象类，此类不能被实例化，只能用来被继承

CLASS cl DEFINITION ABSTRACT.
  ...
ENDCLASS.

抽象类中可以包含抽象方法，一个抽象方法不能在抽象类本身中被实现，而必须在其子类中被实现，含有抽象方法的类必须被定义为抽象类。在派生类的声明时，使用REDEFINITION关键字对该抽象方法进行重新定义。

终结类FINAL

CLASS class DEFINITION FINAL.
...
ENDCLASS.

定义final类，final类是不能用来被继承的。

final类中的所有方法隐式都是final方法，且final类中的方法不能再明确使用final来修饰

如果某个类定义成了abstract 、final，则只能使用此类中的static的组件（你可以定义非static的实例组件，但你不能够使用它们）

与Java不同的是，可以将某个类同时定义成finalab stract，如果定义成final abstract，则该类定义时最好只定义静态的成员（虽然可以定义非静态成员编译时不会报错，但意义不大，因为final决定了该类不能被继承，而abstract又决定了该类不能被实例化）；但相同的是，一个final方法不可以同时是abstract方法。

定时成FINAL类型的类，不能再定义FINAL方法，因为FINAL类型的中所有方法默认就是FINAL了。

CREATE {PUBLIC|PROTECTED|PRIVATE}

该类可以在哪里实例化（即类的可见性），也就是说，CREATE OBJECT语句可以在哪里使用（有点像Java中的类可见修饰符：public、包访问）。

l  CREATE PUBLIC：在任何地方类都是可见的（即可被创建）

l  CREATE PROTECTED：只能在自己所在类的方法或者是子类中的方法中可见（即可被创建）

l  CREATE PRIVATE：只能在自己所在类的方法中可见（即可被创建）

[GLOBAL] FRIENDS

INTERFACE i1. 
  ... 
ENDINTERFACE. 

CLASS c1 DEFINITIONCREATEPRIVATE FRIENDS i1. 
PRIVATESECTION. 
DATA a1 TYPEc LENGTH 10VALUE‘Class 1‘. 
ENDCLASS. 

CLASS c2 DEFINITION. 
PUBLICSECTION. 
INTERFACES i1. 
METHODS m2. 
ENDCLASS. 

CLASS c2 IMPLEMENTATION. 
METHOD m2. 
DATA oref TYPEREFTO c1. 
CREATE OBJECT oref. 
WRITE  oref->a1. 
ENDMETHOD. 
ENDCLASS.

components

可使用的组件有：

2  TYPE-POOLS, TYPES, DATA, CLASS-DATA, CONSTANTS for data types and data objects

2  METHODS, CLASS-METHODS, EVENTS, CLASS-EVENTS for methods and events

2  INTERFACES（如果在类中，表示需要实现哪个接口；如果是在接口中，表示继承哪个接口） for implementing interfaces and ALIASESfor alias names for interface components给接口组件取别名

属性（Attributes）、方法（Methods）、事件（Events）、内部类型（Types）、常量（Constants）、别名（ALIAS Names）同属同一命名空间，所以这些名称不能相同（与Java不一样）

ABAP类中可以定义三种不同的类型的成员：属性、方法、事件。各种成员的可见性（public protected privte）及生存周期（静态、非静态）只能在类定义时指定，而不是在类实现时指定。

ABAP里的静态与非静态成员是在DATA、METHODS、EVENTS前加上前缀CLASS-来体现的：CLASS-DATA、CLASS-METHODS、CLASS-EVENTS，而不是使用STATIC来修饰的。

类的属性除了DATA（非静态的实例变量）以外，可以为下面语句定义的属性（这些都是静态的？）：TYPE-POOLS、TYPES、CLASS-DATA、CONSTANTS

在类或接口中使用CONSTANTS定义的属性是静态的属性，类似于在DATA前加上  CLASS-  前缀而变成静态属性一样，且在定义时就需要赋值。

在类中使用TYPES定义的数据类型，也相当于静态属性。

在类或接口的中使用DATA定义公共属性时，可以加上READ-ONLY选项，表示该属性只能被外部读取，而不能被修改，但可以被内部或子类进行修改。

静态属性在整个继承树中只存在一份，父类的可见静态属性只会加载一次

在类的定义过程中，事件也可以被声明为一种成员组件，声明之后，所有类内部访问均可以触发该事件，还可以在类或者其他类中定义特定的捕捉方法对事件进行处理。

接口组件别名

所有接口组件可以使用 ALIASES 指定其别名（Alias Name），这样在访问接口时，可以简化Interface~前缀。ALIASES只能在接口内或者类的定义部分使用，不能在类的实现部分使用

INTERFACE account.
  METHODS calc IMPORTING p1 TYPE i.
ENDINTERFACE.

CLASS cls1 DEFINITION.
  PUBLIC SECTION.
    INTERFACES account.
    ALIASES calc FOR account~calc.
ENDCLASS.

CLASS cls1 IMPLEMENTATION.
"METHOD account~calc.
  METHOD calc.
    WRITE: / ‘Deposit money is:‘,p1.
  ENDMETHOD.
ENDCLASS.

START-OF-SELECTION.
  DATA:cref1 TYPE REF TO cls1.
  CREATE OBJECT:cref1.
"CALL METHOD:cref1->account~calc EXPORTING p1 = 200.
  CALL METHOD:cref1->calc EXPORTING p1 = 200.
"可以去掉 account~ 前缀，使用别名直接进行访问
  CALL METHOD:cref1->calc EXPORTING p1 = 200.

实现IMPLEMENTATION

CLASS class IMPLEMENTATION. 
    ... 
METHOD ... 
      ... 
ENDMETHOD. 
    ... 
ENDCLASS.

注：不是所有类都需要有实现部分的。只有在类定义时，定义了方法时，才需要实现，如果没有方法，或者类本身定义成了抽象类，则不需要进行实现了，如下面定义的类就不需要写实现部分了：

CLASS a1 DEFINITION . "由于类中未定义任何方法，所以a1不需要有实现类了
ENDCLASS.

============================

CLASS a1 DEFINITION ABSTRACT.
  PUBLIC SECTION.
    METHODS:m1 ABSTRACT. "由于是抽象方法，所以a1不需要有实现类了
ENDCLASS.

============================

CLASS a1 DEFINITION.
  PUBLIC SECTION.
    METHODS:m1 .
ENDCLASS.
CLASS a1 IMPLEMENTATION.
  METHOD:m1.
  ENDMETHOD.
ENDCLASS.
"a2不需要实现，因为继承过来的方法已经被父类自己实现了
CLASS a2 DEFINITION INHERITING FROM a1.
ENDCLASS.

方法的声明

实例方法能访问对象实例中的所有属性和事件以及类的静态成员，而静态方法则只能访问类的静态属性和静态事件

一般方法

METHODS meth [ABSTRACT|FINAL] 
    [IMPORTING parameters [PREFERRED PARAMETER p]] 
    [EXPORTING parameters] 
    [CHANGING parameters] 
    [{RAISING|EXCEPTIONS} exc1 exc2 ...].

静态方法：

CLASS-METHODS meth [ABSTRACT|FINAL] 
    [IMPORTING parameters [PREFERRED PARAMETER p]] 
    [EXPORTING parameters] 
    [CHANGING parameters] 
    [{RAISING|EXCEPTIONS} exc1 exc2 ...].

parameters

... { VALUE(p1) | REFERENCE(p1) | p1 }
        { TYPEgeneric_type } 
|{TYPE{[LINEOF] complete_type}|{REFTO {data|object|complete_type|class|intf}}}
|{LIKE{[LINEOF] dobj}|{REFTO dobj} } 
[OPTIONAL|{DEFAULTdef1}]

{ VALUE(p2) | REFERENCE(p2) | p2 }...]
...
data、object：表示是通用数据类型data、object

complete_type：为完全限定类型

OPTIONAL与DEFAULT两个选项不能同时使用，且对于EXPORTING类型的输入参数不能使用

如果参数名p1前没有使用VALUE、REFERENCE，则默认为还是REFERENCE，即引用传递

不能在方法中修改按引用传递的输入参数，这与Function是一样的

PREFERRED PARAMETER首选参数

设置多个IMPORTING类型参数中的某一个参数为首选参数。

首选参数的意义在于：当所有IMPORTING类型都为可选optional时，我们可以通过PREFERRED PARAMETER选项来指定某一个可选输入参数为首选参数，则在以下简单方式调用时：

[CALLMETHOD] meth( a ).

实参a的值就会传递给设置的首参，而其他不是首参数的可选输入参数则留空或使用DEFAULT设置的默认值

注：此选项只能用于IMPORTING类型的参数；如果有必选的IMPORTING输入参数，则没有意义了

RAISINGexc1 exc2

exc1 exc2为class-based exceptions的异常，如果方法运行时出现了exc1 exc2异常，则会抛出

exc1 exc2为CX_STATIC_CHECK 或者是CX_DYNAMIC_CHECK的子类，如果需要抛出多个异常，且有父子关系，则子的应该排在前面

CX_STATIC_CHECK 或者是CX_DYNAMIC_CHECK类型的异常需要显示的抛出，而CX_SY_NO_HANDLER类型的异常不需要

CLASS math DEFINITION.
  PUBLIC SECTION.
    METHODS divide_1_by
            IMPORTING operand TYPE i
            EXPORTING result  TYPE f
            RAISING   cx_sy_arithmetic_error.
ENDCLASS.
CLASS math IMPLEMENTATION.
  METHOD divide_1_by.
    result = 1 / operand.
  ENDMETHOD.
ENDCLASS.

              

START-OF-SELECTION.

DATA oref TYPEREFTO math.
DATA exc  TYPEREFTO cx_sy_arithmetic_error.
DATA res  TYPE f.
DATAtextTYPE string.

CREATEOBJECT oref.
TRY.
      oref->divide_1_by( EXPORTING operand = 4
IMPORTING result = res ).
text = res.
CATCH cx_sy_arithmetic_error INTO exc.
text = exc->get_text( ).
ENDTRY.
MESSAGEtextTYPE‘I‘.

EXCEPTIONS exc1 exc2

exc1 exc2为non-class-based exceptions类型的异常，可以由方法中的RAISE 或者 MESSAGE RAISING语句来触发

CLASS math DEFINITION.
PUBLICSECTION.
METHODS divide_1_by
IMPORTING  operand TYPEI
EXPORTING  result  TYPE f
EXCEPTIONS arith_error.
ENDCLASS.

CLASS math IMPLEMENTATION.
METHOD divide_1_by.
TRY.
        result = 1 / operand.
CATCH cx_sy_arithmetic_error.
RAISE arith_error.
ENDTRY.
ENDMETHOD.
ENDCLASS.

START-OF-SELECTION.
DATA res  TYPE f.
DATA oref TYPEREFTO math.
CREATE OBJECT oref.
oref->divide_1_by( EXPORTING  operand = 4
IMPORTING  result  = res
EXCEPTIONS arith_error = 4 ).
IFsy-subrc = 0.
WRITE res.
ELSE.
WRITE‘Arithmetic error!‘.
ENDIF.

抽象方法ABSTRACT

ABSTRACT关键字可修饰方法也修饰类，且定义抽象方法时，只能用在抽象类（Abstract Class）里面（接口与非抽象类定义里不能直接用来修改方法）

静态的方法不能定义成Abstract的

抽象方法一定要在其子类声明部分使用REDEFINITION关键字进行重写实现，不能在自己所在实现类中写方法体

接口中的方法默认就是ABSTRACT

Abstract Final修饰的类中可以定义抽象方法，但该类没有什么用（不能被继承，所以不能被实现），并且Abstract Final修饰的类中可以定义实例方法，不像Java那样严格

终结方法FINAL

METHODS meth FINAL...

FINAL关键字可修饰方法也修饰类

FINAL修饰的方法只能在类中进行声明，不能在接口中进行声明。

最终方法是不可以重新定义（重写）的方法，不一定出现在最终类中，但最终类中的所有方法都是最终方法，因此不能再重复使用FINAL关键字了

与Java不同的是，可以将某个类同时定义成finalabstract，如果定义成final abstract，则该类定义时最好只定义静态的成员（虽然可以定义非静态成员编译时不会报错，但意义不大，因为final决定了该类不能被继承，而abstract又决定了该类不能被实例化）；但与Java相同的是，一个final方法不可以同时是abstract方法。

函数方法（Return唯一返回值）

非静态

METHODS meth [ABSTRACT|FINAL]
    [IMPORTING parameters [PREFERRED PARAMETER p]]
RETURNING VALUE(r) typing
    [{RAISING|EXCEPTIONS} exc1 exc2 ...].

静态

CLASS-METHODSmeth [ABSTRACT|FINAL]
    [IMPORTING parameters [PREFERRED PARAMETER p]]
RETURNING VALUE(r) typing
    [{RAISING|EXCEPTIONS} exc1 exc2 ...].

RETURNING ：用来替换EXPORTING 、CHANGING，不能同时使用。定义了一个形式参数 r 来接收返回值，并且只能是值传递

此处的r只能是完全限制类型，不能是通用类型typing：

{ TYPE {[LINEOF] complete_type}
|{REFTO {data|object|complete_type|class|intf}} }
  |{ LIKE {[LINEOF] dobj}| {REFTO dobj} } ...

具有唯一返回值的函数方法可以直接用在以下语句中：

o    逻辑表达式：IF、ELSEIF、WHILE、CHECK、WAIT

o    CASE

o    LOOP

o    算术表达式

o    赋值语句

此类方法可以采用简单调用方式：

meth( )

meth( a )

meth( p1 = a1 P2 = a2 ... )

CLASS math DEFINITION.
PUBLICSECTION.
METHODS factorial
IMPORTING n TYPEi
RETURNINGvalue(fact) TYPEi.
ENDCLASS.

CLASS math IMPLEMENTATION.
METHOD factorial.
fact = 1.
IF n = 0.
RETURN.
ELSE.
DO n TIMES.
        fact = fact * sy-index.
ENDDO.
ENDIF.
ENDMETHOD.
ENDCLASS.

START-OF-SELECTION.
DATA oref TYPEREFTO math.
DATA result TYPEi.

CREATEOBJECT oref.
result = oref->factorial( 4 ).
WRITE: result.

构造函数constructor

非静态

METHODS constructor [FINAL]
    [IMPORTING parameters [PREFERRED PARAMETER p]]
    [{RAISING|EXCEPTIONS} exc1 exc2 ...].

构造函数的名是固定的，即为constructor

构造方法默认就是FINAL的，所以没有必要加

构造器必须放在Public段中进行声明

构造方法中不能包含任何形式的输出参数和返回值

如果在对象创建并调用构造方法的过程中出现异常，则该对象将被删除

构造函数没有输出参数，只有输入参数，且无返回值

每个类都会有一个默认的无参构造器，但如果重新定义了构造器，则会覆盖默认构造器

在类的创建过程中，有两个特殊的方法，一个是实例的构造函数constructor，该方法在实例创建时隐式的调用；另一个方法是类构造函数class_constructor，该方法在第一次访问类时被调用，且只调用一次。

如果某个类继承了别的类（Object除外），这个某个类又重新定义了构造器，则一定要在构造器中明确使用super->constructor方法来调用一下父类构造器（否则编辑不通过），只有这样才能保证整个对象被完整地构造出来，因为子类只能正确地构造出属于自己的那部分属性，对于从基类继承来的那部分属性要调用基类中的构造方法来完成。在调用父构造器前，只能访问父类中静态的组件，只有在调用了父类构造器后，才能去访问父中的实例组件，这与Java不太一样（Java在明确调用父类构造器时，要放在第一句）

如果在一个子类里重写了默认构造函数constructor，则在实现时一定要明确的使用CALL METHOD super->constructor.调用一下父类的构造函数，但不一定是在第一句进行调用，这与Java有点不一样：Java可以重写默认构造函数，且重写时不一定要明确调用父类构造函数，因为它会默认调用默认构造函数，且调用时只能是在第一句。在ABAP中子类重写构造函数不需要明确调用父类构造函数的唯一列外是该类继承的是OBJECT类。

如果某个类重写了父类某个方法，则在父类构造器中如果调用该方法，调用到的方法还是父类的方法，而不是被重写后的子类方法，这与Java又不一样（Java中不管重写的方法是抽象的还是非抽象的，都是可以回调到子类重写过的方法），所以不要在父类方法中回调子类被重写过非Abstract方法，因为根本无法回调到，调到还是父类自己的方法：

CLASS a1 DEFINITION.
  PUBLIC SECTION.
    METHODS :constructor ,
              m1,m2.
ENDCLASS.

CLASS a2 DEFINITION INHERITING FROM a1.
  PUBLIC SECTION.
    METHODS: constructor ,
              m1 REDEFINITION,m2 REDEFINITION.
ENDCLASS.

CLASS a1 IMPLEMENTATION.
  METHOD: constructor.
    "调用的是父类中的方法，而不是子类被重写的方法，这与Java不一样
    me->m1( ).
  ENDMETHOD.
  METHOD: m1.
    WRITE: / ‘a1~m1‘.
    "即使不是在父类构造器中调用被重写方法也是这样的，与Java不一样
    me->m2( ).
  ENDMETHOD.
  METHOD: m2.
    WRITE: / ‘a1~m2‘.
  ENDMETHOD.
ENDCLASS.

CLASS a2 IMPLEMENTATION.
  METHOD: constructor.
    super->constructor( ).
    SKIP.
    me->m1( ).
  ENDMETHOD.
  METHOD: m1.
    WRITE: / ‘a2~m1‘.
    me->m2( ).
  ENDMETHOD.
  METHOD: m2.
    WRITE: / ‘a2~m2‘.
  ENDMETHOD.
ENDCLASS.

START-OF-SELECTION.
  DATA: o TYPE REF TO a1.
  CREATE OBJECT o TYPE a2.
  SKIP.
  o->m1( ).

另外，不能在构造器中调用抽象方法，所以要想在父类的方法中回调到时子类重定义方法，该被重写的方法一定要是父类中定义的抽象方法，这与设计模式中的模板方法设计模式是相当的，以下是使用ABAP面向对象来实现模板方法设计模式：

CLASS a1 DEFINITION ABSTRACT.
  PUBLIC SECTION.
    METHODS: m1,m2 ABSTRACT.
ENDCLASS.

CLASS a2 DEFINITION INHERITING FROM a1.
  PUBLIC SECTION.
    METHODS: m2 REDEFINITION.
ENDCLASS.

CLASS a1 IMPLEMENTATION.
  METHOD: m1.
    "模板模式：在父类中回调子类实现的父类中所定义的抽象方法
    me->m2( ).
  ENDMETHOD.
ENDCLASS.

CLASS a2 IMPLEMENTATION.
  METHOD: m2."实现父类中定义的抽象方法
    WRITE: / ‘a2~m2‘.
  ENDMETHOD.
ENDCLASS.

START-OF-SELECTION.
  DATA: o TYPE REF TO a1.
  CREATE OBJECT o TYPE a2.
  SKIP.
  o->m1( )."调用继承过来的父类方法

静态

CLASS-METHODSclass_constructor.

静态的构造函数是每个类都已具有的方法，但我们可以通过重定义来完成某些初始化工作

静态的构造器只在程序中被调用一次，即第一次作用该类调用时，且不能被程序显示地调用

该方法也必须在公共部分采用CLASS-METHODS声明，其名称必须是class_constructor，且没有参数（因为不能被显示的调用）

并且在此方法里只能访问类的静态属性

CLASS a1 DEFINITION.
  PUBLIC SECTION.
    class-METHODS: class_constructor .
ENDCLASS.
CLASS a1 IMPLEMENTATION.
  METHOD: class_constructor.
    WRITE:/ ‘类已加载‘.
  ENDMETHOD.
ENDCLASS.

START-OF-SELECTION.
DATA: o TYPE REF TO a1.
"在每一次使用类时，静态的构造函数会自动调用
CREATE OBJECT o.

方法重写（Overriding）与重载（Overloading）

在类的声明中，通过REDEFINITION选项告诉其实现类要重写父类的meth方法（实例请参考这里）：

METHODS meth [FINAL] REDEFINITION.

重写一个方法首先需要在子类的类声明中用“REDEFINITION”进行重定义，如果被重写的方法具有参数，则在子类的重定义中不必再重新声明一遍参数列表了，而只需要写函数的名称即可，这是因为ABAP面向对象中，不支持方法之间的重载，即在同一个类中不允许存在两个同名的方法而不管其参数列表是否一致（注：虽然父与子类构造器允许重新定义构造函数constructor，虽然名称相同，但还是可以都重定定义，不会出现同名问题，因为构造函数属于各自的命名究竟，这不属于重写或重载父类中的构造函数，构造函数是一种特殊的方法）；在子类重写的方法中，可以使用“super->”来访问被重写的父类中的成员，super->XXX( ) 只能用于子类中被重写的方法XX中，其他方法中不能直接使用（这与Java不太一样），其作用只是防止循环调用？

重定义（重写）方法必须在子类中被重新实现，且重定义的方法参数不能被更改

静态方法不可以被重写，这与Java一样。一个类的非私有的静态属性将被所有该类的子类所共享

创建对象CREATE OBJECT

在调用CREATE OBJECT语句时，会自动调用类的构造器

在创建过程如果出现异常，则oref为初始值，并且sy-subrc为非零（EXCEPTIONS选项设置的异常值）

根据引用变量（oref）类型来创建对象

CREATE OBJECT oref [AREA HANDLE handle] 
[{ [EXPORTING  p1 = a1 p2 = a2 ...] 
[EXCEPTIONS exc1 = n1 exc2 = n2 ...] } 
| { [PARAMETER-TABLE ptab][EXCEPTION-TABLE etab] }].

此种方式创建对象时，对象的类型由oref定义时的类型来决定，如下面的创建的对象类型为c1：

CLASS c1 DEFINITION.
ENDCLASS.
DATA oref TYPE REF TO c1.
CREATE OBJECT oref.

注：oref的类型c1必须是一个可以实例化的具体类，不能是接口、抽象类、以及Object

创建时明确指定对象类型（TYPE class）

CREATE OBJECT oref [AREA HANDLE handle] 
TYPE {class|(name)} 
[{ [EXPORTING  p1 = a1 p2 = a2 ...] 
    [EXCEPTIONS exc1 = n1 exc2 = n2 ...] } 
| { [PARAMETER-TABLE ptab][EXCEPTION-TABLE etab] }].

此种方式创建的对象类型则这里的class或动态(name)来决定，而非oref定义的类型，如下面创建的对象最终其真正类型为c1，而非object（其实这里就是可以使用父类的引用指向子类对象而已）：

CLASS c1 DEFINITION. 
ENDCLASS. 
DATA oref TYPEREFTO object. 
CREATEOBJECT oref TYPE c1.

class或动态(name)必须是一个可实例化的具体类（也不能是不能是接口、抽象类、以及Object），且为oref定义的类型或者是其子类。而oref的类型则可以是类、或者是接口，甚至是Object

(name)为动态指定类名，且为大写，可以是决定类型名称（The RTTS can determine the absolute type name of any object.）

C2为C1的子类：

DATA o1 TYPEREFTO c1.
DATA o2 TYPEREFTO c2.
CREATE OBJECT o2.
o1 = o2.

这里的o2是一个引用类型变量，其实就是一个指针，用来存储对象的地址，而CREATE语句就是创建了一个对象并让o2指向它，并且最后将o2赋值给o1，这样o1也会指向o2所指向的同一对象

成员访问

oref->comp

其中，oref代表对象引用变量，comp代表要访问的类成员，“->”为对象组件选择运算符，可以用于访问类中定义的实例组件和静态组件。对于类中的静态组件而言，还有另外一种访问方式，可以不通过实例和引用就可以进行访问，而是通过类名称本身使用类成员选择运算符“=>”直接进行操作：

class=>comp

由于对象引用变量本身也可以被定义为类属性，因而可以出现下述的链式访问结构：

oref1->oref2->comp

或者

class=>oref->comp

在类的实例方法中，与Java一样有一个当前指针this，只不过名字为me。

me(this)

me 就是相当于Java中的this，指向当前实例对象

用me引用变量可以引用类中的成员变量或方法

当方法的一个参数名或方法内部的局部变量名与类的成员变量的名字重复的时候，要在该方法内部引用类成员变量xxx时，就必须使用me->xxx 来引用

方法调用

方法的声明请参考这里

静态调用（注：这里的静态不是指调用静态方法）

[CALLMETHOD]  meth|me->meth|oref->meth|super->meth|class=>meth[(]
[EXPORTING  p1 = a1 p2 = a2 ...] 
{{[IMPORTING  p1 = a1 p2 = a2 ...] 
   [CHANGING   p1 = a1 p2 = a2 ...]}
|[RECEIVING  r  = a  ] }
[EXCEPTIONS [exc1 = n1 exc2 = n2 ...] 
[OTHERS = n_others] ] [)].

如果省略CALL METHOD，则一定要加上括号形式；如果通过CALL METHOD来调用，则括号可加可不加

RECEIVING：用来接收METHODS 、CLASS-METHODS 中RETURNING选项返回的值

等号左边的都是形式参数，右边为实参，EXPORTING指定输入参数，IMPORTING指定输出参数，这与函数的调用相似（调用用时与定义是相反的）

如果EXPORTING 、IMPORTING 、CHANGING、RECEIVING、EXCEPTIONS、OTHERS同时出现时，应该按此顺序来编写

注：此种方式调用时，如果原方法声明时带了返回值RETURNING，只能使用RECEIVING来接受，而不能使用等号来接收返回值：

num2 =o1->m1(  EXPORTING  p1 = num1 ).

简单调用方式

[CALLMETHOD] { meth|me->meth|oref->meth|super->meth|class=>meth( )
              | meth|me->meth|oref->meth|super->meth|class=>meth( a ) 
              | meth|me->meth|oref->meth|super->meth|class=>meth( p1 = a1 p2 = a2 ... ) }.

此方式下输入的参数都只能是IMPORTING类型的参数，如果要传CHANGING、EXPORTING、RAISING、EXCEPTIONS类型的参数时，只能使用上面静态调用方式。

2 meth( )

此种方式仅适用于没有输入参数（IMPORTING）、输入\输出参数（CHANGING）、或者有但都是可选的。

通过此种简单方式调用时，会忽略掉EXPORTING输出参数，即不能接收EXPORTING输出值

2 meth( a )

此种方式仅适用于只有一个必选输入参数（IMPORTING）（如果还有其他输入参数，则其他都为可选，或者不是可选时但有默认值也可），或者是有多个可选输入参数（IMPORTING）（此时没有必选输入参数情况下）的情况下但方法声明时通过使用PREFERRED PARAMETER选项指定了其中某个可选参数为首选参数（首选参数即在使用meth( a )方式传递一个参数进行调用时，通过实参a传递给设置为首选的参数）

此情况下可以带可选的OPTIONAL类型的输入输出（input/output）CHANGING类型的参数，以及输出参数EXCEPTIONS，但这些都会被忽略

2 meth( p1 = a1 p2 = a2 ... )

此种方式适用于有多个必选的输入参数（IMPORTING）方法的调用，如果输入参数（IMPORTING）为可选，则可以不必传

动态调用

CALL METHOD (meth_name) 
            | cref->(meth_name) 
            | iref->(meth_name) 
            | (class_name)=>(meth_name) 
            | class=>(meth_name) 
            | (class_name)=>meth 
{ 
   [EXPORTING  p1 = a1 p2 = a2 ...] 
{{[IMPORTING  p1 = a1 p2 = a2 ...][CHANGING p1 = a1 p2 = a2 ...]}
   |[RECEIVING  r  = a  ] }
   [EXCEPTIONS [exc1 = n1 exc2 = n2 ...] 
   [OTHERS = n_others] ]
}
|
{[PARAMETER-TABLE ptab][EXCEPTION-TABLE etab]}.

PARAMETER-TABLE ptab

ptab为ABAP类型组中定义的哈希表ABAP_PARMBIND_TAB，行结构为ABAP_PARMBIND：

* PARAMETER-TABLE
BEGIN OF abap_parmbind,
    name  TYPE abap_parmname,
    kind  TYPE abap_parmkind,
value TYPE REF TO data,
ENDOF abap_parmbind

abap_parmbind_tab TYPE HASHED TABLE OF abap_parmbind WITH UNIQUE KEY name,

name：形式参数的名，且为大写

kind：形式参数的类别，具取值为CL_ABAP_OBJECTDESCR 类的常量EXPORTING, IMPORTING, CHANGING, RECEIVING：

value：参数值，类型为数据引用，即实参的地址（可以是所有类型变量的地址，如普通数据就是，或引用对象等），使用：GETREFERENCEOFpnameINTOptab-value来获取实参地址

EXCEPTION-TABLE etab

non-class-based exceptions，etab为ABAP类型组中定义的哈希表ABAP_EXCPBIND_TAB，行结构为ABAP_EXCPBIND：

* EXCEPTION-TABLE
BEGINOFabap_excpbind,
    name  TYPE abap_excpname,形式参数名，且大写，还可以是OTHERS
    value TYPEi,异常值，出现异常后，此值会存储到sy-subrc系统变量中
ENDOF abap_excpbind,
abap_excpbind_tabTYPEHASHEDTABLEOF abap_excpbind
WITHUNIQUEKEY name.

垃圾回收

ABAP与Java一样也有垃圾回收机制，当没有引用变量再指向某个对象时，将会被自动回收，所以如果要加快垃圾回收，可以使用CLEAR语句初始化指向它的引用变量（相当于Java中给引用设置为null一样），或者使指向它的引用指向其他对象。

多态（转型）

向上转型（Up Casting）：多态

向下转型（Down Casting）：需要进行强转

上图中 student_ref = person_ref. 语句因该有问题，需强转，如下：

CLASS person DEFINITION.

ENDCLASS.

CLASS stud DEFINITION INHERITING FROM person.

ENDCLASS.

START-OF-SELECTION.

  DATA p TYPE REF TO person.

  DATA s TYPE REF TO stud.

  CREATE OBJECT s.

  p = s.

  "拿开注释运行时抛异常，因为P此时指向的对象不是Student，而是Person

  "所以能强转的前提是P指向的是Student

  "CREATE OBJECT p.

  s ?= p."需这样强转

抽象类（ABSTRACT）和最终类（FINAL）

CLASS class DEFINITION ABSTRACT.

...

ENDCLASS.

抽象类不能使用 CREATE OBJECT 语句创建类对象。

也可以将方法定义为抽象方法：

METHOD meth ABSTRACT ...

一个抽象方法不能在类本身中被实现，而必须在其派生出的非抽象类中实现。因而含有抽象方法的类必须被定义为抽象类。

最终类（Final）是不能被继承的类：

接口Interface

针对接口编程：

接口隔离：

定义接口

INTERFACE intf [PUBLIC]. 
  [components] 
ENDINTERFACE.

接口中可以定义以下一些组件（Java接口中定义的属性成员都是 public static 的，而方法都是public abstract，但ABAP接口中定义的属性与方法可以是静态的也可以是非静态的）：

INTERFACE i1.
  CLASS-DATA a2 TYPE i .
  CONSTANTS a3 TYPE i VALUE 1."相当于静态的
  CLASS-METHODS m2.
  CLASS-EVENTS e2.
  TYPES a TYPE c LENGTH 2.
  DATA    a1 TYPE string .
  METHODS m1.
  EVENTS  e1 EXPORTING value(p1) TYPE string.
ENDINTERFACE.
=================================================
CLASS aa DEFINITION.
  PUBLIC SECTION.
    INTERFACES i1.
ENDCLASS.
CLASS aa IMPLEMENTATION.
  METHOD i1~m1.
    WRITE:i1~a2.
    WRITE:i1~a1.
    WRITE:i1~a3.
  ENDMETHOD.
  METHOD i1~m2.
    WRITE:i1~a2.
    "WRITE:i1~a1."静态方法中不能访问非静态属性
    WRITE:i1~a3.
  ENDMETHOD.
ENDCLASS.
START-OF-SELECTION.
  DATA obj TYPE REF TO aa.
  CREATE OBJECT obj.
  WRITE: aa=>i1~a2.
  WRITE: obj->i1~a2.
  WRITE: obj->i1~a1.
  WRITE: aa=>i1~a3.
  WRITE: obj->i1~a3.

接口中所定义的所有东西默认都是公共的，所以不用也不能写PUBLIC SECTION

在接口定义内部可以声明的成员与类中的成员相同（包括属性、方法和事件等，与Java中的接口不太一样就是可以有非静态的成员属性），但无需注明具体的可见性，因为所有接口组件成员均为公有成员。同时，接口定义中也只能包含成员声明部分，而具体的实现将在具体类中进行。

只有在接口中定义的常量（CONSTANTS）才可以使用 VALUE 选项来初始化，而DATA、CLASS-DATA定义的变量是不能初始化。

实现接口

如果要实现某个接口，则在类的公共声明PUBLIC SECTION部分（其他Protected、Private不行），使用以下语句来完成：

INTERFACES intf 
{ {[ABSTRACTMETHODS meth1 meth2 ... ] 
[FINALMETHODS meth1 meth2 ... ]} 
| [ALLMETHODS {ABSTRACT|FINAL}] } 
[DATAVALUES attr1 = val1 attr2 = val2 ...].

可以使用ABSTRACT METHODS、FINAL METHODS选项来指定方法meth1 meth2 ...为abstract 或者是 final类型的方法，这与METHODS语句的ABSTRACT、FINAL选项的意义是一样的。当把接口中的某个方法声明在ABSTRACTMETHODS选项后面时，这个类一定要声明成抽象类，并且接口中的方法不能同时出现在ABSTRACTMETHODS与FINALMETHODS后面。

如果接口中的方法都不实现或实现后都不能再被重写时，可以使用ALLMETHODS {ABSTRACT|FINAL}选项快捷操作