766 lines
29 KiB
Plaintext
766 lines
29 KiB
Plaintext
/*
|
||
* $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-CLIPPER.
|
||
* 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$
|
||
*/
|
||
|
||
|
||
|