✒️ABAP / Las propiedades de la programación orientada a objetos Por Jaime Gomez Arango
ABAP Las propiedades de la programación orientada a objetos
Object-Oriented Programming Properties
Encapsulation
Encapsulation, also known as "hiding," refers to the concept where objects restrict the visibility of their resources (attributes and methods) from other users. It's like hiding the complexity under a hood.
In encapsulation, we have three visibility areas: public, protected, and private. These areas form the basis of encapsulation. Each object has an interface that dictates how it can be interacted with.
CLASS c1 DEFINITION.
PUBLIC SECTION.
DATA: a1 ... " Public attributes visible outside the class.
METHODS: m1 ... " Public methods accessible from outside.
EVENTS: e1 ... " Public events for outside interaction.
PROTECTED SECTION.
DATA: a2 ... " Protected attributes visible to subclasses.
METHODS: m2 ... " Protected methods accessible to subclasses.
EVENTS: e2 ... " Protected events for subclass interaction.
PRIVATE SECTION.
DATA: a3 ... " Private attributes, invisible outside the class.
METHODS: m3 ... " Private methods, not accessible from outside.
EVENTS: e3 ... " Private events, only within the class.
ENDCLASS.
When defining a class, it's crucial to design public components thoughtfully, aiming to declare as few as possible. Once public components of global classes are released, they cannot be changed. It's like setting the rules for how others can interact with your object.
For instance, public attributes are visible externally and form part of the interface between an object and its users. If we want to completely encapsulate an object's state, we shouldn't declare any public attributes. Additionally, besides defining attribute visibility, we can protect them from changes using the READ-ONLY addition.
Inheritance
Inheritance is the property that allows a class to inherit the properties and methods of another class. It's like passing down traits from parent to child.
Inheritance enables the creation of a new class based on an existing one, with the new class inheriting the properties of the existing class. This is done by adding the INHERITING FROM addition to the class definition statement.
CLASS subclass DEFINITION INHERITING FROM superclass.
The new class "subclass" inherits all components of the existing class "superclass."
If no declarations are added to the subclass, it contains the same components as the superclass. However, only the public and protected components of the superclass are visible to the subclass. Although the private components of the superclass exist in the subclass, they are not visible.
Each class operates with its own private components. Methods that a subclass inherits from a superclass utilize the private attributes of the superclass and don't use any private component of the subclass with the same name.
CLASS vehicle DEFINITION.
PUBLIC SECTION.
METHODS: increase_speed,
decrease_speed.
PROTECTED SECTION.
DATA km TYPE i.
ENDCLASS.
CLASS vehicle IMPLEMENTATION.
METHOD increase_speed.
ADD 10 TO km.
ENDMETHOD.
METHOD decrease_speed.
SUBTRACT 10 FROM km.
ENDMETHOD.
ENDCLASS.
***THE BICYCLE CLASS inherits from the VEHICLE CLASS
CLASS bicycle DEFINITION INHERITING FROM vehicle.
PUBLIC SECTION.
DATA tire_wear(5) TYPE c.
ENDCLASS.
In this example, the BICYCLE class inherits properties and methods from the VEHICLE class. It's like saying, "A bicycle is a type of vehicle."
Specialization
Specialization is when a subclass inherits all the main characteristics of another class, the superclass. If we flip the perspective, where the superclass inherits characteristics of the subclass, we talk about generalization. If the superclass lacks a PRIVATE section, the subclass becomes an exact replica of the superclass. However, we can still add new components to the subclass, allowing it to become a specialized version of the superclass.
Types of Inheritance
There are two types of inheritance:
- Simple: A class can have multiple subclasses but only one superclass.
CLASS 1
!
---------------------------
! !
CLASS 2 CLASS 3
- Multiple: A class can inherit from several superclasses.
CLASS 1
!
CLASS 2
!
CLASS 3
When a subclass inherits from a superclass, which in turn inherits from another superclass, a tree structure is formed, increasing specialization with each added hierarchical level. Conversely, classes become more general until reaching the root node of the inheritance tree.
The root node of all inheritance trees in ABAP objects is the predefined empty class OBJECT, the most general of all classes possible.
Polymorphism
Polymorphism means that methods with the same name can behave differently in different classes. It's like different classes responding differently to the same message.
In other words, polymorphism allows an object of one class to behave like an object of any of its subclasses, depending on how methods of that class or subclasses are called.
CLASS counter DEFINITION.
PUBLIC SECTION.
METHODS: set IMPORTING VALUE(set_value) TYPE i,
increment,
get EXPORTING VALUE(get_value) TYPE i.
PROTECTED SECTION.
DATA count TYPE i.
ENDCLASS.
CLASS counter IMPLEMENTATION.
METHOD set.
count = set_value.
ENDMETHOD.
METHOD increment.
ADD 1 TO count.
ENDMETHOD.
METHOD get.
get_value = count.
ENDMETHOD.
ENDCLASS.
CLASS counter_ten DEFINITION INHERITING FROM counter.
PUBLIC SECTION.
METHODS increment REDEFINITION.
DATA count_ten(1) TYPE c.
ENDCLASS.
Polymorphism allows methods to respond differently based on the context of the class. It's like saying, "Different vehicles have different ways of accelerating."
In conclusion, these principles lay the foundation for robust and flexible ABAP programming, offering ways to structure and manage code effectively. They provide powerful tools for building complex systems while maintaining clarity and modularity.
Escanear / Compartir
Sobre el autor
Publicación académica de Jaime Eduardo Gomez Arango, en su ámbito de estudios para la Carrera Consultor ABAP Nivel Avanzado.
SAP Expert
Jaime Eduardo Gomez Arango
Profesión: Ingeniero de Sistemas y Computación - España - Legajo: SW34C
✒️Autor de: 149 Publicaciones Académicas
🎓Egresado de los módulos:
- Carrera Consultor SAP BTP Fiori
- Carrera Consultor ABAP Nivel Avanzado
- Carrera Consultor ABAP Nivel Inicial
Disponibilidad Laboral: FullTime
Presentación:
Ingeniero de sistemas y computación con 8 años de experiencia el desarrollo frontend & backend (react/node) y en cloud (aws), actualmente desarrollando habilidades en sap btp, ui5, abap y fiori.
Certificación Académica de Jaime Gomez
