[Table of Contents]
[Previous]
[Object Central Home]
The Essence of Object-Oriented Programming
Copyright © 1998, Bruce E. Wampler
Part 1
Appendix
- abstraction
-
A model of a real-world object or concept.
- abstract class
-
A class that has no instances. It is usually defined with the
assumption that concrete subclasses will be derived from it,
and extend its basic attributes and behavior.
- actor
-
An actor is an object that can operate on other objects, but is never
operated on by other objects itself.
- agent
-
An agent can both operate on other objects and provide services to
other objects. As the name implies, it often serves as an agent or
intermediary between other objects.
- aggregation
-
A whole/part hierarchy.
An aggregate object includes (
has-a) other objects, each of
which is considered to be a part of (
part-of)the aggregate
object.
- base class
-
The most generalized class in an inheritance hierarchy. Most
applications will have many hierarchies with different base classes.
- behavior
-
The activity of an object that is visible from the outside. Include
how an object responds to messages by changing its internal state
or returning state information.
- class
-
A collection of objects that share common attributes and common behavior.
Class is similar in concept to type, but is more comprehensive in that
it includes both structure and behavior. A class definition describes
all the attributes of member objects of that class, as well as the
methods that implement the behavior of member objects.
- concrete class
-
A class that is completely specified and can have instances.
- container class
-
A class whose instances are collections of other objects. Container
classes can hold objects of either the same or mixed types. They
usually provide a method to iterate over each object in the container.
- constructor
-
An operation that creates an object and defines its initial state.
For complex objects, construction can be a very significant activity,
and cause the constructors of other objects to be invoked as
well.
- deep copy
-
Making a copy of an object that makes a duplicate of everything, including
allocating space to build new copies of anything pointed to by pointers.
- destructor
-
A destructor is an operation that destroys an object and frees whatever
resources the object used. It is invoked when an object ceases to
exist, such as when it goes out of scope.
- dynamic binding
-
Definition bound at run time.
- encapsulation
-
The process of hiding all the internal details of an object from
the outside world. In C++, encapsulation is enforced by
having the definitions for attributes and methods inside
a class definition.
- event
-
An occurrence that can alter the state of the system.
- friend
-
A friend class is one that has access to protected data even though
it is not a direct subclass of a given class. Friend access is often
needed to allow access in
has-a relationships.
- generalization/specialization
-
An inheritance hierarchy. Each subclass is a specialization of
a more generalized superclass.
- generic/parameterized classes
-
A class whose final definition is determined by parameters. One typical
use is to define container classes for arbitrary types of objects.
The type of the object is specified in the parameter. In C++, these
are called
templates.
- hierarchy
-
An ordering of classes. The most common OO hierarchies are
inheritance and aggregation.
- identity
-
The characteristics or state of an object that allows it to
be distinguished for other objects.
- inheritance
-
A mechanism that allows one class (
subclass) to share
the attributes and behaviors of another class (
superclass).
Inheritance defines an
is-a relationship between classes.
The subclass or derived class inherits the attributes
and behaviors of the superclass, and will usually extend
or modify those attributes and behaviors.
- single inheritance
-
When a subclass is derived from a single superclass, it
is said to have single inheritance.
- multiple inheritance
-
When a subclass is derived from multiple superclasses, it
is said to have single inheritance. Not all OO programming
languages allow multiple inheritance, but C++ does.
- instance
-
The same as an object. An instance is a member of a class,
exists, and has identity.
- instantiation
-
Creating an instance of an object of a given class. Instantiating
an instance brings it into existence.
- iterator
-
An iterator is a method used to access or visit each part
of an object. This allows the outside world controlled access to
all important parts of an object without the need to know the internal
implementation details of a specific object.
- member function
-
The C++ name for a method.
- method
-
An operation or service performed upon an object, defined as part
of the declaration of a class. Methods are used to implement object
behavior. Synonyms for method include
member function,
operation,
and
service.
- message
-
A message is an operation one object performs on another. Messages
are usually sent by invoking a specific
method or
operation
provided by another object.
- modifier
-
This is an operation that alters the state of an object.
- module
-
A module is a basic technique of organizing a program, and is usually
thought of as containing all the specific code and declarations needed
to implement a given part of a design. It is the basic unit of encapsulation.
In an OO design, usually each class is implemented as a separate
module, and encapsulates all the data structures and methods, and
controls access by the outside world.
- object
-
The basic thing of object orientation. An object is an entity
that has attributes, behavior, and identity. Objects are members
of a class, and the attributes and behavior of an object are
defined by the class definition.
- persistence
-
Some objects can thought of as persistent whose existence transcend
time. Persistent objects usually provide methods that save and restore
their own state (to disk, for example).
- polymorphism
-
Polymorphism is what allows the appropriate method for any
given object to be used automatically. Polymorphism goes hand in
hand with inheritance and classes derived from a common
superclass. In C++, polymorphism is supported through
virtual functions and dynamic binding.
- private, protected, public
-
Private, protected, and public are access concepts within a class.
Private data and methods are available only to instances of the immediate
class. Protected items are available to other classes directly derived
from the immediate class. Public items are available to the world.
It is usually best to keep all data items and structures private
or protected, and allow public access to a class only through public
methods.
- selector
-
This is an operation that gets information about the state of an
object without altering the state of the object.
[Table of Contents]
[Previous]
[Object Central Home]
Visits: