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

Define state in a class

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
    • Garbage collection
      • 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 properties 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
    • Use the safe navigation operator (?:)
    • 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
    • Generics concepts and terminology in object-oriented ABL
    • Collections in object-oriented ABL
      • List collections in object-oriented ABL
      • Sorted set collections in object-oriented ABL
      • Hash map collections in object-oriented ABL
  • 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 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

Define state in a class

Save PDF
Save selected topicSave selected topic and subtopicsSave all topics
Share
Share to emailCopy topic URL
Print
  • Last Updated: January 16, 2024
  • 1 minute read
    • OpenEdge
    • Version 12.8
    • Documentation

Data can exist in the following forms within a class:

  • Data members of the class
  • Properties of a class
  • ABL widgets, streams, and work tables that are referenced by class members
  • Local variables of a method within the class
Contents
  • Data members and properties
  • Class-scoped handle-based objects
  • Local variables and other data elements of methods
TitleResults for “How to create a CRG?”Also Available inAlert