Object Orientation - OO Glossary
  
  abstract class - a class that is inherited from by other
  classes, but never has any objects instantiated
  
  abstraction - the isolation of attributes and functionality
  appropriate to a particular conceptual view
  
  access method - a method invoked when an attempt is made to
  read (get) the value of an instance variable
  
  ancestor class (or super class) - a class which another class
  has inherited from, either directly (a parent class) or indirectly
  
  assign method - a method invoked when an attempt is made to
  change (set) the value of an instance variable
  
  attribute - a characteristic, or property, of an object
  (typically an instance variable)
  
  base class - a class which does not inherit from any other
  class (except possibly an ultimate system class)
  
  binding - converting a message being sent to an object into
  the actual data or method to access
  
  calculated instance variable - an instance variable that is
  actually implemented by method(s).  In TopClass and VO there
  are two methods: one to get the value and one to set it
  
  child class - a class that inherits from another class (its parent)
  
  class - the definition of the data contained in an object,
  together with the operations available; used when an object is
  created (or instantiated)
  
  class hierarchy - the structure of classes which are inherited
  by or inherit from one another (often a tree)
  
  class interface - the messages that an object of the class
  would respond to (both instance variables and methods)
  
  class method - a method which operates on data shared by all
  objects of a class (i.e. class variables), and/or a method
  which can affect all existing objects of the class
  
  class tree - see inheritance tree
  
  class variable - an instance variable that is shared by all
  objects of the class
  
  composition - storing an object of one class in an instance
  variable of an object of a different class.  This is the same
  as saying that a class is built using one or more sub-parts
  which are themselves classes, or saying that an object
  contains other objects.
  
  constructor - the method invoked when an object of a class is
  being created/initialised
  
  deferred method - a method which is named but not implemented in a
  class, and which therefore needs to be implemented in a sub-class
  
  delegation - passing a message on to a different object, e.g.
  a composite object often delegates to one or other of the
  objects it contains
  
  delete - to remove an instance variable or method (in a class
  definition)
  
  derived class - see child class
  
  descendant - a child
  
  destructor - the method invoked when an object of a class is
  being destroyed
  
  early binding - binding done at compile time (not done in
  Clipper or TopClass)
  
  encapsulation (or information hiding) - allowing access to
  data and operations on it only through a defined interface
  which does not reveal the internal implementation
  
  exported (or public) - data and/or methods made available to
  class users
  
  hidden - an instance variable or method which is deleted
  automatically during inheritance (same as restricted)
  
  information hiding - see encapsulation
  
  inheritance - acquiring data and operations from another class
  
  instance variable - an item of data contained by an object
  
  instantiation - the creation of an object (using the class as
  a template)
  
  interface - the messages that an object of the class would
  respond to (both instance variables and methods)
  
  late binding - binding done at run-time (as in Clipper and TopClass)
  
  message - an operation understood by an object (causes a method
  to be invoked)
  
  method - a function used to implement a message (i.e. one of
  the operations an object responds to)
  
  multiple inheritance - inheriting from more than one class
  
  object - an instance of a class (i.e. exists as a separate
  data item, with space allocated for its instance variables)
  
  overloading - using the same operator or name for more than one
  type of data (e.g. "+" in Clipper works with numbers and strings)
  
  parent class (or super class) - a class that is inherited from
  
  persistent object - an object whose data exists independently of the
  current program (e.g. by being saved in a dBxStore/FlexFile file)
  
  polymorphism - using the same name in different classes, often
  with different implementation
  
  protected - an instance variable or method that can only be
  accessed by methods of the current object's class
  
  public - see exported
  
  read only - an instance variable which can be read but not changed
  
  renaming - changing the name of an instance variable or method
  (during a class definition)
  
  restricted - an instance variable or method which is deleted
  automatically during inheritance (same as hidden)
  
  self - the current object responding to a message
  
  send - the process of invoking a message understood by an object
  
  single inheritance - a class that inherits from only one class
  
  static binding - see early binding
  
  sub-class - a child class
  
  super: - indicates sending a message looked up in the parent
  of the current class (i.e. the search for the message starts
  in the super class, instead of starting the search in self's
  class)
  
  super class - a parent class