ABAP 继承

发表于 更新于 分类于 ， 阅读次数： 本文字数： 1.1k 阅读时长 ≈ 4 分钟

ABAP 继承

🎯 继承的基本概念

面向对象编程中最重要的概念之一是==继承==。继承允许我们根据另一个类定义一个类，这使得创建和维护应用程序变得更容易，也提供了重用代码功能和快速实现时间的机会。

当创建类时，程序员可以指定新类应该继承现有类的成员，而不是写入完全新的数据成员和方法。此现有类称为==基类==或==超类==，新类称为==派生类==或==子类==。



graph TD
    A[超类 Superclass] -->|继承| B[子类 Subclass]
    A --> C["公共成员<br>（可访问）"]
    A --> D["保护成员<br>（可访问）"]
    A --> E["私有成员<br>（不可直接访问）"]
    B --> F["继承的成员<br>+ 新增成员"]
    B --> G["可重定义方法"]

继承的特点

  • 一个类的对象可以获取另一个类的属性
  • 派生类继承超类的数据和方法，但可以==覆盖方法==并==添加新方法==
  • 继承的主要优点是==可重用性==

📋 继承语法

除了类定义语句之外，还使用 INHERITING FROM 指定继承关系：

1
CLASS <subclass> DEFINITION INHERITING FROM <superclass>.

💡 示例：基本继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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.

输出结果

1
2
This is public data
Method in child class  This is public data
💥代码解析
  • INHERITING FROM parent — 子类 child 继承自父类 parent
  • 子类自动拥有父类的公共数据 w_public
  • 子类可以定义自己的方法 childm

🔍 访问控制和继承

派生类可以访问其基类的所有==非私有成员==。因此，不应该被子类的成员函数访问的超类成员应该在超类中被声明为私有的。

访问类型总结

访问位置 公开（PUBLIC） 保护（PROTECTED） 私有（PRIVATE）
同类 ✅ ✅ ✅
派生类 ✅ ✅ ❌
外部 ✅ ❌ ❌

三种继承类型



graph LR
    A[继承类型] --> B["公共继承<br>PUBLIC"]
    A --> C["保护继承<br>PROTECTED"]
    A --> D["私有继承<br>PRIVATE"]
    B --> B1["public → public<br>protected → protected"]
    C --> C1["public → protected<br>protected → protected"]
    D --> D1["public → private<br>protected → private"]

1. 公共继承（常用）

  • 超类的公共成员 → 子类的公共成员
  • 超类的受保护成员 → 子类的受保护成员
  • 超类的私有成员不能直接从子类访问

2. 受保护的继承

  • 超类的公共和受保护成员 → 子类的受保护成员

3. 私有继承

  • 超类的公共和受保护成员 → 子类的私有成员
💡实际开发建议
在ABAP面向对象开发中，几乎总是使用公共继承。保护继承和私有继承很少使用。

🏗️ 子类中的重定义方法

超类的方法可以在子类中==重新实现==。重新定义方法的规则：

规则 说明
同一节声明 重定义语句必须与原始方法的定义在同一节中
无需重写接口 只需要输入方法的名称，不需要再次输入其接口
超类引用 可以使用 SUPER-> 访问直接超类的组件
使用范围 伪引用 SUPER 只能在重定义的方法中使用
💡超类引用
在重定义的方法中，可以使用 SUPER-> 来访问超类的原始实现：
1
2
3
4
5
METHOD addition1.
  " 先调用父类的原始实现
  SUPER->addition1( ... ).
  " 再添加额外逻辑
ENDMETHOD.

示例：方法重定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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: 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.

执行结果

输入值 9 和 10，输出结果为：

1
Redefinition Demo  29
💥代码解析
  • REDEFINITION — 关键字表示子类重定义了父类的方法
  • 子类 addition1 在父类的基础上增加了 +10 的逻辑
  • 结果 29 = 9 + 10 + 10

⚠️ 注意事项

  • 谨慎使用继承，避免过深的继承层次
  • 优先使用==组合==而非继承
  • 确保子类满足 “==is-a==” 关系
  • 重写方法时考虑向上兼容性
  • ABAP 只支持==单继承==（一个类只能有一个父类）