Skip to main contentSkip to search
Powered by Zoomin Software. For more details please contactZoomin
Progress DocumentationProgress Documentation
Progress Documentation
  • Home
  • Home
  • EnglishČeštinaDeutsch (Germany)Español (Spain)FrançaisItaliano (Italy)Português (Brasil)日本語Русский (Russia)中文 (简体) (China)中文 (繁體, 台灣) (Taiwan)ar-AR
  • Login

Develop Object-oriented ABL Applications

Design objects: inheritance, polymorphism, and delegation

Save PDF
Save selected topicSave selected topic and subtopicsSave all topics
Share
Share to emailCopy topic URL
Print
Table of Contents
  • Object-oriented programming and ABL
    • Support for classes in ABL
      • Advantages of ABL classes
      • Foundations of ABL classes
    • Programming models in ABL
      • Procedure-based model
      • Class-based model
      • Compare procedure-based with class-based models
    • Overview of object-oriented programming
      • Encapsulation
        • Comparison with procedure-based programming encapsulation
      • Inheritance
        • Comparison with procedure-based programming inheritance
      • Delegation
        • Comparison with procedure-based programming delegation
      • Polymorphism
      • Method overloading
      • Strong typing
        • Comparison with procedure-based programming complie time validation
      • Glossary of terms
    • Overview of class-based ABL
      • Define classes
        • Comparison with procedure-based programming file structure
      • Define methods
        • Comparison with procedure-based programming internal procedures and user-defined functions
      • Define data members
        • Comparison with procedure-based programming data elements
      • Define properties
        • Comparison with procedure-based programming user-defined functions
      • Define class events
        • Comparison with procedure-based programming named events
      • Define constructors
        • Comparison with procedure-based programming main block
      • Define the destructor
        • Comparison with procedure-based persistent procedures
      • Define interfaces
        • Comparison with procedure-based programming persistent procedures
      • Use object types
      • Specify unqualified class or interface type names
      • Create and destroy a class instance
        • Comparison with procedure-based programming persistent procedures
      • Invoke methods
        • Comparison with procedure-based programming invoking internal procedures
      • Access data members and properties
        • Comparison with procedure-based programming shared variables
      • Publish and respond to class events
        • Comparison with procedure-based programming PUBLISH and SUBSCRIBE
      • Supporting ABL
      • General comparison with procedure-based programming
    • Programming conventions for classes
  • Get started with classes, interfaces, and objects
    • Class definition files and object type names
      • Class definition file structure
      • Define and reference object type names
        • Valid and invalid object type name references
        • Use object type names to locate type definitions in PROPATH
      • Reference an object type name without its package
      • Compare class definition files and procedure source files
    • Define classes
      • Define state in a class
        • Data members and properties
        • Class-scoped handle-based objects
        • Local variables and other data elements of methods
      • Define behavior in a class
        • Methods of a class
        • Events of a class
      • Define classes based on other classes
    • Use the CLASS construct
      • Define data members within a class
        • Comparison with procedure-based programming variables and data elements
      • Define properties within a class
        • DEFINE PROPERTY statement
        • Comparison with procedure-based programming user-defined functions
      • Define methods within a class
        • METHOD statement
      • Define events within a class
        • DEFINE EVENT statement
        • Comparison with procedure-based programming named events
      • Namespaces for class members
        • Tables
        • Fields
        • Abbreviations
        • Static class members
      • Define class constructors
        • CONSTRUCTOR statement
        • Comparison with procedure-based programming main blocks of persistent procedures
      • Define the class destructor
        • DESTRUCTOR statement
        • Comparison with procedure-based programming cleanup
      • Define class-scoped handle-based objects
      • Use the root class: Progress.Lang.Object
    • Define interfaces
    • Use the INTERFACE construct
      • INTERFACE statement
      • Use an interface definition
    • Manage the object life-cycle
      • DELETE OBJECT statement
  • Design objects: inheritance, polymorphism, and delegation
    • Class hierarchies and inheritance
      • Classes and strong typing
      • Class hierarchies and procedure hierarchies
        • Comparison with procedure-based programming super procedures
      • Method scoping within a class hierarchy
        • Comparison with procedure-based programming internal procedures and functions
      • Data member and property scoping within a class hierarchy
        • Comparison with procedure-based programming variables
      • Event scoping within a class hierarchy
        • Comparison with procedure-based programming PUBLIC and PRIVATE events
      • Override data within a class hierarchy
      • Override methods within a class hierarchy
      • Override class events within a class hierarchy
      • Overload methods and constructors
        • Define overloaded methods and constructors
        • Invoke overloaded methods and constructors
      • Construct an object
        • SUPER statement
        • THIS-OBJECT statement
      • Call up the class hierarchy
        • SUPER system reference
        • THIS-OBJECT system reference
      • Delete an object
    • Interface hierarchies and inheritance
      • Multiple interfaces in a hierarchy
      • Duplicate members in a hierarchy
      • Use interface hierarchies
    • Use polymorphism with classes
    • Use delegation with classes
      • Comparison with procedure-based programming compile time checking
  • Program with class-based objects
    • Instantiate and manage class-based objects
      • Define an object reference variable or property
      • Create a class instance
        • NEW and DYNAMIC-NEW statements
        • New( ) method
      • Call class-based methods
        • Call methods from inside a class hierarchy where they are defined
        • Call instance methods from outside a class hierarchy where they are defined
        • Dynamically invoke a method at run time
        • Comparison with procedure-based programming user-defined functions
      • Call an overloaded method or constructor
      • Access data members and properties
        • Reference a public data member or property outside of the object that defines it
      • Dynamically access a property at runtime
      • Define an object reference parameter
      • Pass object reference parameters
      • Define an object reference return type
      • Define an object reference field in a temp-table
      • Publish and subscribe to class events
        • Specify handler subscriptions for class events
        • Publish class events
    • Verify the type and validity of an object reference
      • VALID-OBJECT function
      • TYPE-OF function
    • Use built-in system and object reference elements
      • THIS-OBJECT system reference
      • SUPER system reference
      • ABL session object reference attributes
    • Assign object references
      • Object reference assignment and casting
      • Use the CAST function
        • Casting an object reference assignment
        • Casting an object reference parameter
        • Casting an object reference to invoke a method
      • Use the DYNAMIC-CAST function
    • Compare objects
    • Use static members of a class
      • Static member scoping
      • Access static members
        • Options for referencing static members
        • Use static type-name syntax
        • Access static members from outside the defining class
        • Access static members from inside the defining class
        • Call static methods from inside the defining class
        • Call overridden and super-class static methods
        • Call overloaded static methods
        • Access static and instance events and event handlers
      • Define static members
        • Define a static constructor
        • Define static method overrides and overloadings
      • Initialize and delete static members
      • Common use case for static members
      • Static type-name syntax and naming conflicts
    • Define and use widgets in classes
    • Use preprocessor features in a class
      • Use compile-time arguments
      • Use preprocessor names and directives
    • Raise and handle error conditions
      • Structured and traditional error handling
      • Raise errors within a method
        • Method error handling example
      • Raise errors within a class event handler
      • Raise errors within a property
        • Raise errors in a GET accessor
        • Raise errors in a SET accessor
        • Property error handling example
      • Raise errors within an instance constructor
        • Handle instance constructor errors
        • Instance constructor error handling example
      • Raise errors within a static constructor
      • Raise errors within a destructor
    • Reflection
      • Use the Progress.Lang.Class class
        • Get a Progress.Lang.Class instance
        • Use Progress.Lang.Class properties and methods
    • Use the Progress.Lang.ParameterList class
      • Get and use a Progress.Lang.ParameterList instance
      • Use Progress.Lang.ParameterList methods and properties
    • Identify classes in the Progress.Reflect package
    • Serialization and deserialization
      • Serialize an instance to file
      • Deserialize from a file
  • Program with class-based and procedure objects
    • Class-based and procedure object compatibility
      • Compatibility rules
      • Invalid ABL within a user-defined class
      • Verify the source for an r-code file at run time
    • Compare handles and object references
      • Use handles
      • Use object references
    • Use handle-based object events in classes
      • ON statement
      • SET-CALLBACK( ) method
    • Use widget pools
    • Reference routines on the call stack
    • Compare constructs in classes and procedures
    • Sample classes
    • Comparative procedures
    • Summary comparison of classes and procedures
  • Develop and deploy classes
    • Access class definition files in the Procedure Editor
      • Save and open class definition files
      • Check and run a class from the Procedure Editor
        • Check Syntax option
        • Run option
    • Access class definition files in Progress Developer Studio for OpenEdge
      • Syntax check, compile, and run a class
    • Compile class definition files
      • Protocol for class hierarchy and references
      • Match data types
      • Use the COMPILER system handle
        • MULTI-COMPILE attribute
        • CLASS-TYPE attribute
        • NUM-MESSAGES attribute
        • GET-MESSAGE(n) method
        • GET-NUMBER(n) method
        • GET-FILE-NAME(n) method
        • GET-ERROR-ROW(n) method
        • GET-ERROR-COLUMN(n) method
        • GET-FILE-OFFSET(n) method
    • Use procedure libraries
    • Use the XCODE utility
  • Overloaded method and constructor call scenarios
    • Parameter lists that differ only by mode
    • Parameter data types that differ only by extent
    • Parameters match widened data types
    • Match dynamic and static temp-table or ProDataSet parameters
    • Object reference parameters search the class hierarchy or the interface
    • Match the Unknown value to parameters
    • Match values of Unknown data types to parameters
Table of Contents

Design objects: inheritance, polymorphism, and delegation

Save PDF
Save selected topicSave selected topic and subtopicsSave all topics
Share
Share to emailCopy topic URL
Print
  • Last Updated: March 30, 2020
  • 1 minute read
    • OpenEdge
    • Version 12.2
    • Documentation

Other topics introduced the basic syntax that supports classes in ABL, this content provides more conceptual information on the structure and operation of class hierarchies, and shows how you might use classes in an application.

Contents
  • Class hierarchies and inheritance
  • Interface hierarchies and inheritance
  • Use polymorphism with classes
  • Use delegation with classes
TitleResults for “How to create a CRG?”Also Available inAlert