Object Oriented Programming Glossary

A

Abstract Class

A class that has no instances. An abstract class is written with the expectation that its concrete subclasses will add to its structure and behavior, typically by implementing its abstract operations.

Abstract Operation

An operation that is declared but not implemented by an abstract class. In C++, an abstract operation is declared as a pure virtual member function.

Abstraction

The essential characteristics of an object that distinguishes it from all other kinds of objects and thus provide crisply-defined conceptual boundaries relative to the perspective of the viewer; the process of focusing upon the essential characteristics of an object. Abstraction is one of the fundamental elements of the object model.

Access Control

The mechanism for control of access to the structure or behavior of a class. Public items are accessible by all; protected items are accessible only by the subclasses, implementation, and friends of the class containing the item; private items are accessible only by the implementation and friends of the class containing the item; implementation items are accessible only by the implementation of the class containing the item.

Action

An operation that, for all practical purposes, takes zero time. An action may denote the invocation of a method, the triggering of another event, or the starting or stopping of an activity.

Active Object

An object that encompasses its own thread of control.

Activity

An operation that takes some time to complete.

Actor

An object that can operate upon other objects but is never operated upon by other objects. In some contexts, the terms active object and actor are interchangeable.

Agent

An object that can both operate upon other objects and be operated upon by other objects. An agent is usually created to do some work on behalf of an actor or another agent.

Aggregate Object

An object composed of one or more other objects, each of which is consider a part of the aggregate object.

Algorithmic Decomposition

The process of breaking a system into parts, each of which represents some small step in a larger process. The application of structured design methods leads to an algorithmic decomposition, whose focus is upon the flow of control within a system.

Architecture

The logical and physical structure of a system, forged by all the strategic and tactical design decisions applied during development.

Assertion

The Boolean expression of some condition whose truth must be preserved.

Association

A relationship denoting a semantic connection between two classes.

Attribute

A part of an aggregate object.

B

Base Class

The most generalized class in a class structure. Most applications have many such root classes. Some languages define a primitive base class, which serves as the ultimate superclass of all classes.

Behavior

How an object acts and reacts, in terms of its state changes and message passing; the outwardly visible and testable activity of an object.

Blocking Object

A passive object whose semantics are guaranteed in the presence of multiple threads of control. Invoking an operation of a blocking object blocks the client for the duration of the operation.

C

Cardinality

The number of instances that a class may have; the number of instances that participate in a class relationship.

CASE (Computer Assisted Software Engineering) Tool

A CASE tool is any program which provides a programmer with additional means of designing and/or analyzing the structure of their program. Traditionally, these are programs which provide a interactive graphical representation of a programs object structure.

Class

A set of objects that share a common structure and a common behavior. The terms class and type are usually (but not always) interchangeable; a class is a slightly different concept that a type, in that it emphasizes the classifications of structure and behavior.

Class Category

A logical collection of classes, some of which are visible to other class categories, and other of which are hidden. The class in a class category collaborate to provide a set of services.

Class Diagram

Part of the notation of object-oriented design, used to show the existence of classes and their relationships in the logical design of a system. A class diagram may represent all or part of the class structure of a system.

Class Operation

An operation, such as a constructor or destructor, directed at a class rather than an object.

Class Structure

A graph whose vertices represent classes and whose arcs represent relationships among these classes. The class structure of a system is represented by a set of class diagrams.

Class Utility

A collection of free subprograms or, in C++, a class that only provides static members and/or static member functions.

Class Variable

Part of the state of a class. Collectively, the class variable of a class constitute its structure. A Class variable is shared by all instances of the same class. In C++, a class variable is declared as a static member.

Client

An object that uses the services of another object, either by operation upon it or by referencing its state.

Collaboration

The process whereby several objects cooperate to provide some high-level behavior.

Concrete Class

A class whose implementation is complete and thus may have instances.

Concurrency

The property that distinguishes an active object from one that is not active.

Concurrent Object

An active object whose semantics are guaranteed in the presence of multiple threads of control.

Constraint

The expression of some semantic condition that must be preserved.

Constructor

An operation that creates an object and/or initializes its state.

Container Class

A class whose instances are collections of other objects. Container classes may denote homogeneous collections (all of the objects in the collections are of the same class) or heterogeneous collections (each of the objects in the collections may be of a different class, although all must generally share a common superclass). Container classes are most often defined as parameterized classes, with some parameter designating the class of the contained objects.

CRC Cards

Class/Responsibilities/Collaborators; a simple tools for brainstorming about the key abstractions and mechanisms in a system.

D

Data Dictionary

A comprehensive repository enumerating all the classes in a system.

Delegation

The actor of one object forwarding an operation to another object, to be performed on behalf of the first object.

Destructor

An operation that frees the state of an object and/or destroys the object itself.

Device

A piece of hardware that has no computational resources.

Dynamic Binding

Binding denotes the association of a name (such as a variable declaration) with a class; dynamic binding is a binding in which the name/class association is not made until the object designated by the name is created at execution time.

E

Encapsulation

The process of compartmentalizing the elements of an abstraction that constitute its structure and behavior; encapsulation serves to separate the contractual interface of an abstraction and its implementation.

Event

Some occurrence that may cause the state of a system to change.

Exception

An indication that some invariant has not or cannot be satisfied. In C++, we throw an exception to abandon processing and alert some other object of the problem, which in turn may catch the exception and handle the problem.

F

Field

A repository for part of the state of an object; collectively, the fields of an object constitute its structure. The terms field, instance variable, member object, and slot are interchangeable.

Forward-Engineering

The production of executable code from a logical or physical model.

Free Subprogram

A procedure of function that serves as a nonprimitive operation upon an object or objects of the same or different classes. A free subprogram is any subprogram that is not a method of an object.

Framework

A collection of classes that provide a set of services for a particular domain; a framework thus exports a number of individual classes and mechanisms that clients can use or adapt.

Friend

A class or operation whose implementation may reference the private parts of another class, who alone can extend the offer of friendship.

Function

An input/output mapping resulting from some object's behavior.

Function Point

In the context of a requirements analysis, a single, outwardly visible and testable activity.

G

Generic Class

A class that serves as a template for other classes, in which the template may be parameterized by other classes, objects, and/or operations. A generic class must be instantiated (its parameters filled in) before objects can be created. Generic classes are typically used as container classes. The terms generic class and parameterized class are interchangeable.

Generic Function

An operation upon an object. A generic function of a class may be redefined in subclasses; thus, for a given object, it is implemented through a set of methods declared in various classes related via their inheritance hierarchy. The terms generic function and virtual function are usually interchangeable.

Guard

A Boolean expression applied to an event; if true, the expression permits the event to cause the state of the system to change.

H

Hierarchy

A ranking or ordering of abstractions. The two most common hierarchies in a complex system include its class structure (including "kind of" hierarchies) and its object structure (including "part of" and collaboration hierarchies); hierarchies may also be found in the module and process architectures of a complex system.

I

Identity

The nature of an object that distinguishes it form all other objects

Idiom

An expression peculiar to a certain programming language or application culture, representing a generally accepted convention for use of the language.

Implementation

The inside view of a class, object, or module, including the secrets of its behavior.

Information Hiding

The process of hiding all the secrets of an object that do not contribute to its essential characteristics; typically, the structure of an object is hidden, as well as the implementation of its methods.

Inheritance

A relationship among classes, wherein one class shares the structure or behavior defined in one (single inheritance) or more (multiple inheritance) other classes. Inheritance defines an "is-a" hierarchy among classes in which a subclass inherits from one or more generalized superclasses; a subclass typically specializes its superclasses by augmenting or redefining existing structure and behavior.

Instance

Something you can do things to. An instance has state, behavior, and identity. The structure and behavior of similar instances are defined in their common class. The terms instance and object are interchangeable.

Instance Variable

A repository for part of the state of an object. Collectively, the instance variable of an object constitute its structures. The terms field, instance variable, member object, and slot are interchangeable.

Instantiation

The process of filling in the template of a generic or parameterized class to produce a class from which one can create instances.

Interaction Diagram

Part of the notation of object-oriented design, used to show the execution of a scenario in the context of an object diagram.

Interface

The outside view of a class, object, or module, which emphasizes its abstraction while hiding its structure and the secrets of its behavior.

Invariant

The boolean expression of some conditions whose truth must be preserved.

Iterator

An operation that permits the parts of an object to be visited.

J

K

Key

An attribute whose value uniquely identifies a single target object.

Key Abstraction

A class or object that forms part of the vocabulary of the problem domain.

L

Layer

The collection of class categories or subsystems at the same level of abstraction.

Level of Abstraction

The relative ranking of abstractions in a class structure, object structure, module architecture, or process architecture. In terms of its "part of" hierarchy, a given abstraction is at a higher level of abstraction than other if it builds upon the others; in terms of their "kind of" hierarchy, high-level abstractions are generalized, and low-level abstractions are specialized.

Link

Between two objects, one instance of an association.

M

Mechanism

A structure whereby objects collaborate to provide some behavior that satisfies a requirement of the problem.

Member Function

An operation upon an object, defined as part of the declaration of a class; all member functions are operations, but not all operations are member functions. The terms member function and method are usually interchangeable. In some languages, a member function stands alone and may be redefined in a subclass; in other languages, a member function may not be redefined, but serves as part of the implementation of a generic function or virtual function, both of which may be redefined in a subclass.

Member Object

A repository for part of the state of an object; collectively, the member objects of an object constitute its structure. The terms field, instance variable, member object, a slot are interchangeable.

Message

An operation that one object performs upon another. The terms message, method, and operation are usually interchangeable.

Metaclass

The class of a class; a class whose instances are themselves classes.

Method

An operation upon an object, defined as part of the declaration of a class; all methods are operations, but not all operations are methods, The terms message, method and operation are usually interchangeable. In some languages, a method stands alone and may be redefined in a subclass; in other languages, an method may mot be redefined, but serves as part of the implementation of a generic function or a virtual function, both of which may be redefined in a subclass.

Mixin

A class that embodies a single , focused behavior, used to augment the behavior of some other class via inheritance; the behavior of a mixin is usually orthogonal to the behavior of the classes with which it is combined.

Modularity

The property of a system that has been decomposed into a set of cohesive and loosely coupled modules.

Module

A unit of code that serves as a building block for the physical structure of a system; a program unit that contains declarations, expressed in the vocabulary of a particular programming language, that form the physical realization of some or all of the classes and objects in the logical design of the system. A module typically has two parts: its interface and its implementation.

Module Architecture

A graph whose vertices represent modules and whose arcs represent relationships among these modules. The module architecture of a system is represented by a set of module diagrams.

Module Diagram

Part of the notation of object-oriented design, used to show the allocation of classes and objects to modules in the physical design of a system. A module diagram may represent all or part of the module architecture of a system.

Monomorphism

A concept in type theory, according to which a name (such as a variable declaration) may only denote objects of the same class.

N

O

Object

Something you can do things to. An object has state, behavior, and identity; the structure and behavior of similar objects are defined in their common class. The terms instance and object are interchangeable.

Object Diagram

Part of the notation of object-oriented design, used to show the existence of objects and their relationships in the logical design of a system. An object diagram may represent all or part of the object structure of system, and primarily illustrates the semantics of mechanisms in the logical design. A single object diagram represents a snapshot in time of an otherwise transitory event of configurations of objects.

Object Model

The collection of principles that form the foundation of object-oriented design; a software engineering paradigm emphasizing the principles of abstraction, encapsulation, modularity, hierarchy, typing, concurrency, and persistence.

Object Structure

A graph whose vertices represent objects and whose arcs represent relationships among those objects. The object structure of a system is represented by a set of object diagrams.

Object-Based Programming

A method of programming in which programs are organized as cooperative collections of objects, each of which represents an instance of some type, and whose types are all members of a hierarchy of types united via other than inheritance relationships. In such programs, types are generally viewed as static, whereas objects typically have a much more dynamic nature, somewhat constrained by the existence of static binding and monomorphism.

Object-Oriented Analysis

A method of analysis in which requirements are examined form the perspective of the class and objects found in the vocabulary of the problem domain.

Object-Oriented Decomposition

The process of breaking a system into parts, each of which represents some class or object from the problem domain. The application of object-oriented design methods leads to an object-oriented decomposition, in which we view the world as a collection of objects that cooperate with one another to achieve some desired functionality.

Object-Oriented Design

A method of design encompassing the process of object-oriented decomposition and a notation for depicting both logical and physical as well as static and dynamic models of the system under design; specifically, this notation includes class diagrams, object diagrams, module diagrams, and process diagrams.

Object-Oriented Programming

A method of implementation in which programs are organized as cooperative collections of objects, each of which represents an instance of some class, and whose classes are all members of a hierarchy of classes united via inheritance relationships. In such programs, classes are generally viewed as static, whereas objects typically have a much more dynamic nature, which is encouraged by the existence of dynamic binding and polymorphism.

Operation

Some work that one object performs upon another in order to elicit a reaction. All of the operations upon a specific object may be found in free subprograms and member functions or methods, The terms message, method, and operation are usually interchangeable.

P

Parameterized Class

A class that serves a a template for other classes, in which the template may be parameterized by other classes, objects, and/or operations. A parameterized class must be instantiated (its parameters filled in) before instances can be created. Parameterized classes are typically used as container classes; the terms generic class and parameterized class are interchangeable.

Partition

The class categories or subsystems that form a part of a given level of abstraction.

Passive Object

An object that does not encompass its own thread of control.

Persistence

The property of an object by which its existence transcends time(i.e., the object continues to exist after its creator ceases to exists) and/or space (i.e., the object's locations moves from the address space in which it was created).

Polymorphism

A concept in type theory, according to which a name (such as a variable declaration) may denote objects of many different classes that are related by some common superclass; thus, any object denoted by this name is able to respond to some common set of operations in different ways.

Postcondition

An invariant satisfied by an operation.

Precondition

An invariant assumed by an operation.

Private

A declaration that forms part of the interface of a class, object, or module; what is declared as private is not visible to any other classes, objects, or modules.

Process

The activation of a single thread of control.

Process Architecture

A graph whose vertices represent processors and devices and whose arcs represent connections among these processors and devices. The process architecture of a system is represented by a set of process diagrams.

Process Diagram

Part of the notation of object-oriented design, used to show the allocation of processes to processors in the physical design of a system. A process diagram may represent all or part of the process architecture of a system.

Processor

A piece of hardware that has computation resources.

Protected

A declaration that forms part of the interface of a class, object, or module, but that is not visible to any other classes, objects, or modules except those that represent subclasses.

Protocol

The ways in which an object may act and react, constituting the entire static and dynamic outside view of the object; the protocol of an object defines the envelope of the object's allowable behavior.

Public

A declaration that forms part of the interface of a class, object, or module, and that is visible to all other classes, objects, and modules that have visibility to it.

Q

R

Reactive System

An event-driven system; the behavior of a reactive system is not a simple input/out mapping.

Real-Time System

A system whose essential processes must meet certain critical time deadlines. A hard-real-time system must be deterministic; missing a deadline may lead to catastrophic results.

Responsibility

Some behavior for which an object is held accountable; a responsibility denotes the obligation of an object to provide a certain behavior.

Reverse-Engineering

The production of a logical or physical model from executable code.

Role

The purpose or capacity wherein one class or object participates in a relationship with another; the role of an object denotes the selection of a set of behaviors that are well-defined at a single point in time; a role is the face an object presents to the world at a given moment.

Round-Trip Gestalt Design

A style of design that emphasizes the incremental and iterative development of a system, through the refinement of different yet consistent logical and physical views of the system as a whole; the process of object-oriented design is guided by the concepts of round-trip gestalt design; round-trip gestalt design is a recognition of the fact that the big picture of a design affects its details, and that the details often affect the big picture.

S

Scenario

An outline of events that elicits some system behavior.

Selector

An operation that accesses the state of an object but does not alter that state.

Sequential Object

A passive object whose semantics are guaranteed only in the presence of a single thread of control.

Server

An object that never operates upon other objects, but is only operated upon by other objects; an object that provides certain services.

Service

The behavior provided by a given part of a system.

Signature

The complete profile of an operation's formal arguments and return type.

Slot

A repository for part of the state of an object; collectively, the slots of an object constitute its structure. The terms field, instance variable, member object, and slot are interchangeable.

Space Complexity

The relative or absolute time in which some operation completes.

State

The cumulative results of the behavior of an object; one of the possible conditions in which an object may exist, characterized by definite quantities that are distinct from other quantities; at any given point in time, the state of an object encompasses all of the (usually static) properties of the object plus the current (usually dynamic) values of each of these properties.

State Transition Diagram

Part of the notation of object-oriented design, used to show the state space of a given class, the events that cause a transition from one state to another, and the actions that result from a state change.

State Space

An enumeration of all the possible states of an object. The state space of an object encompasses an indefinite yet finite number of possible (although not always desirable not expected) states.

Static Binding

Binding denotes the association of a name (such as a variable declaration) with a class; static binding is a binding in which the name/class association is made when the name is declared (at compile time) but before the creation of the object that the name designates.

Strategic Design Decision

A design decision that has sweeping architectural implications.

Strongly Typed

A characteristic of a programming language, according to which all expressions are guaranteed to be type-consistent.

Structure

The concrete representation of the state of an object. An object does not share its state with any other object, although all objects of the same class do share the same representation of their state.

Structured Design

A method of design encompassing the process of algorithmic decomposition.

Subclass

A class that inherits from one of more classes (which are called its immediate superclasses).

Subsystem

A collection of modules, some of which are visible to other subsystems and others of which are hidden.

Superclass

The class from which another class inherits (which is called its immediate subclass).

Synchronization

The concurrency semantics of an operation. An operation may be simple (only one thread of control is involved), synchronous (two processes rendezvous), balking (one process may rendezvous with another only if the second process is already waiting), timeout (one process may rendezvous with another, but will wait or the second process only for a specified amount of time), or asynchronous (the two processes operate independently).

T

Tactical Design Decision

A design decision that has local architectural implications.

Thread of Control

A single process. The start of a thread of control is the root from which independent dynamic action within a system occurs; a given system may have many simultaneous thread of control, some of which may dynamically come into existence and then cease to exist. Systems executing across multiple CPU's allow for truly concurrent threads of control, whereas systems running on a single CPU can only achieve the illusion of concurrent threads of control.

Time Complexity

The relative or absolute space consumed by an object.

Transformational System

A system whose behavior is an input/output mapping.

Transition

The passing from one state to another state.

Type

The definition of the domain of allowable values that an object may possess and the set of operations that may be performed upon the object. The terms class and type are usually (but not always) interchangeable; a type is a slightly different concept than a class, in that it emphasizes the importance of conformance to a common protocol.

Typing

The enforcement of the class of an object, which prevents objects of different types from being interchanged or, at the most, allow them to be interchanged only in very restricted ways.

U

Use

To reference the outside view of an abstraction.

V

Virtual Function

An operation upon an object. A virtual function may be redefined by subclasses; thus, for a given object, it is implemented through a set of methods declared in various classes that are related via their inheritance hierarchy. The terms generic function and virtual function are usually interchangeable.

Visibility

The ability of one abstraction to see another and thus reference resources in its outside view. Abstractions are visible to one another only where their scopes overlap. Export control may further restrict access to visible abstractions.

W

X

Y

Z