harbour-core/harbour/doc/es/command.txt

/*
 * $Id$
 */

/*
 * Las siguientes partes son derechos adquiridos de sus autores individuales.
 * www - http://www.harbour-project.org
 *
 * Copyright 2000 Alejandro de G rate <alex_degarate@hotmail.com>
 * Documentaci¢n en Espa¤ol de los comandos OOP
 *
 * Copyright 2000 Brian Hays <bhays@abacuslaw.com>
 * Documentaci¢n en Ingl‚s de los comandos OOP
 *
 * Vea doc/license.txt por los t‚rminos de la licencia.
 *
 */


/*  $DOC$
 *  $COMMANDNAME$
 *      CLASS
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Define una Clase para la Programacion Orientada a Objetos (OOP).
 *  $SYNTAX$
 *      CLASS <NombreClase> [ <FROM, INHERIT> <SuperClase> ]
 *  $ARGUMENTS$
 *      <NombreClase> Nombre de la clase a definir. Por tradici¢n, las
 *                    clases en Harbour comienzan con "T" (algo com£n en el
 *                    mundo OOP) para evitar colisiones con clases creadas
 *                    por el usuario.
 *      <SuperClase>  La clase padre para usar la herencia.
 *  $DESCRIPTION$
 *      CLASS crea una clase desde la cual se pueden crear objetos.
 *      Cada clase es definida en un archivo.prg separado para este prop¢sito
 *      No se puede crear m s de una clase en un archivo.prg
 *      Despu‚s del mandato CLASS comienza la definici¢n, luego los elementos
 *      DATA (tambien conocidos como variables de instancia) y luego
 *      los METHODS de la clase (el equivalente a las funciones en la
 *      Programacion tradicional)
 *
 *      Las Clases pueden heredar desde una clase sola <SuperClass>, pero la
 *      cadena de herencia puede extenderse a muchos niveles
 *
 *      Un program usa una clase llamando al Constructor de la clase, el
 *      m‚todo New() para crear el objeto. Ese objeto es usualmente asignado
 *      a una variable, la cual es usada para acceder a los elementos DATA
 *      y a los m‚todos
 *  $EXAMPLES$
 *      <fixed>
 *      CLASS TBColumn
 *
 *         DATA Block      // Codeblock para recuperar datos para la Columna
 *         DATA Cargo      // Variable definida por el usuario
 *         DATA ColorBlock // Codeblock que determina el color de los items
 *         DATA ColSep     // Caracter separador de la Columna
 *         DATA DefColor   // Array de ¡ndices num‚ricos a la tabla de color
 *         DATA Footing    // Pie de Columna
 *         DATA FootSep    // Caracter separador del Pie
 *         DATA Heading    // Encabezado de la Columna
 *         DATA HeadSep    // Caracter separador de la cabecera
 *         DATA Width      // Ancho de la Columna
 *         DATA ColPos     // Posici¢n temporaria de la columna en pantalla
 *
 *         METHOD New()    // Constructor
 *
 *      ENDCLASS
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      CLASS es una extensi¢n de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      HBClass(),Programacion Orientada a Objeto,DATA,METHOD
 *  $END$
 */

/*  $DOC$
 *  $COMMANDNAME$
 *      DATA
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Define una variable de instance DATA, para los objetos de la clase
 *  $SYNTAX$
 *      DATA <NombreDato1> [,<NombreDatoN>] [ AS <tipo> ] [ INIT <uValor> ]
 *  $ARGUMENTS$
 *      <NombreDato1> Nombre de DATA
 *
 *      <tipo>        Especificaci¢n Opcional del tipo de datos, de uno de
 *                    los siguientes (especificaci¢n en ingl‚s):
 *                    Character, Numeric, Date, Logical, Codeblock, Nil
 *
 *      <uValor>      Valor opcional inicial cuando se crea un nuevo objeto
 *  $DESCRIPTION$
 *      Los elementos DATA tambien pueden ser pensados como "propiedades"
 *       ¢ "atributos" de un objeto. ellos pueden ser de cualquier tipo
 *      incluyendo bloques de codigo.
 *      Una vez que el objeto ha sido creado, los elementos DATA son refe-
 *      renciados con dos puntos (:) como en MyObject:Heading := "Nombre".
 *      Usualmente una clase tambi‚n define m‚todos para manipular los DATA.
 *
 *      Se puede usar la clausula "AS <type>" para reforzar que DATA es
 *      perteneciente a un cierto tipo. De otra manera este tomar  el tipo
 *      de cualquier valor que le sea asignado.
 *
 *      Use la clausula "INIT <uValue>" para inicializar ese DATA a <uValue>
 *      siempre que un nuevo objeto es creado.
 *  $EXAMPLES$
 *      <fixed>
 *      CLASS TBColumn
 *
 *         DATA Block      // Codeblock para recuperar datos para la Columna
 *         DATA Cargo      // Variable definida por el usuario
 *         DATA ColorBlock // Codeblock que determina el color de los items
 *         DATA ColSep     // Caracter separador de la Columna
 *         DATA DefColor   // Array de ¡ndices num‚ricos a la tabla de color
 *         DATA Footing    // Pie de Columna
 *         DATA FootSep    // Caracter separador del Pie
 *         DATA Heading    // Encabezado de la Columna
 *         DATA HeadSep    // Caracter separador de la cabecera
 *         DATA Width      // Ancho de la Columna
 *         DATA ColPos     // Posici¢n temporaria de la columna en pantalla
 *
 *         METHOD New()    // Constructor
 *
 *      ENDCLASS
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      DATA es una extensi¢n de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Programacion Orientada a Objeto,CLASS,METHOD,CLASSDATA
 *  $END$
 */

/*  $DOC$
 *  $COMMANDNAME$
 *      CLASSDATA
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Define una variable CLASSDATA para una clase (NO para un Objeto !)
 *  $SYNTAX$
 *      CLASSDATA <DataName1> [,<DataNameN>] [ AS <type> ] [ INIT <uValue> ]
 *  $ARGUMENTS$
 *      <NombreDato1> Nombre de DATA
 *
 *      <tipo>        Especificaci¢n opcional del tipo de datos de uno de
 *                    los siguientes (Original en ingl‚s):
 *                    Character, Numeric, Date, Logical, Codeblock, Nil
 *
 *      <uValor>      Valor opcional inicial cuando se inicia el programa
 *  $DESCRIPTION$
 *      Las variables CLASSDATA pueden se pensadas como "propiedades" de un
 *      clase entera. Cada CLASSDATA existe s¢lo una vez, no importa cu ntos
 *      objetos sean creados. Un uso comun es para un contador que es
 *      incrementado siempre que un objeto es creado y decrementado cuando
 *      alguno es destruido, as¡ se puede monitorear el n£mero de objetos
 *      en existencia para esta clase.
 *
 *      Se puede usar la clausula "AS <type>" para reforzar que CLASSDATA es
 *      perteneciente a un cierto tipo. De otra manera este tomar  el tipo
 *      de cualquier valor que le sea asignado.
 *      Use la clausula "INIT <uValue>" para inicializar ese DATA a <uValue>
 *      siempre que un nuevo objeto es creado.
 *  $EXAMPLES$
 *      <fixed>
 *      CLASS TWindow
 *         DATA   hWnd, nOldProc
 *         CLASSDATA lRegistered AS LOGICAL
 *      ENDCLASS
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      CLASSDATA es una extensi¢n de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Programacion Orientada a Objeto,CLASS,METHOD,DATA
 *  $END$
 */

/*  $DOC$
 *  $COMMANDNAME$
 *      METHOD
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Declara un METHOD para una clase en la cabecera de la clase
 *  $SYNTAX$
 *      METHOD <NombreM‚todo>( [<params,...>]) [ CONSTRUCTOR ]
 *      METHOD <NombreM‚todo>( [<params,...>]) INLINE <Code,...>
 *      METHOD <NombreM‚todo>( [<params,...>]) BLOCK  <CodeBlock>
 *      METHOD <NombreM‚todo>( [<params,...>]) EXTERN <FuncName>([<args,..>])
 *      METHOD <NombreM‚todo>( [<params,...>]) SETGET
 *      METHOD <NombreM‚todo>( [<params,...>]) VIRTUAL
 *      METHOD <NombreM‚todo>( [<param>] )     OPERATOR <op>
 *      METHOD <NombreM‚todo>( [<params,...>]) CLASS <ClassName>
 *  $ARGUMENTS$
 *      <NombreM‚todo>  Nombre del m‚todo a definir
 *
 *      <params,...>    Lista opcional de parametros
 *  $DESCRIPTION$
 *      Los M‚todos son "funciones de clase" y hacen el trabajo de la clase.
 *      Todos los m‚todos pueden ser definidos en la cabecera entre los
 *      comandos CLASS y ENDCLASS. Si el cuerpo de un m‚todo no esta
 *      totalmente definido aqui, el cuerpo completo es escrito debajo del
 *      comando ENDCLASS usando esta sintaxis:
 *
 *         METHOD <NombreM‚todo>( [<params,...>] ) CLASS <NombreClase>
 *
 *      Los M‚todos pueden referenciar al objeto actual usando la palabra
 *      clave "Self:" ¢ su versi¢n m s corta "::"
 *
 *      CLAUSULAS:
 *
 *      CONSTRUCTOR  Define un m‚todo especial de la clase: el m‚todo
 *                   Constructor, usado para crear objetos. Este es
 *                   usualmente el m‚todo New().
 *                   Los constructores siempre retornan el objeto New().
 *
 *      INLINE       R pido y f cil de codificar, INLINE le permite definir
 *                   el c¢digo para el m‚todo inmediatamente despu‚s de la
 *                   definici¢n de la clase. Cualquier m‚todo no declarado
 *                   INLINE ¢ BLOCK debe ser completamente definido despu‚s
 *                   del comando ENDCLASS.
 *                   El <Codigo,...> siguiente a INLINE recibe un parametro
 *                   de Self. Si se necesita recibir m s par metros, use
 *                   la cl usula BLOCK en su lugar.
 *
 *      BLOCK        Use esta cl usula cuando desee declarar r pidos m‚todos
 *                   'inline' que necesiten par metros. El primer par metro
 *                    a <CodeBlock> debe ser Self, como en:
 *
 *          METHOD <NombreM‚todo> BLOCK {|Self,<arg1>,<arg2>,...,<argN>|...}
 *
 *      EXTERN       Si una funci¢n externa hace lo que el m‚todo necesita,
 *                   use esta cl usula para hacer una llamada optimizada a
 *                   esa funci¢n directamente.
 *
 *      SETGET       Para datos calculados. El nombre del m‚todo puede ser
 *                   manipulado como un elemento de DATA para establecer
 *                   (Set) u obtener (Get) un valor.
 *
 *      VIRTUAL      M‚todos que no hacen nada. Utiles para Clases de Base
 *                   donde la Clase hija definir  el comportamiento del
 *                   m‚todo, ¢ cuando Ud. esta creando y probando una Clase.
 *
 *      OPERATOR     Operador de Sobrecarga para las Clases.
 *                   Vea el ejemplo ../Tests/TestOp.prg para detalles
 *
 *      CLASS <ClassName>
 *                   Use esta sintaxis solamente para definir un m‚todo
 *                   completo despu‚s del comando ENDCLASS.
 *  $EXAMPLES$
 *      <fixed>
 *      CLASS TWindow
 *         DATA   hWnd, nOldProc
 *         METHOD New( ) CONSTRUCTOR
 *         METHOD Capture() INLINE  SetCapture( ::hWnd )
 *         METHOD End() BLOCK  { | Self, lEnd | If( lEnd := ::lValid(),;
 *                                 ::PostMsg( WM_CLOSE ),), lEnd }
 *         METHOD EraseBkGnd( hDC )
 *         METHOD cTitle( cNewTitle ) SETGET
 *         METHOD Close() VIRTUAL
 *      ENDCLASS
 *
 *      METHOD New( ) CLASS TWindow
 *         local nVar, cStr
 *         ... <codigo> ...
 *         ... <codigo> ...
 *      RETURN Self
 *      </fixed>
 *  $TESTS$
 *      <fixed>
 *      TestOp.prg
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      METHOD es una extensi¢n de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      HBClass(),Programacion Orientada a Objeto,DATA,CLASS
 *  $END$
 */

/*  $DOC$
 *  $COMMANDNAME$
 *      MESSAGE
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Reenv¡a la llamada de un m‚todo a otro m‚todo.
 *  $SYNTAX$
 *      MESSAGE <NombreMensaje>   METHOD <NombreM‚todo>( [<params,...>] )
 *      MESSAGE <NombreMensaje>() METHOD <NombreM‚todo>( [<params,...>] )
 *  $ARGUMENTS$
 *      <NombreMensaje>  El nombre del pseudo-m‚todo a definir.
 *
 *      <NombreM‚todo>   El m‚todo a crear y llamar cuando <NombreMensaje>
 *                       es invocado.
 *      <params,...>     Lista de par metros opcionales para el m‚todo
 *  $DESCRIPTION$
 *      El comando MESSAGE es una caracter¡stica rara vez usada, que permite
 *      re-enviar una llamada a un m‚todo con un nombre diferente. Esto puede
 *      ser necesario si el nombre de un m‚todo entra en conflicto con una
 *      funci¢n p£blica que necesita ser llamada desde adentro de un m‚todo
 *      de la Clase.
 *
 *      Por ejemplo, se puede tener una funci¢n p£blica llamda BeginPaint()
 *      que es usada para pintar las ventanas. Podr¡a ser natural tambi‚n
 *      tener un m‚todo de la Clase Ventana, llamado :BeginPaint() que la
 *      aplicaci¢n pueda llamar.
 *      Pero dentro del m‚todo de la Clase uno podr¡a no estar habilitado
 *      para llamar a la funci¢n p£blica porque, los m‚todos internos est n
 *      basados en funciones est ticas (las que ocultan funciones p£blicas
 *      con el mismo nombre)
 *
 *      El comando MESSAGE permite crear el verdadero m‚todo con un nombre
 *      diferente (::xBeginPaint()) y a£n permitir la sintaxis ::BeginPaint()
 *      para llamar a ::xBeginPaint(). Este entonces es libre de llamar a
 *      la funci¢n publica BeginPaint().
 *  $EXAMPLES$
 *      <fixed>
 *      CLASS TWindow
 *         DATA   hWnd, nOldProc
 *         METHOD New( )  CONSTRUCTOR
 *         MESSAGE BeginPaint METHOD xBeginPaint()
 *      ENDCLASS
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      MESSAGE es una extensi¢n de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      METHOD,DATA,CLASS,Programacion Orientada a Objeto
 *  $END$
 */

/*  $DOC$
 *  $COMMANDNAME$
 *      ERROR HANDLER
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Designa un m‚todo como manejador de error para la Clase.
 *  $SYNTAX$
 *      ERROR HANDLER <NombreM‚todo>( [<params,...>] )
 *  $ARGUMENTS$
 *      <NombreM‚todo>  Nombre del m‚todo a definir
 *
 *      <params,...>    Lista de parametros opcionales
 *  $DESCRIPTION$
 *      ERROR HANDLER nombra al m‚todo que deberia manejar los errores para
 *      la Clase que esta siendo definida.
 *  $EXAMPLES$
 *      <fixed>
 *      CLASS TWindow
 *         ERROR HANDLER  MyErrHandler()
 *      ENDCLASS
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      ERROR HANDLER es una extensi¢n de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Programacion Orientada a Objeto,ON ERROR,CLASS,METHOD,DATA
 *  $END$
 */

/*  $DOC$
 *  $COMMANDNAME$
 *      ON ERROR
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Designa un m‚todo como manejador de error para la Clase.
 *  $SYNTAX$
 *      ON ERROR <NombreM‚todo>( [<params,...>] )
 *  $ARGUMENTS$
 *      <NombreM‚todo>  Nombre del m‚todo a definir
 *
 *      <params,...>    Lista de parametros opcionales
 *  $DESCRIPTION$
 *      ON ERROR es un sin¢nimo para ERROR HANDLER.
 *      Este nombra al m‚todo que deber¡a manejar los errores para la
 *      Clase que esta siendo definida.
 *  $EXAMPLES$
 *      <fixed>
 *      CLASS TWindow
 *         ON ERROR  MyErrHandler()
 *      ENDCLASS
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      ON ERROR es una extensi¢n de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Programacion Orientada a Objeto,ERROR HANDLER,CLASS,METHOD,DATA
 *  $END$
 */

/*  $DOC$
 *  $COMMANDNAME$
 *      ENDCLASS
 *  $CATEGORY$
 *      Comando OOP
 *  $ONELINER$
 *      Termina la declaraci¢n de una Clase.
 *  $SYNTAX$
 *      ENDCLASS
 *  $DESCRIPTION$
 *      ENDCLASS marca el fin de la declaraci¢n de una Clase.
 *      Este es usualmente seguido por el m‚todo de la Clase que no es
 *      INLINE.
 *  $EXAMPLES$
 *      <fixed>
 *      CLASS TWindow
 *         DATA   hWnd, nOldProc
 *      ENDCLASS
 *      </fixed>
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      ON ERROR es una extensi¢n de Harbour.
 *  $PLATFORMS$
 *      Todas
 *  $SEEALSO$
 *      Programacion Orientada a Objeto,CLASS,METHOD,DATA
 *  $END$
 */

/*  $DOC$
 *  $FUNCNAME$
 *      Programacion Orientada a Objeto
 *  $CATEGORY$
 *      Documento
 *  $ONELINER$
 *      Programacion Orientada a Objeto
 *  $DESCRIPTION$
 *      </b>Programaci¢n Orientada a Objeto (OOP)</b>
 *
 *      <b>INTRODUCCION</b>
 *
 *      Esta es una breve introduci¢n al mundo OOP, no pretende ser m s que
 *      un ayuda memoria de algunos puntos.
 *      El Objetivo de la OOP de Harbour es alcanzar la m xima compatibilidad
 *      posible con otros programas que prove¡an de funcionalidad OOP a
 *      Clipper donde este no la tenia.
 *      Algunos de ellos son Class(y), FiveWin Objects, TopClass y Visual
 *      Object.
 *
 *
 *      <b>OBJETOS</b>
 *
 *      Tradicionalmente la implementaci¢n de objetos, ha sido basado en
 *      lo que se conoce como "estructuras", un tipo de datos habitual en
 *      lenguaje "C" (struct) y (record) en Pascal y Delphi.
 *      Tanto en Clipper como en Harbour los objetos se implementan sobre
 *      arrays.
 *      Un objeto puede contener a la vez variables y funciones.
 *      Mientras ese objeto-array se conserve se puede pasar como par metro
 *      modificarlo, ejecutar las funciones contenidas en ‚l, etc.
 *      Uno vive rodeado de objetos. Podemos considerar Arbol como una clase
 *      particular de objeto. Entonces podremos tener Pino, Roble, Acacia
 *      todos ellos son instancias de Arbol. En otras palabras ellos son
 *      objetos de la clase Arbol.
 *
 *
 *      <b>CLASE</b>
 *
 *      Es un t‚rmino que describe una especificaci¢n para un conjunto de
 *      objetos con propiedades comunes.
 *      Desde el punto de vista de la programaci¢n Ud. define que debe
 *      tener una clase para que le sea £til a Ud., qu‚ atributos satisfacen
 *      sus necesidades.
 *      Esto es llamado <b>Abstracci¢n de datos</b> en la jerga de OOP, ¢
 *      Programacion Orientada a Objetos porque Ud. solamente abstrae los
 *      atributos que Ud. desea usar, de un mont¢n de posibilidades para un
 *      objeto modelo.
 *
 *
 *      <b>INSTANCIA</b>
 *
 *      Una instancia de una clase es un t‚rmino t‚cnico para un objeto de
 *      esa clase.
 *
 *
 *      <b>CLASES DE OBJETOS</b>
 *
 *      Una definicion de una clase lista todos los parametros que se
 *      necesitan para definir un objeto de esa clase en particular.
 *      La cantidad de datos necesarios para definir una clase depende
 *      de que es lo que Ud. vaya a hacer con ese objeto, pero siempre
 *      habr  un m¡nimo que impida que una clase sea ambigua ¢ incompleta.
 *
 *      La clase Arbol por ejemplo podr¡a contener dos parametros en la
 *      definici¢n. El nombre del Arbol como cadena de caracteres, Si es
 *      perenne (si conserva las hojas en invierno) como una variable logica
 *      Los parametros que definen un objeto son denominados <b>variables</b>
 *      <b>de instancia ¢ atributos</b> de una clase.
 *      Las variables de instancia pueden ser tipos basicos de datos como
 *      CHARACTER, NUMERIC ¢ LOGIC, aunque tambien puede ser otros objetos
 *      como la Hoja y definida esta como de la Clase Hoja.
 *
 *
 *      <b>OPERANDO CON OBJETOS</b>
 *
 *      Una de las limitaciones basicas sobre que puede hacer con los
 *      objetos dependen del tipo de datos sobre los cuales estan basados
 *      as¡ por ejmplo Ud. no puede hacer operaciones matematicas con el
 *      atributo <cNombre> de la clase Arbol, pero s¡ puede compararlo con
 *      otro, etc.
 *      Las unicas operaciones que se pueden hacer sobre una instancia de una
 *      clase particular son aquellas definidas dentro de la clase.
 *      Por lo tanto, la utilidad y flexibilidad de una clase depende de
 *      cuanto esfuerzo e ingenio haya puesto al establecer su definici¢n.
 *      Estas operaciones se llaman <b>METODOS</b> en la jerga OOP que no son
 *      ni m s ni menos que nuestros conocidos procedimientos y funciones.
 *
 *
 *      <b>ENCAPSULAMIENTO</b>
 *
 *      Se refiere al hecho de ocultar items de datos y metodos dentro de
 *      una clase al declararlos como <b>Private</b> en la definici¢n de la
 *      clase. Esto protege las partes internas de la clase de ser cambiadas
 *      ¢ usadas incorrectamente.
 *      Esta habilidad de ocultar la <b>Implementaci¢n de la clase</b>
 *      permitiendo un acceso limitado a los miembros de una clase, le da la
 *      posibilidad de cambiar las partes internas de esa clase cuando sea
 *      necesario. Mientras las caracteristicas de los metodos que pueden ser
 *      llamados desde afuera permanezcan sin cambios, la codificaci¢n
 *      interna puede ser cambiada como se desee.
 *
 *
 *      <b>HERENCIA</b>
 *
 *      Muchos de los objetos que se definen en una clase pueden ser
 *      subdivididos en conjuntos m s especializados que tambi‚n pueden ser
 *      representados por clases.
 *      En nuestro ejemplo de la clase Arbol, Conifera podr¡a ser una
 *      subclase de la clase Arbol, esta podr¡a tener todas las variables de
 *      instancia y m‚todos de la clase Arbol, m s algunas variables de
 *      instancia adicionales y metodos que la definan como Conifera.
 *      Podemos referirnos a la clase conifera como una <b>Subclase</b> de
 *      la clase Arbol y a la clase Arbol como una <b>Superclase</b> ¢
 *      <b>Clase Padre</b> de la clase Conifera.
 *
 *
 *      <b>POLIMORFISMO</b>
 *
 *      Es la habilidad de asumir diferentes formas ¢ contornos.
 *      Practicamente significa la habilidad de una £nica variable de llamar
 *      a diferentes m‚todos, dependiendo de lo que contiene la variable.
 *      El polimorfismo involucra dos cosas:
 *      1) Usar una variable de un tipo especifico, gralmente una variable
 *         de una clase base, para almacenar objetos de alguna de las clases
 *         derivadas.
 *      2) El uso automatico del objeto almacenado en la variable de la clase
 *         base para seleccionar un m‚todo de entre todos los m‚todos de las
 *         clases derivadas.
 *         El tipo del objeto almacenado no es conocido hasta que el
 *         programa se ejecuta, por tanto la elecci¢n de cual m‚todo de clase
 *         a ejecutar es hecha dinamicamente.
 *
 *
 *      <b>ATRIBUTOS</b>
 *
 *      Los atributos de un objeto, a menudo son llamados <b>Miembros de</b>
 *      <b>Clase</b> y se declaran utilizando la palabra clave DATA.
 *      Por ejemplo:
 *      DATA cFile  INIT "*.txt"
 *      En Harbour se utiliza la clausula INIT para inicializar las variables
 *
 *
 *      <b>CONSTRUCTOR</b>
 *
 *      Declarar una variable para soportar un objeto no crea al objeto en
 *      s¡ mismo, la variable solo mantiene una referencia al objeto.
 *      para crear un objeto se debe usar la palabra clave <b>New</b>.
 *      Este es seguido por una lista de argumentos opcionales entre
 *      parentesis y luego por el objeto de la clase a la que pertenecen.
 *
 *      Un constructor es la funci¢n que crea al objeto e inicializa las
 *      variables. Como las funciones en el lenguaje OOP se llaman
 *      m‚todos el constuctor siempre se declara como  METHOD New(..)
 *
 *      METHOD New( cFile ) CLASS TNortonGuide
 *
 *         IF VALTYPE( cFile ) <> NIL .AND. VALTYPE( cFile ) == "C"
 *            Self:cFile   := LOWER( cFile )
 *            Self:nHandle := FCREATE( Self:cFile )
 *         ENDIF
 *
 *      RETURN Self
 *
 *      Cuando se crea un objeto, el objeto contendr  todas las variables que
 *      fueron incluidas en la definici¢n de la clase. Sin embargo no todas
 *      las variables son iguales. Hay dos tipos:
 *      Un tipo de variable de clase que es asociada con cada objeto
 *      univocamente, cada instancia de la clase tendr  su propia copia de
 *      estas variables con su propio valor asignado. Estas diferencian un
 *      objeto de otro, d ndole a un objeto su individualidad por ello se
 *      llaman <b>Variables de Instancia</b>.
 *
 *      El otro tipo de variable de clase es asociada con la clase y es
 *      compartida con todos los objetos de la clase. Hay solo una copia
 *      de este tipo de variables, no importa cuantos objetos sean creados.
 *      Este £ltimo tipo se llama <b>Variables de Clase</b>, ellas existen
 *      a£n si ning£n objeto de esta clase ha sido creado. Ellas pertenecen
 *      a la clase, pero son incluidas como parte de cada objeto de la clase.
 *      Si el valor de una variable de clase es cambiado, el nuevo valor est 
 *      disponible en todos los objetos de la clase.
 *      Una variable de clase debe ser definida usando la palabra clave
 *      CLASSDATA (es equivalente a STATIC en el mundo OOP) precediendo a su
 *      nombre.
 *
 *      Al igual que con las variables existen dos tipos de M‚todos:
 *      <b>Metodos de Clase</b> Ud. puede ejecutar Metodos de Clase, a£n
 *      si ning£n objeto de esta clase ha sido creado. Al igual que con las
 *      variables de clase son precedidos del identificador STATIC en la
 *      mayoria de los lenguajes OOP.
 *
 *      Mientras que los <b>Metodos de Instancia</b> solamente pueden ser
 *      ejecutados en relaci¢n a un objeto particular, as¡ que si no existe
 *      el objeto, NO hay m‚todo de instancia a ser ejecutado.
 *
 *      Debe tenerse en cuenta que no se puede hacer referencia a ninguna
 *      variable de instancia dentro de una clase dentro un m‚todo Static
 *      Estto se debe a que su m‚todo Static puede ser ejecutado cuando
 *      todav¡a ning£n objeto de la clase a sido creado y por lo tanto NO
 *      existen variables de instancia.
 *
 *
 *      <b>SELF</b>
 *
 *      Habitualmente los m‚todos de una clase, devuelven una referencia al
 *      objeto sobre el cual act£an y esa referencia se denomina <Self>
 *
 *
 *      <b>DEFINIENDO UNA CLASE</b>
 *
 *      Una clase se define con la palabra clave CLASS seguida de un nombre
 *      que identifica a la clase. Para indicar que termina una clase se
 *      utiliza la palabra clave ENDCLASS
 *      Por tradici¢n, las clases en Harbour comienzan con la letra "T"
 *      (algo com£n en el mundo OOP) para evitar colisiones con clases
 *      creadas por el usuario.
 *
 *      la por ej.
 *      METHOD <NombreM‚todo>( [<params,...>] ) CLASS <NombreClase>
 *
 *      Los M‚todos pueden referenciar al objeto actual usando la palabra
 *      clave "Self:" ¢ su versi¢n m s corta "::"
 *      Vea METHOD para una explicaci¢n de las distintas variantes.
 *
 *
 *      <b>VIDA DE UN OBJETO</b>
 *
 *      La vida de un objeto esta determinada por la variable que hace
 *      referencia a ‚l. Si distintas variables hacen referencia a un
 *      mismo objeto, el objeto sobrevive mientras todav¡a haya una variable
 *      que haga referencia a ese objeto.
 *      Si creamos un objeto
 *          oNgi := TNortonGuide():new( "Myfile" )
 *      y luego hacemos
 *          oNgi := NIL
 *      la variable oNgi no apunta m s al objeto, se pierde la referencia y
 *      si asumimos que no hay ninguna otra variable referenciandolo entonces
 *      el objeto TNortonGuide al cual ella apunta queda disponible para el
 *      el recolector de memoria.
 *      Pero el objeto no desaparece instant neamente, sino que pasa alg£n
 *      tiempo hasta que el objeto se vuelve inaccesible para su programa
 *      (cuando el subsistema de memoria dispone de tiempo de procesamiento),
 *      se ocupa de ‚l.
 *
 *
 *      <b>SOBRECARGA</b>
 *      Vea testop.prg por un ejemplo
 *
 *
 *      <b>CLONANDO OBJETOS</b>
 *      Algunos lenguajes OOP proveen una m‚todo preconstruido para duplicar
 *      objetos.
 *
 *      <b>Comentario Final</b>
 *
 *      Los programas Orientados a Objetos son escritos usando objetos los
 *      cuales modelan el problema que esta siendo resuelto.
 *      Debido a que un objeto incluye los m‚todos con los cuales puede
 *      operar, as¡ como los datos que lo definen, este tipo de programaci¢n
 *      es menos propensa a errores (seg£n los especialistas) y deber¡a ser
 *      m s robusta que la forma de programaci¢n procedural.
 *
 *      Estas caracter¡sticas son las que han facilitado la proliferaci¢n de
 *      lenguajes como Java y Python. Pero una de las desventajas m s notables
 *      es la dificultad muchas veces para intercambiar la informaci¢n
 *      almacenada en esos objetos con otros programas y la conservaci¢n de
 *      esos objetos en un medio magnetico (<b>Serializaci¢n</b>) en un
 *      formato compatible, algo que seg£n los expertos promete XML y que ya
 *      est  disponible con Harbour.
 *
 *  $EXAMPLES$
 *      CLASS Circle
 *
 *      CLASS TNortonGuide
 *
 *         DATA cFile                // Nombre archivo
 *         DATA nHandle              // file handle
 *         METHOD New( cFile )       // constructor, funcion que crea archivo
 *         METHOD CLOSE()            // funcion que cierra archivo
 *         METHOD WriteParBold( cPar )
 *         METHOD WriteTitle( cTopic, cTitle )
 *
 *      ENDCLASS
 *
 *      METHOD new( cFile ) CLASS TNortonGuide
 *
 *         IF VALTYPE( cFile ) <> NIL .AND. VALTYPE( cFile ) == "C"
 *            Self:cFile   := LOWER( cFile )
 *            Self:nHandle := FCREATE( Self:cFile )
 *         ENDIF
 *
 *      RETURN Self
 *
 *
 *  $STATUS$
 *      R
 *  $COMPLIANCE$
 *      La sintaxis Orientada a Objetos en Harbour es compatible con
 *      CA-Cl*pper.
 *      Pero Clipper solamente permite la creaci¢n de objetos a partir
 *      de unas pocas clases estandares, y NO le permite al programador
 *      crear nuevas clases.
 *      En Harbour, Ud. puede crear sus propias clases completamente con
 *      M‚todos, Variables de Instancia, Variables de Clase y Herencia.
 *      Aplicaciones enteras pueden ser designadas y codificadas en el
 *      estilo Orientado a Objetos.
 *  $PLATFORMS$
 *      Todas
 *  $FILES$
 *  $SEEALSO$
 *      __objHasData(),CLASS,METHOD
 *  $END$
 */