|
Term
|
Meaning
|
|
Class
|
Provides the definition of a type, which represents the state and behavior for instances of the class (objects). A class can define members, including data members and properties (representing the state), and methods and events (representing the behavior) for any object belonging to the class. A class can be abstract, in which case it can define abstract members, including properties, methods, or events, that must be implemented by a derived class. An abstract class member is defined only by a name, data type, and signature as appropriate for each abstract method, property, or event, but no implementation.
|
|
Class hierarchy
|
The set of classes that make up the class definition. The hierarchy includes all classes in the inheritance chain as well as any implemented interfaces.
|
|
Delegation
|
A design technique where one class (referred to as the container) accesses the public interface of another class (referred to as the delegate). Normally, the container class uses the capabilities of the delegate class by delegating work to it. The container class then defines its own public interface to allow other classes outside the container class to access the delegate class's capabilities.
|
|
Derived class
|
See Subclass.
|
|
Encapsulation
|
Refers to the design and creation of self-contained and purposed components that are implemented as classes. Because a well-designed class strictly controls access to its state and behavior without revealing its implementation, it supports information hiding (encapsulation) to protect that state and behavior. Thus, encapsulation allows the implementation of an object’s behavior to change without affecting any caller that invokes that behavior in the object.
|
|
Inheritance
|
The mechanism through which new classes (or types) can be derived from existing classes or types. The relationship of subclass and super class is established by inheritance. The subclass inherits the PUBLIC and PROTECTED data members, properties, methods, and events from the super class. The subclass can then provide its own implementation of inherited methods (see ), and it can also add additional data members, properties, methods, and events of its own. Inheritance can thus be viewed as a specialization mechanism. If the super class is abstract, any abstract properties, methods, or events that it defines must also be implemented by a subclass. The hierarchy that is established when one class inherits from another treats the classes in the hierarchy as a single unit. From outside the class, you cannot tell whether the class's state and behavior are defined directly in the class or inherited from a super class. The class that you actually instantiate becomes the bottom (most derived subclass) of its class hierarchy in the running class instance.An interface can inherit member prototypes from one or more other interfaces. The interface that inherits member prototypes is the subinterface and the interface from which the member prototypes are inherited is the super interface. The inheriting interface effectively combines all inherited super interface member prototypes together with its own member prototypes as members of a single interface. Interface inheritance has no effect on class inheritance, but it requires that any class that implements an interface to implement all interfaces that the interface inherits. The member prototypes defined or inherited by an interface that a given class implements can be implemented by any class or classes in the given class inheritance hierarchy.
|
|
Interface
|
Provides the definition of a type that specifies a contract consisting of one or more properties, methods, and events that must be defined by any class that implements the interface. An interface assures a common way for accessing functionality that might differ from one class to the next depending on its implementation. All properties, methods, and events in an interface are abstract, meaning that the interface provides only a name and signature definition (prototype) for each property, method, and event, but no implementation.
|
|
Member
|
Class definition:An element of a class definition that defines its state or behavior. Depending on its definition, a member of a class can be inherited by other classes (subclasses) or accessed from contexts outside the defining class hierarchy. Members of a class can include data members, properties, methods, and events. All other components of a class definition support the definition or function of these class members.Interface definition:An element of an interface definition that defines a prototype for state or behavior that a class must implement. Members of an interface can include prototypes for properties, methods, and events, which the interface can define or inherit from other interfaces (super interfaces). All other components of an interface definition support the member prototypes that it defines.
|
|
Message
|
A communication with an instance of a class (object) that identifies specific behavior to invoke in that class. One way to communicate with (send a message to) an object is to invoke a method on the object that is defined by the object’s type.
|
|
Method overloading
|
Defining a method in a class that has the same name as, but a different signature than, another method defined in or inherited by the class. It provides a means to conserve method names, where you might specify related but different behavior for each method defined with the same name.
|
|
Method overriding
|
Defining a method in a class that has the same name, signature, and return type of a non-private method defined in its class hierarchy. An overriding method can access the overridden method in a super class in order to extend that super class’s behavior. Method overriding is used to implement a powerful type of polymorphism.
|
|
Object
|
For classes, an instance of a class with state (represented by its data members and properties) and behavior (implemented by its methods). For procedures, an instance of a persistent procedure (procedure object). Also, an instance of an ABL data, visual, or other element (such as a procedure or socket object) that can be referenced by a handle (handle-based object), and an instance of an ActiveX control (COM object) as supported in ABL.
|
|
Object reference
|
A value that provides access to an instance of a class and its public members. An object reference is strongly typed and can be stored in an ABL data element, such as a data member or property of a class or a variable in a method, procedure, or user-defined function.
|
|
Polymorphism
|
A mechanism where by a method can be implemented or overridden in different ways by different subclasses of a super class. Any reference to the method on a super class object reference, or within the class hierarchy of the object, invokes the most derived version of the method, that is, the version of the method defined in the most derived subclass in the class hierarchy of the object. This ability to provide multiple behaviors for a method by allowing different implementations in different subclasses and, accessing the different subclass implementations through the super class, is called polymorphism—hence poly- (many) morphism (forms).
|
|
Root class
|
The super class for all classes that do not explicitly inherit from some other class. In ABL, the root class is the built-in class, Progress.Lang.Object. For more information, see Using the root class: Progress.Lang.Object.
|
|
Super class
|
A class that is inherited by another class. A super class is also called a base class. The top-most super class in a given class hierarchy is the root class (Progress.Lang.Object in ABL).
|
|
Subclass
|
A class that inherits behavior from another class (a super class) in its class hierarchy. A subclass has access to all of the non-private state and behavior in its super class hierarchy. A subclass is also called a derived class, and the bottom-most subclass in a given class hierarchy is called the most derived class (or subclass).
|
|
Subinterface
|
An interface that inherits member prototypes from one or more other super interfaces. Inherited members must be implemented by a class as if they were defined directly by the subinterface that the class implements.
|
|
Super interface
|
An interface whose member prototypes are inherited by another interface.
|
|
Type
|
Specifies the structure and semantics of an object, but not its implementation. Types are used to enforce strong typing, and an object type is identified by a name and the interface to its members. The implementation of an object, however, is defined by the behavior of its class members.
|