GNU Info

Info Node: (texinfo)Abstract Objects

(texinfo)Abstract Objects


Next: Data Types Prev: Typed Variables Up: Def Cmds in Detail
Enter node , (file) or (file)node

Object-Oriented Programming
---------------------------

  Here are the commands for formatting descriptions about abstract
objects, such as are used in object-oriented programming.  A class is a
defined type of abstract object.  An instance of a class is a
particular object that has the type of the class.  An instance variable
is a variable that belongs to the class but for which each instance has
its own value.

  In a definition, if the name of a class is truly a name defined in the
programming system for a class, then you should write an `@code' around
it.  Otherwise, it is printed in the usual text font.

`@defcv CATEGORY CLASS NAME'
     The `@defcv' command is the general definition command for
     variables associated with classes in object-oriented programming.
     The `@defcv' command is followed by three arguments: the category
     of thing being defined, the class to which it belongs, and its
     name.  Thus,

          @defcv {Class Option} Window border-pattern
          ...
          @end defcv

     illustrates how you would write the first line of a definition of
     the `border-pattern' class option of the class `Window'.

     The template is:
          @defcv CATEGORY CLASS NAME
          ...
          @end defcv

     `@defcv' creates an entry in the index of variables.

`@defivar CLASS NAME'
     The `@defivar' command is the definition command for instance
     variables in object-oriented programming.  `@defivar' is
     equivalent to `@defcv {Instance Variable} ...'

     The template is:
          @defivar CLASS INSTANCE-VARIABLE-NAME
          BODY-OF-DEFINITION
          @end defivar

     `@defivar' creates an entry in the index of variables.

`@deftypeivar CLASS DATA-TYPE NAME'
     The `@deftypeivar' command is the definition command for typed
     instance variables in object-oriented programming.  It is similar
     to `@defivar' with the addition of the DATA-TYPE parameter to
     specify the type of the instance variable.  `@deftypeivar' creates
     an entry in the index of variables.

`@defop CATEGORY CLASS NAME ARGUMENTS...'
     The `@defop' command is the general definition command for
     entities that may resemble methods in object-oriented programming.
     These entities take arguments, as functions do, but are associated
     with particular classes of objects.

     For example, some systems have constructs called "wrappers" that
     are associated with classes as methods are, but that act more like
     macros than like functions.  You could use `@defop Wrapper' to
     describe one of these.

     Sometimes it is useful to distinguish methods and "operations".
     You can think of an operation as the specification for a method.
     Thus, a window system might specify that all window classes have a
     method named `expose'; we would say that this window system
     defines an `expose' operation on windows in general.  Typically,
     the operation has a name and also specifies the pattern of
     arguments; all methods that implement the operation must accept
     the same arguments, since applications that use the operation do
     so without knowing which method will implement it.

     Often it makes more sense to document operations than methods.  For
     example, window application developers need to know about the
     `expose' operation, but need not be concerned with whether a given
     class of windows has its own method to implement this operation.
     To describe this operation, you would write:

          @defop Operation windows expose

     The `@defop' command is written at the beginning of a line and is
     followed on the same line by the overall name of the category of
     operation, the name of the class of the operation, the name of the
     operation, and its arguments, if any.

     The template is:
          @defop CATEGORY CLASS NAME ARGUMENTS...
          BODY-OF-DEFINITION
          @end defop

     `@defop' creates an entry, such as ``expose' on `windows'', in the
     index of functions.

`@deftypeop CATEGORY CLASS DATA-TYPE NAME ARGUMENTS...'
     The `@deftypeop' command is the definition command for typed
     operations in object-oriented programming.  It is similar to
     `@defop' with the addition of the DATA-TYPE parameter to specify
     the return type of the method.  `@deftypeop' creates an entry in
     the index of functions.

`@defmethod CLASS NAME ARGUMENTS...'
     The `@defmethod' command is the definition command for methods in
     object-oriented programming.  A method is a kind of function that
     implements an operation for a particular class of objects and its
     subclasses.

     `@defmethod' is equivalent to `@defop Method ...'.  The command is
     written at the beginning of a line and is followed by the name of
     the class of the method, the name of the method, and its
     arguments, if any.

     For example:
          @defmethod `bar-class' bar-method argument
          ...
          @end defmethod

     illustrates the definition for a method called `bar-method' of the
     class `bar-class'.  The method takes an argument.

     The template is:

          @defmethod CLASS METHOD-NAME ARGUMENTS...
          BODY-OF-DEFINITION
          @end defmethod

     `@defmethod' creates an entry, such as ``bar-method' on
     `bar-class'', in the index of functions.

`@deftypemethod CLASS DATA-TYPE NAME ARGUMENTS...'
     The `@deftypemethod' command is the definition command for methods
     in object-oriented typed languages, such as C++ and Java.  It is
     similar to the `@defmethod' command with the addition of the
     DATA-TYPE parameter to specify the return type of the method.


automatically generated by info2www version 1.2.2.9