Agricultura Precision Soft de Gestion Agroganadera

Universidad Nacional del Nordeste
Facultad de Ciencias Exactas y Naturales y de Agrimensura
Licenciatura en Sistemas de Información

Trabajo Final de Aplicación
Aplicación Web para la Gestión Agro-Ganadera
Alumno: Lisandro Dardo Yaccuzzi - LU:32774

Profs. Orientadores: Mgter. David L. La Red Martinez
y Lic. Valeria E. Uribe
Prof. Coordinador: Agr. Castor F. Herrmann
Corrientes - Argentina
Julio - 2010
A mi familia, esposa e hija.

Prefacio
Los diversos avances tecnológicos derivados del conocimiento y la ciencia

están siendo aplicados en varios países del mundo a distintos sectores nun-
ca antes imaginados, entre ellos el sector de la agricultura y la ganadería en
Argentina. A esto se le suma el empleo de herramientas con tecnología de avan-
zada que ya se encuentran a disposición de todos en cualquier momento y lugar
que se las requieran, para poder de esta forma mantener la competitividad a
nivel mundial con una producción sustentable en el tiempo.
Todo lo señalado precedentemente sería ilusorio si no se dispusiera de las
metodologías y de los sistemas informáticos que facilitaran la información en-
tre las distintas organizaciones empresariales, utilizando diversos medios de co-
municación y diferentes plataformas de hardware y de software, para resolver
el problema de la creciente complejidad de la gestión de un establecimiento
agrícola-ganadero en continua expansión.
Este trabajo se basa en el estudio de software de base que permite el
desarrollo de aplicaciones Web multiplataforma con acceso a bases de datos
y en el desarrollo de una aplicación Web de gestión de un establecimiento
agro-ganadero.
Contempla el registro y seguimiento de la información propia del estable-
cimiento como todas las actividades realizadas en el mismo, es decir la infor-
mación emergente del registro de cada actividad que se genera en el mismo, el
seguimiento detallado de cada actividad registrada, paso a paso, a los efectos
de brindar información a los usuarios finales de los movimientos realizados,
también a su vez da información, mediante consultas a la aplicación, de los
datos ingresados por cada actividad, como estado actual, stock y demás.
Esto significa la posibilidad de registrar cada actividad con sus datos y
fechas en el mismo momento que ocurren para su posterior gestión o consul-
ta, brindando la posibilidad de una consulta desde la Internet por los demás
usuarios de la aplicación.
Objetivos
El objetivo inicialmente planteado fue la realización de una aplicación Web
multiplataforma desarrollada en Java, mediante la cual el usuario pudiera con-
tar con un medio de gestión para consultar distintos aspectos del estableci-
miento en sí, mediante la Web. La aplicación podría ser operada desde una
Intranet o bien desde Internet.

Los objetivos planteados al inicio del trabajo, fueron totalmente cumplidos.

Etapas de Desarrollo
Se ha efectuado una amplia recopilación bibliográfica específica de los

temas pertinentes a la tarea planificada y a los productos de software
que se emplearon para la concreción del Trabajo Final.
Se realizaron las traducciones de los manuales correspondientes a la he-
rramienta de desarrollo Eclipse, versión 5.0 para Windows.
Se ha realizado un detallado estudio del lenguaje Java, utilizándose la
versión JDK 1.5.
Se ha realizado un detallado estudio del entorno de trabajo Scientific
WorkPlace 2.5.0 para la escritura del libro correspondiente al informe
final.
Se ha realizado un detallado estudio del software para el desarrollo de
la aplicación, es decir el estudio de la plataforma integrada de desarrollo
de aplicaciones Web, Eclipse.
Se ha realizado el estudio del Manejador de Bases de Datos (DBMS)
multiplataforma DB2 Express-C 9.
Se ha realizado el desarrollo de la aplicación utilizando páginas HTML
y Servlets de Java en el marco de la herramienta Eclipse en el entorno
Windows.
Se ha realizado el correspondiente testeo de la aplicación, utilizando una
máquina como servidor y otra como cliente ingresando a la base de datos
del servidor a través de la Intranet de la Facultad.
Una vez finalizada la aplicación se realizó la grabación en DVD de todo
el material correspondiente al trabajo final: una versión de la aplicación,
otra referente al libro en formato LaTex y el PDF generado. También se
icluyó los instaladores de los productos utilizados para el desarrollo, es
decir DB2 Express-C 9, Eclipse y Tomcat.
Objetivos Logrados
Se han alcanzado plenamente la totalidad de los objetivos planteados para
el presente trabajo.

Organización del Informe Final

El informe final comprende un libro impreso y un DVD, además de un
resumen y de un resumen extendido.
El libro impreso está organizado en capítulos, los que se indican a con-
tinuación:
Capitulo 1 - La Agro-Ganadería en la Actualidad: Se presenta una

visión general de los conceptos sobre la tecnología aplicada al sector
agro-ganadero.
Capitulo 2 - Conceptos básicos sobre Java: Se señalan los principales

conceptos referidos al lenguaje de programación.
Capitulo 3 - El lenguaje Java: Se indican los principales aspectos y

destacadas características referidas al lenguaje.
Capitulo 4 - Los Servlets: Se resumen los aspectos y características

más destacadas de estas facilidades.
Capitulo 5 - Introducción a DB2 Express-C 9: Se detallan las más

relevantes características de esta familia de productos de gestión de bases
de datos multiplataforma.
Capitulo 6 - Eclipse: Se presentan los principales aspectos de este en-

torno de desarrollo de aplicaciones complejas.
Capitulo 7 - Introducción al Servidor Tomcat: Se señalan los aspec-

tos más relevantes de este servidor de aplicaciones Web.
Capitulo 8 - Aplicación: Se detallan los aspectos más significativos de

la aplicación desarrollada utilizando las facilidades antes mencionadas.
Capitulo 9 - Conclusiones: Se presentan las conclusiones a las que se

ha llegado al finalizar el presente trabajo y las posibles líneas futuras.
El DVD, adjunto al libro impreso, contiene lo siguiente:
Instaladores del software utilizado.
Resúmenes del trabajo realizado.

Libro del informe final.
Presentación para la defensa final.
Copia de seguridad de la base de datos de la aplicación.
Aplicación desarrollada.
Lisandro Dardo Yaccuzzi

Licenciatura en Sistemas de Información
Universidad Nacional del Nordeste
L.U.: 32774
Profs. Orientadores: Mgter. David Luis La Red Martínez
y Lic. Valeria E. Uribe
Prof. Coordinador: Agr. Castor F. Herrmann
Corrientes; 01 de Mayo de 2010
Índice general
1. La Agro-Ganadería en la Actualidad 1
1.1. La Agricultura y la Ganadería en el Mundo y en Argentina . . 1
1.2. La Agricultura, la Máquina Reemplaza al Músculo . . . . . . . 2
1.2.1. Agricultura de Precisión . . . . . . . . . . . . . . . . . . 4
1.3. La Evolución de la Ganadería . . . . . . . . . . . . . . . . . . . 5
1.3.1. Ganadería Extensiva e Intensiva . . . . . . . . . . . . . 7
2. Conceptos Básicos de Java 11

2.1. ¿Qué es Java y Para qué fue Pensado? . . . . . . . . . . . . . . 11
2.1.1. Características del Lenguaje Java . . . . . . . . . . . . . 12
2.1.2. Desarrollo de las Principales Características de Java . . 13
2.1.3. Ventajas de Java . . . . . . . . . . . . . . . . . . . . . . 18
2.1.4. Limitaciones con Java . . . . . . . . . . . . . . . . . . . 19
2.1.5. Errores con Java . . . . . . . . . . . . . . . . . . . . . . 19
2.2. Existen Distintos Tipos de Java . . . . . . . . . . . . . . . . . . 20
2.2.1. JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.2. Java Standalone . . . . . . . . . . . . . . . . . . . . . . 21
2.2.3. Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3. Java en los Browsers de la World Wide Web . . . . . . . . . . . 23
2.3.1. Las Applets en la Web . . . . . . . . . . . . . . . . . . . 23
2.3.2. Máquinas Virtuales . . . . . . . . . . . . . . . . . . . . . 26
2.3.3. Java sin Browsers . . . . . . . . . . . . . . . . . . . . . . 28
2.3.4. HotJava . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.4. Java en Hebras - Threads . . . . . . . . . . . . . . . . . . . . . 29
2.4.1. La Ventaja de ser Multi-Threaded . . . . . . . . . . . . 30
2.5. Java Para Aplicaciones Corporativas . . . . . . . . . . . . . . . 31
3. El Lenguaje Java 34
3.1. Introducción a su Codificación . . . . . . . . . . . . . . . . . . 34

ÍNDICE GENERAL
3.1.1. Bibliotecas de Clases Estándares de Java . . . . . . . . 36

3.2. Estructura General de un Programa Java . . . . . . . . . . . . 36
3.3. Conceptos Básicos . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3.1. Clase . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3.2. Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.3.3. Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.3.4. Package . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.3.5. La Jerarquía de Clases de Java (API) . . . . . . . . . . 41
3.3.6. Variables Dentro del Lenguaje Java . . . . . . . . . . . 42
3.3.7. Visibilidad y Vida de las Variables . . . . . . . . . . . . 44
3.4. Operadores en Java . . . . . . . . . . . . . . . . . . . . . . . . 45
3.4.1. Operadores Aritméticos . . . . . . . . . . . . . . . . . . 45
3.4.2. Operadores de Asignación . . . . . . . . . . . . . . . . . 46
3.4.3. Operadores Unarios . . . . . . . . . . . . . . . . . . . . 46
3.4.4. Operadores Incrementales . . . . . . . . . . . . . . . . . 46
3.4.5. Operadores Relacionales . . . . . . . . . . . . . . . . . . 47
3.4.6. Operador de Concatenación de Cadenas de Caracteres
(+) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.4.7. Precedencia de Operadores . . . . . . . . . . . . . . . . 49
3.5. Estructuras de Programación . . . . . . . . . . . . . . . . . . . 50
3.5.1. Sentencias o Expresiones . . . . . . . . . . . . . . . . . . 50
3.5.2. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . 50
3.5.3. Sentencia import . . . . . . . . . . . . . . . . . . . . . . 52
3.5.4. Longitud de Líneas . . . . . . . . . . . . . . . . . . . . . 52
3.5.5. Bifurcaciones . . . . . . . . . . . . . . . . . . . . . . . . 52
3.5.6. Bucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.6. Clases en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.6.1. Características Importantes de las Clases . . . . . . . . 57
3.6.2. Métodos o Funciones Miembros . . . . . . . . . . . . . . 58
3.7. Clases de Mayor Utilidad . . . . . . . . . . . . . . . . . . . . . 60
3.7.1. Clase Arrays . . . . . . . . . . . . . . . . . . . . . . . . 60
3.7.2. Clases String y StringBuffer . . . . . . . . . . . . . . . . 61
3.7.3. Clase Double . . . . . . . . . . . . . . . . . . . . . . . . 62
3.7.4. Clase Integer . . . . . . . . . . . . . . . . . . . . . . . . 63
3.8. El AWT (Abstract Windows Toolkit) . . . . . . . . . . . . . . . 63
3.8.1. Qué es el AWT . . . . . . . . . . . . . . . . . . . . . . . 63
3.8.2. Creación de una Interface Gráfica de Usuario . . . . . . 63
3.8.3. Objetos “event source” y Objetos “event listener” . . . 64
ÍNDICE GENERAL
3.8.4. Proceso a Seguir Para Crear Una Aplicación Interactiva

(Orientada a Eventos) . . . . . . . . . . . . . . . . . . . 65
3.9. Errores Frecuentes de Programación . . . . . . . . . . . . . . . 65
3.9.1. Scheduling de Hilos de Ejecución . . . . . . . . . . . . . 66
3.9.2. Errores en el Uso de las Características de Portabilidad
de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
3.9.3. Uso de Directorios Definidos . . . . . . . . . . . . . . . 68
3.9.4. Carga de Drivers JDBC . . . . . . . . . . . . . . . . . . 71
3.9.5. Terminación de Líneas . . . . . . . . . . . . . . . . . . . 72
3.9.6. Entrada/Salida por Archivo . . . . . . . . . . . . . . . . 73
3.9.7. Fuentes de Caracteres . . . . . . . . . . . . . . . . . . . 73
4. Los Servlets 74
4.1. Servlets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.1.1. Principios de Codificación de Servlet . . . . . . . . . . 75
4.1.2. Ciclo de Vida del Servlet . . . . . . . . . . . . . . . . . 76
4.1.3. Instanciación e Inicialización . . . . . . . . . . . . . . . 76
4.1.4. Servicio de Demanda . . . . . . . . . . . . . . . . . . . . 78
4.1.5. Terminación . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.1.6. Modelos de Acceso JSP . . . . . . . . . . . . . . . . . . 78
4.1.7. Procesadores JSP . . . . . . . . . . . . . . . . . . . . . . 79
4.1.8. Compilación Batch de Archivos JSP . . . . . . . . . . . 81
4.1.9. Desarrollando Aplicaciones . . . . . . . . . . . . . . . . 81
4.1.10. Fases de Inicialización y de Terminación . . . . . . . . . 82
4.1.11. Rasgos de Java Servlet API . . . . . . . . . . . . . . . . 82
4.1.12. Patrones y Guías de Servlets/JSP . . . . . . . . . . . . 83
5. Introducción al DB2 Express-C 9 87

5.0.13. Servidores DB2 . . . . . . . . . . . . . . . . . . . . . . . 88
5.0.14. Clientes DB2 y Controladores . . . . . . . . . . . . . . . 89
5.0.15. Características y Productos Relacionados . . . . . . . . 90
5.0.16. Características incluídas en otras ediciones de DB2: . . 90
5.0.17. Características Incluidas con la Licencia de Suscripción
de DB2 Express-C . . . . . . . . . . . . . . . . . . . . . 92
5.0.18. Características No Disponibles con DB2 Express-C . . . 94
5.0.19. Productos Pagados Relacionados con DB2 . . . . . . . . 96
5.0.20. Guía de Instalación de DB2 Express C . . . . . . . . . . 97
5.0.21. Herramientas de DB2 . . . . . . . . . . . . . . . . . . . 102
6. Eclipse 109
ÍNDICE GENERAL
6.1. ¿Que es Eclipse? . . . . . . . . . . . . . . . . . . . . . . . . . . 109

6.2. ¿Como Utilizar Eclipse? . . . . . . . . . . . . . . . . . . . . . . 110
7. Tomcat 114
7.1. Descripción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
7.2. Entorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
7.3. Estado de su Desarrollo . . . . . . . . . . . . . . . . . . . . . . 115
7.4. Estructura de Directorios . . . . . . . . . . . . . . . . . . . . . 115
7.5. Características del Producto . . . . . . . . . . . . . . . . . . . . 115
7.6. Historia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8. Descripción de la Aplicación 118

8.1. Descripción General . . . . . . . . . . . . . . . . . . . . . . . . 118
8.2. Análisis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
8.3. Desarrollo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.3.1. Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
8.3.2. Ganadería . . . . . . . . . . . . . . . . . . . . . . . . . . 130
8.3.3. Empleados . . . . . . . . . . . . . . . . . . . . . . . . . 135
8.3.4. Bancos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
8.3.5. Clientes . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
8.3.6. Proveedores . . . . . . . . . . . . . . . . . . . . . . . . . 139
8.3.7. Consultas . . . . . . . . . . . . . . . . . . . . . . . . . . 140
8.3.8. Planillas . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
8.4. Estructura de Datos . . . . . . . . . . . . . . . . . . . . . . . . 142
8.5. Ejemplos de Código Fuente Utilizados . . . . . . . . . . . . . . 158
8.5.1. Servlets y HTML embebido . . . . . . . . . . . . . . . . 158
9. Conclusiones 171
9.1. Conclusiones Acerca de las Tecnologías y Software Utilizados . 171
9.2. Líneas Futuras de Acción . . . . . . . . . . . . . . . . . . . . . 172
Bibliografía 173
Índice alfabético 174

Índice de figuras
1.1. La Agricultura Ayer y Hoy. . . . . . . . . . . . . . . . . . . . . 3

1.2. Distintos Dispositivos Tecnológicos Utilizados en la Agricultura. 4
1.3. La Agricultura de Precisión. . . . . . . . . . . . . . . . . . . . . 5
1.4. Ganadería de Corral. . . . . . . . . . . . . . . . . . . . . . . . . 7
1.5. Ganadería Extensiva e Intensiva. . . . . . . . . . . . . . . . . . 10
2.1. Logo de Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.2. Arquitectura Cliente - Servidor. . . . . . . . . . . . . . . . . . . 24
2.3. Bytecode y JVM. . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4. Netscape Navigator - Internet Explorer. . . . . . . . . . . . . . 27
2.5. JIT - Just In Time. . . . . . . . . . . . . . . . . . . . . . . . . 28
2.6. HotJava. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.7. Clase Thread. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.1. Herencia en Java. . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.2. Típicos Packages Predefinidos. . . . . . . . . . . . . . . . . . . 41
3.3. API de Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.4. JDBC en Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.1. Ciclo de Vida de un Servlet. . . . . . . . . . . . . . . . . . . . . 77

4.2. Requerimiento de un Archivo JSP. . . . . . . . . . . . . . . . . 79
4.3. Requerimiento de un Servlet. . . . . . . . . . . . . . . . . . . . 80
5.1. Servidores DB2. . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

5.2. Réplica de SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . 94
5.3. DB2 Connect. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
5.4. WebSphere Federation Server. . . . . . . . . . . . . . . . . . . . 98
5.5. Ventana de Progreso en DB2. . . . . . . . . . . . . . . . . . . . 101
5.6. Herramientas DB2. . . . . . . . . . . . . . . . . . . . . . . . . . 102
5.7. Herramientas DB2: Menú Inicio. . . . . . . . . . . . . . . . . . 103

ÍNDICE DE FIGURAS
5.8. Centro de Control de DB2. . . . . . . . . . . . . . . . . . . . . 104

5.9. Icono DB2 en Windows. . . . . . . . . . . . . . . . . . . . . . . 106
5.10. Editor de Comandos. . . . . . . . . . . . . . . . . . . . . . . . . 106
5.11. Botón Show SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . 107
5.12. Salida de un Botón Show SQL. . . . . . . . . . . . . . . . . . . 108
8.1. Diagrama de Contexto . . . . . . . . . . . . . . . . . . . . . . . 119

8.2. Caso de Uso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.3. Página Principal de la Aplicación. . . . . . . . . . . . . . . . . 120
8.4. Formulario de Agricultura. . . . . . . . . . . . . . . . . . . . . 122
8.5. Formulario de Carga Cosecha a Terceros. . . . . . . . . . . . . 123
8.6. Formulario de Carga Siembra Propia. . . . . . . . . . . . . . . 124
8.7. Formulario de Carga Rollos Propios. . . . . . . . . . . . . . . . 125
8.8. Formulario de Modificar Máquinas. . . . . . . . . . . . . . . . . 126
8.9. Formulario de Carga Pulverizaciones a Terceros. . . . . . . . . 127
8.10. Formulario de Carga Campos Propios. . . . . . . . . . . . . . . 128
8.11. Principal de Insumos. . . . . . . . . . . . . . . . . . . . . . . . 129
8.12. Principal de Ventas. . . . . . . . . . . . . . . . . . . . . . . . . 130
8.13. Pantalla Principal de Ganadería. . . . . . . . . . . . . . . . . . 131
8.14. Pantalla Principal de la Sección Ganado. . . . . . . . . . . . . . 132
8.15. Formularios de Vacunación y Baño de Ganado. . . . . . . . . . 133
8.16. Formulario de Carga de Inseminaciones de Ganado. . . . . . . . 134
8.17. Formularios de Reproducción y Balanza. . . . . . . . . . . . . . 135
8.18. Página Principal de Empleados. . . . . . . . . . . . . . . . . . . 136
8.19. Página Principal del Módulo Bancos. . . . . . . . . . . . . . . . 137
8.20. Operaciones Financieras. . . . . . . . . . . . . . . . . . . . . . . 138
8.21. Principal de Clientes. . . . . . . . . . . . . . . . . . . . . . . . . 139
8.22. Principal de Proveedores. . . . . . . . . . . . . . . . . . . . . . 140
8.23. Ejemplos de Listados Arrojados por el Sistema. . . . . . . . . . 141
8.24. Ejemplo de Planillas Disponibles en el Sistema. . . . . . . . . . 142
8.25. Estructura de la Base de Datos. . . . . . . . . . . . . . . . . . . 143
8.26. Tablas de la Base de Datos SAG. . . . . . . . . . . . . . . . . . 158
Índice de cuadros
3.1. Tipos de Variables. . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.2. Categorías de Variables. . . . . . . . . . . . . . . . . . . . . . . 43
3.3. Tipos Primitivos de Variables. . . . . . . . . . . . . . . . . . . . 44
3.4. Operadores de Asignación. . . . . . . . . . . . . . . . . . . . . . 46
3.5. Operadores Relacionales. . . . . . . . . . . . . . . . . . . . . . . 47
3.6. Precedencia de Operadores. . . . . . . . . . . . . . . . . . . . . 49
5.1. Comandos Para Iniciar Algunas Herramientas DB2. . . . . . . 103

Capítulo 1
La Agro-Ganadería en la
Actualidad
1.1. La Agricultura y la Ganadería en el Mundo y

en Argentina
Los diversos avances tecnológicos derivados del conocimiento y la ciencia

están siendo aplicados en varios países del mundo a distintos sectores nunca
antes imaginados, entre ellos el sector de la agricultura y la ganadería en
Argentina. A esto se le suma el empleo de herramientas con tecnología de
avanzada que ya se encuentran a disposición de todos en cualquier momento y
lugar que se la requiera, para poder de esta forma mantener la competitividad
a nivel mundial con una producción sustentable en el tiempo.
1
CAPÍTULO 1. LA AGRO-GANADERÍA EN LA ACTUALIDAD 2
En la actualidad Argentina está obteniendo importantes logros en los sec-

tores de agricultura y ganadería ya que se basan en la incoporación de tec-
nologías adaptadas exitosamente a la realidad.
1.2. La Agricultura, la Máquina Reemplaza al Mús-

culo
Anteriormente la actividad agrícola se realizaba con la indispensable ayuda

del hombre como herramienta principal para ésta actividad, ya que mediante
el mismo se hacía el trabajo en la tierra a mano o traccionado por animales.
Hoy en día con la aparición de la maquinaría agrícola, exigentes tareas como
la de sembrar y cosechar se pueden realizar de una manera rápida a una escala
nunca antes imaginable.
Según la Academia Internacional de Ingeniería de EE.UU, la mecanización
agraria es uno de los 20 mayores logros de la ingeniería del siglo XX. A princi-
pios del siglo XX, se necesitaba un granjero para alimentar de 2 a 5 personas,
mientras que hoy, gracias a la tecnología, los agroquímicos y las variedades de
cultivos actuales, un granjero puede alimentar a 130 personas.
Además de los avances tecnológicos, como se puede observar en la figura
8.4 de la página 122, también se le suman medios de comunicación, servicio
meteorológico y estudios de mercado que hacen que el crecimiento del sector
agrícola sea exponencial [1].
Figura 1.1: La Agricultura Ayer y Hoy.
Las maquinarias que actualmente se utilizan ya traen incoporados dispo-

sitivos tecnológicos de una alta gama, permitiendo de ésta forma tener agri-
cultura de precisión, como por ejemplo:
GPS (Global Positioning System).
Banderilleros satelitales.
Computadoras de pulverización.
Higrómetros (miden el grado de humedad).
Monitores de siembra.
Balanzas electrónicas.
Humedímetros y cuenta hectáreas.
Software de mapeo.
Sistemas de gestión para el agro.

Figura 1.2: Distintos Dispositivos Tecnológicos Utilizados en la Agricultura.
1.2.1. Agricultura de Precisión
Consiste en determinar qué requerimientos tienen los suelos, y en qué sitios,

y luego poner exactamente la cantidad necesaria de semilla, fertilizante o agro-
químicos en el lugar preciso y junto a éstas herramientas poder tomar las cor-
rectas decisiones de manejo acerca del tipo de cultivo a realizar, sus rotaciones
y fechas de siembra.
Hacer Agricultura de Precisión, es hacer lo que siempre se ha estado ha-
ciendo pero ahora con mucha mayor precisión, con mucha más información
sobre la parcela y sus características.
Normalmente los agricultores ya tienen una idea de que áreas de su campo
tienen los rendimientos más altos y bajos, pero los trabajos de investigación
en la actualidad han mostrado que aún las tierras de altos rendimientos tienen
condiciones de suelo variables que producen rendimientos variables.
La Agricultura de Precisión usa la Tecnología para medir los rendimientos,
determinar las condiciones del suelo y obtener información de cada parte del
campo, registrando la ubicación exacta de donde proviene cada dato obtenido.
Cada dato de: rendimiento, humedad del grano cosechado, nutrientes del suelo,
etc., puede ser llevado a un mapa generado por la computadora, que permite
ver más claramente la relación entre varios factores. Luego puede usar la in-
formación de estos mapas para determinar los tipos, cantidades, y ubicación
de insumos a aplicar.
Sin embargo, hasta ahora no era posible estudiar cada uno de estos factores
debido a que no existía la tecnología necesaria para ello. Gracias al desarrollo
de lo que conocemos como “nuevas tecnologías” se puede acometer hoy
día el estudio y la gestión de una explotación agrícola de forma integral, con-
siderando el uso de agroquímicos localizada a la zona que realmente hace falta
y a la dosis correcta.
Figura 1.3: La Agricultura de Precisión.
La Agricultura de Precisión utiliza la tecnología con un objetivo claro

“Que los productores tienen ahora la posibilidad de medir exactamente qué
está sucediendo en su campo, tomar decisiones más acertadas, basadas en este
conocimiento, y así mejorar la eficiencia”.
1.3. La Evolución de la Ganadería
La Ganadería es una actividad económica de origen muy antiguo que con-

siste en la crianza de animales para su aprovechamiento. La Argentina ocupa
un importante lugar en el mundo como país ganadero, en lo que se refiere a
bovinos (el quinto lugar por sus existencias y el tercero como Productor de
carne) lo cual le dá una importancia aún mayor.
Mediante la selección y el cruzamiento genético se asegura la calidad de las
razas de bovinos Shorthorn, Heresford, Aberdeen Angus y Holando argentino

(para leche); y de ovinos: Merino, Corriedale y Lincoln. En la región Pampeana
se concentra la producción de vacunos, porcinos y equinos. El ovino prevalece
en la Patagonia.
La producción ganadera como sector importantísimo en la economía ar-

gentina, tiene además a procesos fundamentales dentro de la cadena como la
refrigeración y procesamiento de carne y subproductos, ya que la producción
anual supera los 3,4 millones de toneladas.
Desde hace mucho tiempo, Argentina es líder mundial en la exportación
de carne cruda, aunque cada vez es más importante la exportación de la carne
procesada y envasada. Por este motivo la incorporación de la tecnología es un
factor importante a la hora de incrementar las producciones de carne, mediante
la utilización del rendimiento expuesto al máximo en sectores como:
La nutrición animal.
La sanidad animal.
La genética e inseminación artificial.
El uso de aplicaciones informáticas para la gestión.
Las tecnologías para la protección del medio ambiente.
Los edificios, equipos y materiales para el ganado.
La logística, manipulación y almacenamiento.
La estabulación del ganado y el desarrollo de nuevas técnicas de alimen-

tación han contribuido para disminuir la dependencia de las condiciones del
medio ambiente. Como principales pautas de manejo que permitien el crec-
imiento se mencionan técnicas a las que se califica de aplicación sencilla y de
alto impacto, como:
La implantación de pasturas.
La fertilización.
La subdivisión de las grandes extensiones en parcelas para un uso más

eficiente.
El adecuado manejo de los rodeos.
Figura 1.4: Ganadería de Corral.
Actualmente la ganadería ocupa más de 105 millones de hectáreas, mien-

tras que la agricultura no supera los 25 millones en el territorio nacional. De
allí la preocupación por la sustentabilidad de los sistemas. Esto se debe a que
en promedio para cada animal se necesita 10 hectáreas para su producción.
Además el ganado puede ser criado en áreas donde el duro clima imposibilita
el crecimiento de los cultivos, como en las altas montañas o las zonas con una
aridez extrema.
1.3.1. Ganadería Extensiva e Intensiva
Ganadería Extensiva
Los sistemas extensivos, tradicionales o convencionales de producción ani-

mal se caracterizan esencialmente por formar parte de un ecosistema natural
modificado por el hombre, es decir, un agroecosistema, y tienen como objetivo
la utilización del territorio de una manera perdurable, o sea, están sometidos
a los ciclos naturales, mantienen siempre una relación amplia con la produc-
ción vegetal del agroecosistema de que forman parte y tienen la necesidad de
legar a la generación siguiente los elementos del sistema en un estado igual o

superior que los que se recibieron de la generación precedente.
Dentro de la ganadería extensiva se puede incluir a la ganadería sostenible

que es la ganadería perdurable en el tiempo y que mantiene un nivel de produc-
ción sin perjudicar al medio ambiente o al ecosistema. La ganadería sostenible
se incluye dentro del concepto de desarrollo sostenible.
La explotación ganadera para la alimentación del ganado utiliza los apro-

vechamientos a diente de los pastos procedentes de prados, pastizales, hierbas
y rastrojos; propios, ajenos o comunales, de forma permanente o temporal.
Ventajas de la Ganadería Extensiva
Requieren un escaso aporte de energía fósil, en ocasiones se requiere 0,1

kilo o menos para obtener 1 kilo de alimento en la mesa del consumidor.
Contribuyen a mantener los agroecosistemas de los que forman una parte

esencial, manteniendo los agroecosistemas naturales del entorno, como
la biodiversidad.
En climas áridos o semiáridos contribuyen al mantenimiento de la cu-

bierta vegetal, es decir, evitar la erosión.
Prevenir los incendios forestales mediante el control arbustivo, la reduc-

ción de biomasa combustible, etc.
Inconvenientes de la Ganadería Extensiva
Menor eficiencia.
No pueden ajustarse fácilmente a la demanda de los consumidores.
No pueden proporcionar productos tan homogéneos como solicita la dis-

tribución y el mercado de las grandes superficies comerciales.
Ganadería Intensiva
En la ganadería intensiva el ganado se encuentra estabulado, generalmente

bajo condiciones de temperatura, luz y humedad que han sido creadas en forma
artificial, con el objetivo de incrementar la producción en el menor lapso

de tiempo; los animales se alimentan, principalmente, de alimentos enriqueci-
dos. Es por esto que requiere grandes inversiones en aspectos de instalaciones,
tecnología, mano de obra y alimento, entre otros.
Entre sus ventajas se destaca una elevada productividad, que tiene co-
mo contraparte la gran contaminación que genera, mediante la aplicación de
múltiples tecnologías y las formas de pensamiento surgidas del capitalismo.
Ventajas de la Ganadería Intensiva
Eficiencia: La ganadería intensiva obtiene la máxima producción con el

dinero invertido en el menor tiempo posible.
Adaptación a la demanda del mercado (consumidores).
Homogeneidad: Es la obtención de productos homogéneos o de caracte-

rísticas iguales, para satisfacer las necesidades de la distribución y com-
ercialización a gran escala.
Inconvenientes de la Ganadería Intensiva:
Gran consumo de energía, generalmente de procedencia energía fósil, en

ocasiones hasta 20 kilos por kilo del alimento obtenido.
Extremadamente contaminantes, debido a la acumulación de enormes

masas de deyecciones, que no pueden ser recicladas en los agrosistemas
convencionales y que provocan la contaminación atmosférica, la conta-
minación del suelo y de las aguas con metales pesados, fármacos etc.
Efímero: La ganadería intensiva no es perdurable, es decir, es “insos-

tenible”, que implica que no puede mantenerse indefinidamente en el
tiempo.
Figura 1.5: Ganadería Extensiva e Intensiva.
El Feed - Lot (engorde a corral), como se observa en la figura 1.5 de la

página 10, es uno de los claros ejemplos de esta ganadería ya que obtiene
el máximo beneficio, en el menor tiempo posible, concentrando los medios de
producción y mecanizando y racionalizando los procesos, para incrementar
constantemente el rendimiento productivo, mediante la utilización de la tec-
nología e infraestructura disponible en el mercado.
Capítulo 2
Conceptos Básicos Sobre el

Lenguaje Java
2.1. ¿Qué es Java y Para qué fue Pensado?
Java es un lenguaje de programación sencillo de aprender que original-

mente fue desarrollado por un equipo de ingenieros de Sun Microsystems, uti-
lizado por Netscape, por nuevas necesidades, ya que los lenguajes existentes
no cumplían con todas las necesidades para el proyecto en marcha. Pero se
basaron en lo ya hecho y probado. Es por esta razón que el código Java se
expresa en archivos de texto comunes, y tiene una apariencia muy familiar
para los programadores de C/C++ y para los programadores en general [2].
Los creadores de Java partieron de la sintaxis de C++ pero “simplificada”
y trataron de eliminar todo lo que resulte complicado, o permita fuente de
errores.
Java nace en un intento de resolver simultáneamente los problemas que

se planteaban los desarrolladores de software por la difusión de arquitecturas
incompatibles, tanto entre las diferentes máquinas como entre los diversos
sistemas operativos y sistemas de ventanas que funcionaban sobre una misma
máquina, incrementando la dificultad de crear aplicaciones distribuidas en la
Red [2].
El uso del lenguaje Java se destaca en la Web pero sirve para crear todo
tipo de aplicaciones (locales, Intranet o Internet). Java sirvió posteriormente
11
CAPÍTULO 2. CONCEPTOS BÁSICOS DE JAVA 12
Figura 2.1: Logo de Java.
como base para JavaScript, que se detallará más adelante .

Una de las utilizaciones más difundida, que justifica a Java como lenguaje
es en pequeños electrodomésticos como microondas, tostadoras y, fundamen-
talmente, televisión interactiva y otros dispositivos electrónicos de uso diario,
como celulares, PDA’s, palms y pocket pc.
2.1.1. Características del Lenguaje Java
Las principales son:
Orientado a objetos.
Simple.
Distribuido.
Flexible.
Independiente de la plataforma.
Robusto.
Gestiona la memoria automáticamente.

No permite el uso de técnicas de programación inadecuadas.
Multithreading.
Cliente-servidor.
Mecanismos de seguridad incorporados.
Herramientas de documentación incorporadas.
2.1.2. Desarrollo de las Principales Características de Java
Las principales características que ofrece el lenguaje Java respecto a cual-

quier otro lenguaje son:
Es un lenguaje Orientado a Objetos.
Posiblemente el más orientado a objetos de todos los lenguajes existentes;

en Java todo, a excepción de los tipos fundamentales de variables (int, char,
long), es un objeto.
Las plantillas de objetos son llamadas, como en C++, clases y sus copias,
instancias. Estas instancias, como en C++, necesitan ser construidas y destru-
idas en espacios de memoria.
Los objetos se definen en clases, con atributos y métodos, agrupándose en
paquetes, y exponiendo interfaces a esos objetos. Soporta las tres característi-
cas propias del paradigma de la orientación a objetos: encapsulación, herencia
y polimorfismo, implementando así la tecnología de objetos de una manera
muy completa, y a la vez sencilla y agradable.
Se reconocerá al estudiar la semántica, que Java es realmente un lenguaje
que merece ser llamado “totalmente orientado a objetos”.
Java incorpora funcionalidades inexistentes en C++, como por ejemplo,
la resolución dinámica de métodos. En C++ se suele trabajar con librerías
dinámicas (DLL’s) que obligan a recompilar la aplicación cuando se retocan
las funciones que se encuentran en su interior. Este inconveniente es resuel-
to por Java mediante una interfaz específica llamada RTTI (RunTime Type
Identification) que define la interacción entre objetos excluyendo variables de
instancias o implementación de métodos.
Las clases en Java tienen una representación en el runtime que permite a

los programadores interrogar por el tipo de clase y enlazar dinámicamente la
clase con el resultado de la búsqueda.
Es simple.
Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las ca-
racterísticas menos usadas y más confusas de éstos. C++ es un lenguaje que
padece falta de seguridad, pero C y C++ son lenguajes más difundidos, por
ello Java se diseñó para ser parecido a C++ y así facilitar un rápido y fácil
aprendizaje.
Java elimina muchas de las características de otros lenguajes como C++,

para mantener reducidas las especificaciones del lenguaje y añadir caracterís-
ticas muy útiles.
Java reduce en un 50 % los errores más comunes de programación con
lenguajes como C y C++ al eliminar muchas de las características de éstos.
Es distribuido.
Está orientado al trabajo en red, soportando protocolos como TCP/IP,

HDP, HTTP y FTP. Por otro lado el uso de estos protocolos es bastante
sencillo comparándolo con otros lenguajes que los soportan.
Java se ha construido con extensas capacidades de interconexión TCP/IP.
Existen librerías de rutinas para acceder e interactuar con protocolos como
HTTP y FTP. Esto permite a los programadores acceder a la información a
través de la red con tanta facilidad como a los ficheros locales.
La verdad es que Java en sí no es distribuido, sino que proporciona las
librerías y herramientas para que los programas puedan ser distribuidos, es
decir, que se corran en varias máquinas.
Es robusto.
Se refiere a la forma en que está diseñado ya que el compilador de Java

detecta muchos errores que otros compiladores sólo detectarían en tiempo
de ejecución o incluso nunca. El código generado por el compilador Java es
independiente de la arquitectura, o sea, puede ejecutarse en un entorno

Unix, Mac o Windows.
Java no permite el manejo directo del hardware ni de la memoria, así

virtualmente es imposible colgar un programa Java. El intérprete siempre tiene
el control. Inclusive el compilador es suficientemente inteligente como para no
permitir cosas que causen problemas, como usar variables sin inicializarlas,
modificar valores de punteros directamente, acceder a métodos o variables en
forma incorrecta, utilizar herencia múltiple, etc.
Posee herramientas de documentación incorporadas.
Además, con el JDK (Java Development Kit) vienen incorporadas muchas

herramientas, entre ellas un generador automático de documentación que, con
un poco de atención al poner los comentarios en las clases, crea inclusive toda
la documentación de las mismas en formato HTML.
Es Seguro.
Los problemas de virus, o de confidencialidad de los datos aparecen masi-

vamente con Internet, y con la distribución de programas por todas las redes,
así el problema de la seguridad ha tomado una nueva dimensión, más grave,
ya que actualmente a nuestra máquina pueden llegar aplicaciones hostiles y
virus malignos, desde cualquier parte del mundo.
Java ha sido adaptado a Internet, pensando mucho en el tema seguridad,
sobre todo un tipo de desarrollo: los applets. Java garantiza que ningún applet
puede escribir o leer de nuestro disco o mandar información del usuario que
accede a la página a través de la red (ej.: e-mail).
Un applet Java se ejecuta en un entorno, que impide su intromisión en la
máquina cliente. En general no permite realizar cualquier acción que pudiera
dañar la máquina o violar la intimidad de quien visita la página Web. Entonces,
no hay posibilidad de un virus Java, viajando por toda la red.
Java implementa mecanismos de seguridad que limitan el acceso a recursos
de las máquinas donde se ejecuta, especialmente en el caso de los Applets
(aplicaciones que se cargan desde un servidor y se ejecutan en el cliente).
También está diseñado específicamente para trabajar sobre una red, de modo
que incorpora objetos que permiten acceder a archivos en forma remota (via
URL por ejemplo).
Es Portable (multiplataforma).
En Java no hay aspectos dependientes de la implementación, todas las im-

plementaciones de Java siguen los mismos estándares en cuanto a tamaño y
almacenamiento de los datos y corren de igual forma bajo distintas platafor-
mas, mientras que otros lenguajes almacenan datos de formas diferentes según
la plataforma en la que se encuentre.
Esto no sucede con Java ya que el proceso de compilación no produce

código para un procesador en particular, como en los compiladores C/C++,
sino que genera código para un procesador ideal, denominado Máquina Virtual
Java (Java Virtual Machine, o Java VM). La razón de ésto es la necesidad
de poder ejecutarse en cualquier plataforma, sin necesidad de cambiar el
código fuente, ni aun de recompilar.
Todo programa Java se traduce en una serie de códigos (llamados bytecodes

que son el resultado de la compilación de un programa Java) para un proce-
sador imaginario (virtual), el Java VM, que puede ser implementado fácilmente
en cualquier plataforma poderosa. Es así como el lenguaje y sus aplicaciones se
independizan de la máquina destino, a costa de algo de velocidad, provocada
por la necesidad de “simular ” la Java VM, mediante software.
Aún los tipos primitivos de datos quedan definidos de un solo paso, para
todas las plataformas. Se evitan de esta forma los problemas de portabili-
dad, conocidos por los programadores de C/C++, al cambiar, por ejemplo,
de ambiente a ambiente, el tamaño de los enteros, o el conjunto de caracte-
res soportados. En Java, esos problemas no existen: sólo existe una máquina
virtual.
Los programas en Java pueden ejecutarse en cualquiera de las siguientes
plataformas, sin necesidad de hacer cambios:
Windows/95 y /NT.
Power/Mac.
Unix (Solaris, Silicon Graphics, ...).
La compatibilidad es total:
A nivel de fuentes: el lenguaje es exactamente el mismo en todas las

plataformas.
A nivel de bibliotecas: en todas las plataformas están presentes las mismas

bibliotecas estándares.
A nivel del código compilado: el código intermedio que genera el compilador

es el mismo para todas las plataformas. Lo que cambia es el intérprete del
código intermedio.
Manejo automático de memoria.
El lenguaje Java se compone de objetos y estos pueden y deben crearse;

tienen una vida corta, ya que se inicia con la ejecución y dura hasta que se
termina la ejecución, donde es su destrucción.
Mientras que la creación de los objetos se deja bajo la voluntad del pro-
gramador, la destrucción definitiva de un objeto ocurre cuando no es más
referenciado por otros objetos del programa. De esta forma, se elimina una de
las causas más comunes de error en otros lenguajes, como la destrucción por
el programador de objetos aún en uso en el programa, o la falta de destrucción
de objetos que ya son inútiles, ya que no se usan en el resto de la ejecución,
pero que molestan con empleo de recursos.
Esta técnica de manejo automático de memoria ocupada por los objetos

se denominan garbage collection, es como recolección de basura o reciclador
de memoria dinámica; gracias a ésto no es necesario preocuparse de liberar
memoria, el reciclador se encarga de ello y como es un thread de baja prioridad,
cuando entra en acción, permite liberar bloques de memoria muy grandes, lo
que reduce la fragmentación de la memoria.
El recolector de basuras es un gran aporte a la productividad. Se ha es-
tudiado en casos concretos que los programadores han dedicado un 40 % del
tiempo de desarrollo a determinar en qué momento se puede liberar un trozo
de memoria.
En una aplicación Java hay siempre un proceso, ejecutado como un “thread”
o hilo de ejecución separado, que se ocupa de recorrer la memoria donde se
encuentran los objetos, y determina cuáles pueden liberarse y destruirse.
En Java los programadores ya no necesitan preocuparse de liberar un tro-
zo de memoria cuando no lo necesitan. Es el recolector de basuras el que
determina cuando se puede liberar la memoria ocupada por un objeto.
Java no se aísla y evoluciona.
Java trata de ser un lenguaje de producción, no un lenguaje académico o

ideal, entonces no intenta comunicarse con librerías de otros lenguajes. Tiene
capacidades definidas para implementar clases y métodos (o funciones), es-
critos, por ejemplo, en C/C++. Esto permite usar lo que ya está hecho, en
cada plataforma de implementación.
Igualmente, Java es un lenguaje de uso general, y muchas de las rutinas y
librerías que se necesita para un proyecto, pueden ser escritas en Java. Debido
al éxito del lenguaje, y a su difusión, cada día aparecen nuevas herramientas
y paquetes de clases escritas por otros programadores.
Dinámico.
Java se beneficia todo lo posible de la tecnología orientada a objetos. Java

no intenta conectar todos los módulos que comprenden una aplicación hasta
el tiempo de ejecución.
Las librería nuevas o actualizadas no paralizarán las aplicaciones actuales.
Java también simplifica el uso de protocolos nuevos o actualizados. Si el sis-
tema ejecuta una aplicación Java sobre la red y encuentra una pieza (módulo)
de la aplicación que no sabe manejar, Java es capaz de traer automáticamente
cualquiera de esas piezas que el sistema necesita para funcionar.
Para evitar que los módulos de bytecodes o los objetos o nuevas clases,
tengan que ser traídos de la red cada vez que se necesiten, se implementan las
opciones de persistencia, para que no se eliminen cuando se limpie la caché de
la máquina.
2.1.3. Ventajas de Java
1. No se vuelve a escribir el código si se quiere ejecutar el programa en

otra máquina (multiplataforma). Un solo código funciona para todos los
browsers compatibles con Java o donde se tenga una Máquina Virtual
de Java (Mac’s, PC’s, Sun’s, etc).
2. Java es un lenguaje de programación orientado a objetos, y tiene todos

los beneficios que ofrece esta metodología de programación..
3. Un browser compatible con Java deberá ejecutar cualquier programa he-

cho en Java, esto ahorra a los usuarios tener que estar insertando “plug-
ins” y demás programas que a veces quitan tiempo y espacio en disco.
4. Java es un lenguaje y por lo tanto puede hacer todas las cosas que puede
hacer un lenguaje de programación: cálculos matemáticos, procesadores
de palabras, bases de datos, aplicaciones gráficas, animaciones, sonido,
hojas de cálculo, etc.
5. Si lo que interesa son las páginas Web, no tienen que ser estáticas, porque
se les pueden poner toda clase de elementos multimedia, permitiendo un
alto nivel de interactividad, sin tener que invertir tanto en paquetes de
multimedia.
2.1.4. Limitaciones con Java
1. Una de las más importantes es la velocidad. Los programas hechos en

Java no tienden a ser muy rápidos, pero se está trabajando para mejorar
esto. Como los programas de Java son interpretados nunca alcanzan la
velocidad de un verdadero ejecutable.
2. Java es un lenguaje de programación. Por tratarse de un lenguaje, debe

ser aprendido, lo que es una dificultad para los no programadores.
3. Java es relativamente nuevo. Todavía no se conocen bien todas sus ca-

pacidades.
Pero en general, Java posee muchas ventajas y mucha fuerza. Con este
lenguaje se pueden hacer muchas cosas interesantes. Está de moda en cualquier
medio computacional, y se apuesta a futuro con Java.
2.1.5. Errores con Java
En Java no se pueden cometer algunos errores típicos, ya que:
• Java siempre chequea los índices al acceder a un arreglo.

• Java realiza chequeo de tipos durante la compilación (al igual que

C). En una asignación entre punteros el compilador verifica que los
tipos sean compatibles.
• Además, Java realiza chequeo de tipos durante la ejecución (cosa
que C y C++ no hacen). Cuando un programa usa un cast para
acceder a un objeto como si fuese de un tipo específico, se verifica
durante la ejecución que el objeto en cuestión sea compatible con
el cast que se le aplica. Si el objeto no es compatible, entonces se
levanta una excepción que informa al programador la línea exacta
en donde está la fuente del error.
• Java posee un recolector de basuras que administra automática-
mente la memoria. Es el recolector el que determina cuando se
puede liberar el espacio ocupado por un objeto. El programador no
puede liberar explícitamente el espacio ocupado por un objeto.
• Java no posee aritmética de punteros, porque es una propiedad que
no se necesita para programar aplicaciones. En C sólo se necesita
la aritmética de punteros para programar malloc/free o para pro-
gramar el núcleo del sistema operativo.
Por lo tanto Java no es un lenguaje para hacer sistemas operativos o

administradores de memoria, pero sí es un excelente lenguaje para programar
aplicaciones.
2.2. Existen Distintos Tipos de Java
Según donde se lo aplique se puede distinguir entre:
2.2.1. JavaScript
Es una versión de Java directamente interpretada, que se incluye como

parte de una página HTML, lo que lo hace muy fácil y cómodo para aplica-
ciones muy pequeñas, pero en realidad tiene muchas limitaciones:
No soporta clases ni herencia.
No se precompila.
No es obligatorio declarar las variables.

Verifica las referencias en tiempo de ejecución.
No tiene protección del código, ya que se baja en ASCII.
No todos los browsers lo soportan completamente.
JavaScript es una forma de trasladar algunas tareas simples al lado del

cliente. Y tiene una sintaxis que es en general parecida a la de C, excepto que
no hay una función main. Lo que no está dentro de una función se ejecutará
mientras se cargue la página.
JavaScript recibe información a através de eventos y propiedades de obje-

tos, y la entrega mediante propiedades de objetos y métodos.
2.2.2. Java Standalone
Son programas Java que se ejecutan directamente mediante el intérprete

Java.
2.2.3. Applets
Son programas Java que corren bajo el entorno de un browser (o del ap-
pletviewer, que es el visualizador de applets de Sun.)
En sí los applets y Java standalone son el mismo lenguaje, pero cambia un
poco la forma en que se implementa el objeto principal (la aplicación).
Así los “applets” de una web, son programas diseñados para ser ejecutados
en una página Web; pueden ejecutarse en cualquier máquina que se conecte
a ella independientemente de qué sistema operativo emplee (siempre que el
ordenador en cuestión tenga instalada una JVM (Máquina Virtual de Java)).
La definición más extendida de applet, indica que un applet es “una pe-
queña aplicación accesible en un servidor Internet, que se transporta por la
red, se instala automáticamente y se ejecuta en ese lugar como parte de un
documento web”. La definición establece el entorno (Internet, Web, etc.).
Un applet trata de ser una aplicación pretendidamente corta (no ocupar
más de un gigabyte) basadándose en un formato gráfico sin representación
independiente: es decir, es un elemento a embeber en otras aplicaciones (es un

componente en el sentido estricto).
Appletviewer: El Visor de Applets de Sun
El visualizador de applets (appletviewer) es una aplicación que permite

ver en funcionamiento applets, sin necesidad de la utilización de un navegador
World-Wide-Web como HotJava, Microsoft Internet Explorer o Netscape.
El hecho de que se integre estática (embebido en un ejecutable) o dinámi-
camente (intérpretes, DLL’s, etc.) no afecta en absoluto a la esencia del com-
portamiento como componente.
Como no existe una base adecuada para soportar aplicaciones industri-
ales Java en las que insertar miniaplicaciones; los applets se han construido
mayoritariamente, y con gran acierto comercial, como pequeñas aplicaciones
interactivas, con movimiento, luces y sonido... en Internet.
Llamadas a Applets con Appletviewer
Dado que un applet es una míni aplicación Java diseñada para ejecutarse
en un navegador Web, no necesita preocuparse por un método main() ni en
dónde se realizan las llamadas. Otra diferencia de Java con el lenguaje C. Es
que no hay función main, ya que los applets no lo necesitan. La función main
se encuentra “escondida” en el programa que cargó la página html. En los
applets no hay una función que sea llamada después de otra, sino que todo
gira en torno al tratamiento de los eventos que se produzcan. Es decir que
un applet está esperando por una serie de eventos, como la pulsación de una
tecla, el movimiento del ratón, o la pulsación de alguna de la teclas del ratón.
Y recibido el evento, responder con el método adecuado.El applet asume que
el código se está ejecutando desde dentro de un navegador.
El appletviewer se asemeja al míni navegador. Espera como argumento el
nombre del fichero HTML que debe cargar, no se le puede pasar directamente
un programa Java. Este fichero HTML debe contener una marca que especifica
el código que cargará el appletviewer.
2.3. Java en los Browsers de la World Wide Web
Los programas Java son otro recurso más, como pueden ser una página
HTML o un archivo gráfico. Al igual que estos últimos viajan desde el servidor
a la máquina cliente para ejecutarse en ésta. El lugar más frecuente donde se
encuentra el lenguaje Java, es en los exploradores o navegadores (browsers) de
Internet.
La WWW es la aplicación más popular en Internet, y causante de la ex-
plosión de la red de redes. Basa su existencia en dos principales aplicaciones:
Los servidores de Web.
Son programas dedicados e instalados en las máquinas nodos de la red, que

atienden a todos los pedidos de los clientes. Estos solicitan archivos, recursos
de la Web, en general, archivos HTML y gráficos. Los archivos HTML son
archivos de texto, que contienen una descripción de lo que se ve como página
en el browser. La sigla HTML significa Hypertext Markup Languaje (Lenguaje
de Marcación de Hipertexto), y es el lenguaje que describe las páginas Web.
Los clientes.
En las páginas se colocan textos, gráficos y otros recursos. Es trabajo del

cliente, el browser, interpretar esa página, mostrándola en pantalla, y recla-
mando todo lo que se necesite para armarla, como los gráficos y archivos de
sonido que la pueden acompañar.
En la figura 2.2 de la página 24 se muestra la arquitectura Cliente - Servi-
dor.
2.3.1. Las Applets en la Web
Al crear algún applet, se exige una construcción, con la marca HTML

‹APPLET...›, que especifica un determinado lugar en una página Web, para
que el browser se posicione y ejecute una aplicación Java. Los archivos Java que
viajan son de un tipo; al tratarse de archivos con extensión .class, contienen
las instrucciones Java ya compiladas y no viajan en código fuente.
Figura 2.2: Arquitectura Cliente - Servidor.
Un applet se compone, como mínimo, de un archivo .class, pero puede

requerir más archivos .class (con más código para ejecutar), que el browser
recupera, o archivos gráficos, de sonido u otros, que el propio applet se encarga
de recuperar.
Un applet Java no existe por sí mismo (sino dentro de una página .html ),
por esto se lo debe invocar desde una página HTML que se haya creado.
Seguridad
Puede ser riesgoso, por la naturaleza de Internet, traer programas desde

un lugar lejano y no controlado a la computadora, para ejecutarlo.
Pero los applets Java son seguros ya que Sun y los constructores de browsers
han implementado una polí tica de seguridad, que impide a un applet, por
ejemplo, leer o escribir en un disco, o interferir con otras aplicaciones en eje-
cución.
Es tan grande la seguridad que, puede llegar a molestar a algunos progra-
madores, que en un applet nunca se pueda grabar un archivo local, con datos
transitorios o de configuración.
Restricción de Seguridad de Java
No se pueden cargar archivos que estén en una máquina distinta a aquella

desde la cual se cargó el applet. El applet se ejecuta en el cliente, e intenta
acceder a un archivo local. Eso provoca una excepción (que, por supuesto,
puede detectarse con un catch y tratarse).
Por razones de seguridad, los applets son más limitados que las aplicaciones
Java locales. Las políticas de seguridad las manejan los browsers (no Java), y
generalmente los límites que se imponen a los applets son:
Un applet no puede cargar bibliotecas (libraries) ni definir métodos na-

tivos.
No puede leer o escribir normalmente archivos en el cliente que lo carga

desde otro server.
No puede establecer conexiones de red, salvo al servidor del que proviene.
No puede arrancar programas en la máquina donde se está ejecutando.
No puede leer algunas propiedades del sistema.
En las ventanas de los applets se indica que se trata de un applet.
Pero también, pueden:
Reproducir sonidos.
Establecer conexiones con el servidor del que provienen.
Llamar fácilmente páginas HTML desde el browser.
Invocar métodos públicos de otros applets de la misma página.
Seguir corriendo aunque se cambie de página en el browser.
Si se cargan desde la máquina local no tienen ninguna de las restricciones

anteriores.
Figura 2.3: Bytecode y JVM.
En realidad, la especificación de Java permite que los applets lean archivos

en otras máquinas dando la URL completa; sin embargo, los browsers no lo
permiten.
2.3.2. Máquinas Virtuales
El lenguaje Java se compila, no para una plataforma o procesador en par-

ticular, sino produciendo código (que se denomina bytecodes), destinado a ser
interpretado por la llamada Máquina Virtual Java.
En la figura 2.3 de la página 26 se puede apreciar como trabaja.
Esta máquina no es única, sino que hay una por cada plataforma y, en
realidad, cada browser que implementa Java tiene la suya. Así, el Microsoft
Explorer usará una máquina propia en Windows, mientras que el Netscape
Navigator usará otra máquina, que variará de Windows a UNIX.
Todas tienen la misma funcionalidad (o deberían). Tanto el usuario como
los programadores no deberían preocuparse por las distintas implementaciones.
Sin embargo, hay quejas de los desarrolladores, originadas en las pequeñas
diferencias que se encuentran tanto entre una implementación y otra, como en

el aspecto de la interface gráfica.
Además de la máquina virtual, cada browser instala una serie de clases, lis-
tas para usar, que Java espera tener disponibles en cualquier plataforma. Esas
clases tienen una funcionalidad definida, que no debería sufrir modificaciones.
Netscape y Microsoft
La empresa Netscape, creadora del Netscape Navigator, soporta Java desde

la versión 2 del browser. Pero Microsoft no se quedó atrás y soporta Java desde
la versión 2.0 de su browser Internet Explorer.
Ambos browsers instalan y usan una máquina virtual propia Java. No hay
diferencias apreciables en las prestaciones de estos dos browsers, respecto de
Java.
Figura 2.4: Netscape Navigator - Internet Explorer.
Entre Netscape (en múltiples plataformas) y Microsoft (en plataformas

Windows) acaparan casi la totalidad del mercado de los browsers.
En general, los browsers, de cualquier origen, soportan Java en ambientes

que permiten la multitarea y los llamados múltiples hilos de ejecución (multi-
threading).
Para poder explotar al máximo el potencial de Java se requiere de un
sistema operativo multithreading (como Unix, Windows, OS/2), porque Java
es un lenguaje interpretado y al compilar un programa Java, lo que se genera
es un seudocódigo definido por Sun, para una máquina genérica.
Al ejecutar posteriormente sobre una máquina en particular, el software
de ejecución Java simplemente interpreta las instrucciones, emulando a dicha
Figura 2.5: JIT - Just In Time.
máquina genérica. Claro que esto no es muy eficiente, entonces Netscape como
Hotjava o Explorer, al ejecutar el código por primera vez, lo van compilando
(mediante un JIT: Just In Time Compiler), así al crear el código ya está
compilado específicamente para la máquina huésped.
El lenguaje de esa máquina genérica es público, y si uno quisiera hacer un
intérprete Java para otro sistema operativo sólo tendría que implementarlo y
pedir a Sun la aprobación (que verifique que cumpla con los requisitos de Java
en interpretación de cada instrucción, seguridad y otros).
2.3.3. Java sin Browsers
No todo es Internet en Java. Este es un lenguaje de uso general, que sólo

incidentalmente cobró popularidad en Internet. Se puede desarrollar aplica-
ciones Java que se ejecuten en una máquina propia, sin necesidad de estar
conectados a la red, y sin el auxilio de browsers.
Mientras los programas Java para Internet y páginas HTML se llaman
“applets”, los que pueden ejecutarse fuera de la red se llaman genéricamente
“aplicaciones”.
2.3.4. HotJava
HotJava, es un navegador con soporte Java (Java-enabled), desarrollado

en Java.
Como cualquier navegador de Web, HotJava puede decodificar HTML es-

tándar y URL’s estándares, aunque no soporta completamente el estándar
HTML 3.0.
La ventaja sobre el resto de navegadores, sin soporte Java, es que puede
ejecutar programas Java sobre la red.
La diferencia con Netscape es que tiene implementados completamente los

sistemas de seguridad que propone Java, esto significa que puede escribir y leer
en el disco local, aunque esto hace disminuir la seguridad, ya que se pueden
grabar en el disco programas que contengan código malicioso o introducir un
virus, por ejemplo. No obstante, el utilizar esta característica de HotJava es
decisión del usuario.
Figura 2.6: HotJava.
2.4. Java en Hebras - Threads
La traducción literal de thread es hilo o hebra. Los threads (a veces lla-

mados, procesos ligeros), son básicamente pequeños procesos o piezas inde-
pendientes de un gran proceso. Pero el concepto de threads en los ambientes
y sistemas operativos es relativamente complejo de explicar: independiente-
mente del sistema elegido, se puede pensar que un thread es algo así como el
lugar de ejecución de un programa.
Java es multithreading: esto significa que tiene capacidad de “diálogo”, y

permite ejecutar muchas actividades simultáneas en un programa, es decir,
threads en paralelo como si fuera una conversación múltiple y simultánea.
No hay que confundir multithreading con la capacidad de ejecutar varios
programas a la vez. Esta es una posibilidad, pero también un mismo pro-
grama puede utilizar varios threads (caminos de ejecución) simultáneamente
y depende fundamentalmente de la capacidad del sistema operativo para so-
portar multithreading. Por esto Java no puede ejecutarse (al menos en forma
completa) en sistemas que no lo soporten.
Como los threads son construídos con el lenguaje Java, son más fáciles de
usar y más robustos que sus semejantes en C o C++.
El uso de threads nos permite, por ejemplo, ejecutar simultáneamente va-
rios programas que interactúen entre ellos; o, también, que un programa, mien-
tras por ejemplo actualiza la pantalla, simultáneamente realice una serie de
cálculos sin tener que hacer esperar el usuario.
Una forma sencilla de verlo es imaginar que se tiene un grupo de mi-
croprocesadores que pueden ejecutar, cada uno, un solo thread; y se asignan
programas (o partes de programas) a cada uno de ellos.
Además, se puede imaginar que los microprocesadores comparten una
memoria común y recursos comunes, de lo que surgirá una serie de proble-
mas importantes a tener en cuenta cuando se usan threads.
2.4.1. La Ventaja de ser Multi-Threaded
Consiste en un mejor rendimiento interactivo y mejor comportamiento en

tiempo real. Aunque el comportamiento en tiempo real está limitado a las
capacidades del sistema operativo que lo soporte como Unix, Windows u otros,
aún así supera tanto en facilidad de desarrollo como en rendimiento, a los
entornos de flujo único de programa (single-threaded), que todavía se utilizan
en la mayoría de los programas; es decir un programa comienza y su ejecución
sigue un camino único: es un solo thread, como si fuera un “monólogo”.
Los pasos básicos a seguir para usar threads en un programa son tres:
Figura 2.7: Clase Thread.
La clase que se quiere asignar a un thread debe implementar la interface

Runnable.
Se debe crear una variable (instancia) del tipo Thread, que permita ac-
ceder y manejar el thread.
Y crear un método run() que es el que ejecuta el código del programa

propiamente dicho.
Al utilizar la tecnología de navegación concurrente, se sabe lo frustrante

que puede ser esperar que se traiga una gran imagen. En Java, las imágenes
se pueden traer en un thread independiente, permitiendo que el usuario pueda
acceder a la información en la página sin tener que esperar por el navegador.
2.5. Java Para Aplicaciones Corporativas
Java e Intranet actualmente son palabras de moda. Y Java particularmente

es una buena tecnología para desarrollar aplicaciones corporativas, ya que
en donde la red sea algo crítico, Java facilita tremendamente la vida de la
programación corporativa.
Las más grandes compañías se han convencido de que la Red Corporativa
es la Empresa. Ya que la Red es un canal importante por donde fluye la
información que mantiene vivo el negocio. La información fluye desde el gran
servidor de las oficinas centrales, hasta los servidores de las delegaciones, las
estaciones de trabajo de los programadores y las PC’s.
Si esta red no se mantiene, los pedidos no llegan, el inventario no se actuali-

za, el software no se desarrolla adecuadamente, los clientes no están satisfechos
y, fundamentalmente, el dinero no entra.
La necesidad de diagnosticar y reducir los problemas que puedan surgir en
la red, hace que se esté incorporando continuamente nuevas metodologías que
subsanen este grave problema.
Java es el lenguaje apto para Internet; pero, para las aplicaciones corpo-
rativas, allí donde la red es el punto crítico, sería una buena tecnología, si
se compararan las capacidades de Java con la lista de necesidades de la red
corporativa.
Aplicaciones Efectivas o Eficientes
Las aplicaciones que se crean en grandes empresas deben ser más efectivas
que eficientes; es decir, conseguir que el programa funcione y el trabajo salga
adelante es más importante que el hacerlo eficientemente. Esto es una realidad
de la programación corporativa.
Java al ser un lenguaje más simple que cualquiera de los que ahora están
de moda para los programadores, permite concentrarse en la mecánica de la
aplicación, en vez de pasarse horas y horas incorporando API’s “Interface de
Programación de Aplicaciones” para el control de las ventanas, controlando
minuciosamente la memoria, sincronizando los ficheros de cabecera y corrigien-
do los mensajes del linker.
Java tiene su propio toolkit para interfaces, maneja por sí mismo la memo-
ria que utilice la aplicación, no permite ficheros de cabecera separados (en
aplicaciones puramente Java) y solamente usa enlace dinámico.
Muchas de las implementaciones de Java actuales son puros intérpretes.
Los bytecodes son interpretados por el sistema run-time de Java, la Máquina
Virtual Java (JVM ), sobre el ordenador del usuario.
Hay proveedores que ofrecen compiladores nativos Just-In-Time (JIT ).

Si la Máquina Virtual Java dispone de un compilador instalado, las secciones
(clases) del bytecode de la aplicación se compilarán hacia la arquitectura nativa
del ordenador del usuario.
Los programas Java competirán con el rendimiento de programas en C++.
Los compiladores JIT no se utilizan en la forma tradicional de un compilador;
los programadores no compilan y distribuyen binarios Java a los usuarios.
La compilación JIT tiene lugar a partir del bytecode Java, en el sistema del
usuario, como una parte (opcional) del entorno run-time local de Java.
Java permite algunas técnicas innovadoras de optimización. Como se men-
cionó anteriormente, Java es inherentemente multithreaded, a la vez que ofrece
posibilidades de multithread como la clase Thread y mecanismos muy sencillos
de usar de sincronización; Java en sí utiliza threads.
Los desarrolladores de compiladores inteligentes pueden utilizar esta carac-
terística de Java para lanzar un thread que compruebe la forma en que se está
utilizando la aplicación. Más específicamente, este thread podría detectar qué
métodos de una clase se están usando con más frecuencia e invocar a sucesivos
niveles de optimización en tiempo de ejecución de la aplicación. Cuanto más
tiempo esté corriendo la aplicación o el applet, los métodos estarán cada vez
más optimizados.
Si un compilador JIT está embebido en el entorno run-time de Java, el
programador no se preocupa de hacer que la aplicación se ejecute óptimamente.
Mantenimiento y Soporte
Uno de los problemas más conocidos que ocurre con el software corporativo
es la demanda de mantenimiento y realimentación. Java no es, ciertamente, la
solución para el problema del mantenimiento, pero es un lenguaje que posee
varias características que harán la vida más fácil a los desarrolladores y man-
tenedores de aplicaciones. [2]
Capítulo 3
El Lenguaje Java
3.1. Introducción a su Codificación
Java por ser un lenguaje orientado a objetos, posee ciertas característi-

cas que hoy día se consideran estándares en los lenguajes OO, para esto se
utilizarán los siguientes conceptos:
Objetos.
Clases.
Métodos.
Subclases.
Herencia simple.
Enlace dinámico.
Encapsulamiento.
34
CAPÍTULO 3. EL LENGUAJE JAVA 35
Para programar orientado a objetos es necesario primero diseñar un conjun-

to de clases. La claridad, eficiencia y mantenibilidad del programa resultante
dependerá principalmente de la calidad del diseño de clases. Un buen diseño de
clases significará una gran economía en tiempo de desarrollo y mantenimiento.
Lamentablemente se necesita mucha habilidad y experiencia para lograr
diseños de clases de calidad. Un mal diseño de clases puede llevar a programas
OO de peor calidad y de más alto costo que el programa equivalente no OO [2,
Castillo-Cobo-Solares].
La gran ventaja de un lenguaje OO son las bibliotecas de clases que se

pueden construir para la aplicación. Una biblioteca de clases cumple el mismo
objetivo de una biblioteca de procedimientos en una lenguaje como C.
Una biblioteca de clases es mucho más fácil de usar que una biblioteca
de procedimientos, incluso para programadores sin experiencia en orientación
a objetos. Esto se debe a que las clases ofrecen mecanismos de abstracción
más eficaces que los procedimientos.
Se puede distinguir entre varios tipos de programadores en Java:
• El diseñador de clases: Es el encargado de definir qué clases ofrece

una biblioteca y cuál es la funcionalidad que se espera de estas
clases. La persona tiene que ser muy hábil y de mucha experiencia.
Un diseño equivocado puede conducir a clases que son incompren-
sibles para los clientes de la biblioteca.
• El programador de clases de biblioteca: Es el encargado de progra-
mar las clases especificadas por el diseñador de clases. La persona
debe entender orientación a objetos, pero no requiere mayor expe-
riencia en diseño de clases.
• El cliente de bibliotecas: Es el programador de aplicaciones, sóla-

mente utiliza las clases que otros han diseñado y programado. Como
en el caso anterior necesita entender orientación a objetos y conocer
la biblioteca que va a usar, pero no necesita mayor experiencia.
Tanto programadores de clases como clientes de bibliotecas pueden llegar

a convertirse en buenos diseñadores de clases en la medida que adquieran
experiencia, comparando los diseños de las bibliotecas que utilicen.
Por lo tanto es importante destacar que no se necesita gran experiencia en
diseño orientado a objetos para poder aprovechar las ventajas de la orientación
a objetos.
3.1.1. Bibliotecas de Clases Estándares de Java
Toda implementación de Java debe tener las siguientes bibliotecas de

clases:
Manejo de archivos.
Comunicación de datos.
Acceso a la red Internet.
Acceso a bases de datos.
Interfaces gráficas.
La interfaz de programación de estas clases es estándar, es decir en todas

ellas las operaciones se invocan con el mismo nombre y los mismos argumentos.
3.2. Estructura General de un Programa Java
La estructura habitual de un programa realizado en cualquier lenguaje

orientado a objetos u OOP (Object Oriented Programming) tiene muchas par-
ticularidades, principalmente en el lenguaje Java.
En el siguiente ejemplo de código se presenta la estructura general de un
programa en Java:
import java.awt.*;
import java.lang.String;
import java.lang.Integer;
import java.awt.event.WindowEvent;
import java.util.*;
import java.awt.TextField;
public class Simula extends Frame implements ActionListener,ItemListener{
MenuBar barra;
m1 =new Menu(“Archivo”);
barra.add(m1);
m2 =new Menu(“Ver”);
barra.add(m2);
....
public static void main(String argv [ ]){
Simula menus = new Simula();
menus.setTitle(“Simulación de Redes”);
menus.setVisible(true);
}
}
Aparece una clase que contiene el programa principal Simula (aquel que
contiene la función main()) y algunas clases de usuario (las específicas de la
aplicación que se está desarrollando) que son utilizadas por el programa prin-
cipal. La aplicación se ejecuta por medio del nombre de la clase que contiene
la función main(). Las clases de Java se agrupan en packages, que son libr-
erías de clases. Si las clases no se definen como pertenecientes a un package,
se utiliza un package por defecto (default) que es el directorio activo.
3.3. Conceptos Básicos
3.3.1. Clase
Una clase es una agrupación de datos (variables o campos) y de funciones

(métodos) que operan sobre esos datos. A esos datos y funciones pertenecientes
a una clase se les denomina variables y métodos o funciones miembro. La
programación orientada a objetos se basa en la programación de clases. Un
programa se construye a partir de un conjunto de clases.
Una vez definida e implementada una clase, es posible declarar elementos
de esta clase de modo similar a como se declaran las variables del lenguaje (int,
double, String). Los elementos declarados de una clase se denominan objetos
de la clase. De una única clase se pueden declarar o crear numerosos objetos.
La clase es lo genérico: es el patrón o modelo para crear objetos. Cada objeto
tiene sus propias copias de las variables miembro, con sus propios valores, en
general distintos de los demás objetos de la clase. Las clases pueden tener
variables static, que son propias de la clase y no de cada objeto.
Ejemplo:
public abstract class FuncionActivacion implements Cloneable,Serializable{
/*constructor sin argumentos que permite la herencia */
public FuncionActivacion () {
3.3.2. Herencia
La herencia permite que se puedan definir nuevas clases basadas en clases

existentes, lo cual facilita reutilizar código previamente desarrollado. Si una
clase deriva de otra (extends) hereda todas sus variables y métodos. La clase
derivada puede añadir nuevas variables y métodos y/o redefinir las variables
y métodos heredados.
Figura 3.1: Herencia en Java.
En Java, a diferencia de otros lenguajes orientados a objetos, una clase sólo

puede derivar de una única clase, con lo cual no es posible realizar herencia
múltiple en base a clases. Sin embargo es posible “simular” la herencia múltiple
en base a las interfaces.
3.3.3. Interface
Una interface es un conjunto de declaraciones de funciones. Si una clase

implementa (implements) una interface, debe definir todas las funciones es-
pecificadas por la interface. Una clase puede implementar más de una interface,
representando una forma alternativa de la herencia múltiple.
Una interface puede derivar de otra o incluso de varias interfaces, en cuyo
caso incorpora todos los métodos de las interfaces de las que deriva.
Ejemplo: La clase TangenteHiperbólica se extiende de la clase FunciónAc-
tivación que implementa la interface Serializable.
/*función de activación tangente hiperbólica */

public class TangenteHiperbolica extends FuncionActivacion implements Se-

rializable{
/*constructor sin argumentos */
public TangenteHiperbolica () {
}
}
3.3.4. Package
Un package es una agrupación de clases. Existen una serie de packages

incluidos en el lenguaje.
Además el programador puede crear sus propios packages. Todas las clases
que formen parte de un package deben estar en el mismo directorio.
Los packages se utilizan con las siguientes finalidades:
1. Para agrupar clases relacionadas.
2. Para evitar conflictos de nombres. En caso de conflicto de nombres en-

tre clases importadas, el compilador obliga a cualificar en el código los
nombres de dichas clases con el nombre del package.
3. Para ayudar en el control de la accesibilidad de clases y miembros.
Por estas razones, durante la etapa de Diseño del Software a desarrollar,

se tiene que crear tantos paquetes como sea necesario, como en el siguiente
ejemplo donde se utiliza la sentencia package.
package myprojects.simula;
import myprojects.calculos.*;
import myprojects.interfase.*;
Figura 3.2: Típicos Packages Predefinidos.
3.3.5. La Jerarquía de Clases de Java (API)
Durante la generación de código en Java, es recomendable y casi necesario

tener siempre a la vista la documentación on-line del API de Java. En dicha
documentación es posible ver tanto la jerarquía de clases, es decir la relación
de herencia entre clases, como la información de los distintos packages que
componen las librerías base de Java.
Es importante distinguir entre lo que significa herencia y package. Un
package es una agrupación arbitraria de clases, una forma de organizar las
clases. La herencia sin embargo consiste en crear nuevas clases en base a otras
ya existentes. Las clases incluidas en un package no derivan en general de la
misma clase.
En la documentación on-line se presentan ambas visiones: “Package Index”
y “Class Hierarchy”. La primera presenta la estructura del API de Java agru-
pada por packages, mientras que en la segunda aparece la jerarquía de clases.
Hay que resaltar el hecho de que todas las clases en Java son derivadas de la
clase java.lang.Object, por lo que heredan todos los métodos y variables de
ésta.
Si se selecciona una clase en particular, la documentación muestra una
descripción detallada de todos los métodos y variables de la clase. A su vez
muestra su herencia completa (partiendo de la clase java.lang.Object).
Figura 3.3: API de Java.
3.3.6. Variables Dentro del Lenguaje Java
Una variable en Java es un identificador que representa una palabra de

memoria que contiene información. El tipo de información almacenado en una
variable sólo puede ser del tipo con que se declaró esa variable.
En Java hay dos tipos principales de variables:
1. Variables de tipos primitivos. Están definidas mediante un valor único

y almacenan directamente ese valor siempre que pertenezca al rango de
ese tipo. Por ejemplo una variable int almacena un valor entero como
1, 2, 0, -1, etc. Esto significa que al asignar una variable entera a otra
variable entera, se copia el valor de la primera en el espacio que ocupa
la segunda variable.
2. Variables referencia. Las variables referencia son referencias o nombres

de una información más compleja: arrays u objetos de una determinada
clase. Una referencia a un objeto es la dirección de un área en memoria
destinada a representar ese objeto. El área de memoria se solicita con
el operador new. Al asignar una variable de tipo referencia a objeto a
otra variable se asigna la dirección y no el objeto referenciado por esa
dirección. Esto significa que ambas variables quedan referenciando el
mismo objeto. En Java una variable no puede almacenar directamente
un objeto, como ocurre en C y C++. Por lo tanto cuando se dice en
Java que una variable es un string, lo que se quiere decir en realidad es
que la variable es una referencia a un string.
Desde el punto de vista de su papel dentro del programa, las variables

pueden ser:
1. Variables miembro de una clase: Se definen en una clase, fuera de cual-

quier método; pueden ser tipos primitivos o referencias.
2. Variables locales: Se definen dentro de un método o más en general dentro
de cualquier bloque entre llaves {}. Se crean en el interior del bloque y se
destruyen al finalizar dicho bloque. Pueden ser también tipos primitivos
o referencias.
En la Tabla 3.1 de la pág. 43 se muestra una declaración, el nombre de la

variable introducida y el tipo de información que almacena la variable:
Declaración Identificador Tipo

int i; i entero
String s; s referencia a string
int a []; a referencia a arreglo de enteros
int[]b; b referencia a arreglo de enteros
Cuadro 3.1: Tipos de Variables.
En la Tabla 3.2 de la pág. 43 se muestran las dos grandes categorías de

tipos para las variables en Java:
Tipos Primitivos Referencias a Objetos

int, short, byte, long Strings
char, boolean Arreglos
float, double otros objetos
Cuadro 3.2: Categorías de Variables.
En la Tabla 3.3de la pág. 44 se indica para cada tipo primitivo el número

de bits que se emplea en su representación y el rango de valores que se puede
almacenar en las variables de estos tipos.
Se dice que un tipo A es de mayor rango que un tipo B si A es un super-
conjunto de B. Esto quiere decir que las variables de tipo B siempre se pueden
Tipo Bits Rango Ejemplos

int 32 −231 ..231 − 1 0,1,5,-120,...
short 16 −215 .,215 − 1 0,1,5,-120,...
byte 8 −27 .,27 − 1 0,1,5,-120,...
long 64 −263 .,263 − 1 0,1,5,-120,...
boolean 1 n/a false, true
char 16 n/a ‘a’,‘A’,‘0’,‘*’,...
float 32 IEEE 1.2
double 64 IEEE 1.2
Cuadro 3.3: Tipos Primitivos de Variables.
asignar a variables de tipo A (eventualmente con pérdida de significancia).

Por ejemplo int es de mayor rango que short, que a su vez es de mayor
rango que byte. Float y double son de mayor rango que int. Double es de mayor
rango que float.
3.3.7. Visibilidad y Vida de las Variables
Se entiende por visibilidad o ámbito de una variable a la parte de la apli-

cación donde dicha variable es accesible y por lo tanto puede ser utilizada en
cualquier expresión. En Java todos las variables deben estar incluidas en una
clase. En general las variables declaradas dentro de unas llaves {}, es decir
dentro de un bloque, son visibles y existen dentro de estas llaves. Por ejemplo
las variables declaradas al principio de una función existen mientras se ejecute
la función; las variables declaradas dentro de un bloque if no serán válidas
al finalizar las sentencias correspondientes a dicho if y las variables miembro
de una clase (es decir declaradas entre las llaves {} de la clase pero fuera de
cualquier método) son válidas mientras existe el objeto de la clase.
Las variables miembro de una clase declaradas como public son accesi-
bles a través de una referencia a un objeto de dicha clase utilizando el
operador punto (.).
Las variables miembro declaradas como private no son accesibles direc-

tamente desde otras clases. Las funciones miembro de una clase tienen
acceso directo a todas las variables miembro de la clase sin necesidad de

anteponer el nombre de un objeto de la clase. Sin embargo las funciones
miembro de una clase B derivada de otra A, tienen acceso a todas las
variables miembro de A declaradas como public o protected, pero no a las
declaradas como private. Una clase derivada sólo puede acceder directa-
mente a las variables y funciones miembro de su clase base declaradas
como public o protected.
Otra característica del lenguaje es que es posible declarar una variable

dentro de un bloque con el mismo nombre que una variable miembro, pero no
con el nombre de otra variable local. La variable declarada dentro del bloque
oculta a la variable miembro en ese bloque. Para acceder a la variable miembro
oculta será preciso utilizar el operador this.
Uno de los aspectos más importantes en la programación orientada a ob-

jetos (OOP) es la forma en la cual son creados y eliminados los objetos. La
forma de crear nuevos objetos es utilizar el operador new. Cuando se utiliza
el operador new, la variable de tipo referencia guarda la posición de memoria
donde está almacenado este nuevo objeto. Para cada objeto se lleva cuenta
de por cuántas variables de tipo referencia es apuntado. La eliminación de los
objetos la realiza el denominado garbage collector, quien automáticamente
libera o borra la memoria ocupada por un objeto cuando no existe ninguna
referencia apuntando a ese objeto. Lo anterior significa que aunque una varia-
ble de tipo referencia deje de existir, el objeto al cual apunta no es eliminado
si hay otras referencias apuntando a ese mismo objeto.
3.4. Operadores en Java
Java es un lenguaje rico en operadores, que son casi idénticos a los de

C/C++. Estos operadores se describen brevemente a continuación.
3.4.1. Operadores Aritméticos
Son operadores binarios (requieren siempre dos operandos) que realizan

las operaciones aritméticas habituales: suma (+), resta (-), multiplicación (* ),
división (/ ) y resto de la división ( % ).
3.4.2. Operadores de Asignación
Los operadores de asignación permiten asignar un valor a una variable.

El operador de asignación por excelencia es el operador igual (=). La forma
general de las sentencias de asignación con este operador es:
variable = expression;
Java dispone de otros operadores de asignación. Se trata de versiones abre-

viadas del operador (=) que realizan operaciones “acumulativas” sobre una
variable.
La siguiente Tabla 3.4 de la pág. 46, muestra estos operadores y su equi-
valencia con el uso del operador igual (=).
Operador Utilización ExpresiónEquivalente

+= op1 + = op2 op1 = op1 + op2
-= op1 - = op2 op1 = op1 - op2
=* op1 * = op2 op1 = op1 * op2
=/ op1 / = op2 op1 = op1 / op2
%= op1 % = op2 op1 = op1 % op2
Cuadro 3.4: Operadores de Asignación.
3.4.3. Operadores Unarios
Los operadores más (+) y menos (-) unarios sirven para mantener o cam-
biar el signo de una
variable, constante o expresión numérica. Su uso en Java es el estándar de
estos operadores.
3.4.4. Operadores Incrementales
Java dispone del operador incremento (++) y decremento (—). El operador

(++) incrementa en una unidad la variable a la que se aplica, mientras que (—)
la reduce en una unidad. Estos operadores se pueden utilizar de dos formas:
1. Precediendo a la variable (por ejemplo: ++i). En este caso primero se

incrementa la
variable y luego se utiliza (ya incrementada) en la expresión en la que
aparece.
2. Siguiendo a la variable (por ejemplo: i++). En este caso primero se

utiliza la variable en la expresión (con el valor anterior) y luego se incre-
menta.
En muchas ocasiones estos operadores se utilizan para incrementar una va-

riable fuera de una expresión. En este caso ambos operadores son equivalente.
Si se utilizan en una expresión más complicada, el resultado de utilizar estos
operadores en una u otra de sus formas será indiferente. La actualización de
contadores en bucles for es una de las aplicaciones más frecuentes de estos
operadores.
3.4.5. Operadores Relacionales
Los operadores relacionales sirven para realizar comparaciones de igualdad,

desigualdad y relación de menor o mayor. El resultado de estos operadores es
siempre un valor boolean (true o false) según se cumpla o no la relación
considerada. La siguiente Tabla 3.5 de la pág. 47 muestra los operadores rela-
cionales de Java.
Operador Utilización El resultado es true

> op1 > op2 si op1 es mayor que op2
>= op1 >= op2 si op1 es mayor o igual que op2
< op1 < op2 si op1 es menor que op 2
<= op1 <= op2 si op1 es menor o igual que op2
== op1 == op2 si op1 y op2 son iguales
!= op1 != op2 sio p1 y op2 son diferentes
Cuadro 3.5: Operadores Relacionales.
Estos operadores se utilizan con mucha frecuencia en las bifurcaciones y

en los bucles, que se verán luego.
Ejemplo de Operadores Incrementales y Operadores Relacionales en un

método.
public void cambiarParesEntrenamiento(double[ ] paresEntrenamiento){
/* inicialización de sus valores a partir de los valores pasados como argumentos

*/
for(int i = 0; i< paresEntrenamiento.length; i++)
{for(int j = 0; j< numeroNeuronasEntrada; j++)
{entradaEntrenamiento[i][j] = paresEntrenamiento[i][j];
for(int j = 0; j< numeroSalidas; j++)
{salidaEntrenamiento[i][j] = paresEntrenamiento[i]
[j+numeroNeuronasEntrada];
3.4.6. Operador de Concatenación de Cadenas de Caracteres

(+)
El operador más (+) se utiliza también para concatenar cadenas de carac-

teres. Por ejemplo, para escribir una cantidad con un rótulo puede utilizarse
la sentencia:
editor.append(“Error Obtenido:” + String.valueOf(imprimoError) + “\n”);
editor.append(“Iteraciones:”+ String.valueOf(imprimoIteraciones) + “\n”);
editor.append(“Inicio: ” + horaInicial.toString() + “\n”);

editor.append(“Final: ” + horaFinal.toString() + “\n”);
donde el operador de concatenación se utiliza dos veces para construir

la cadena de caracteres que se desea imprimir. Las variables imprimoErrror,
imprimoIteraciones, horaInicial, horaFinal son convertidas en cadena de ca-
racteres para poder concatenarlas.
3.4.7. Precedencia de Operadores
El orden en que se realizan las operaciones es fundamental para determinar

el resultado de una expresión. Por ejemplo, el resultado de x/y*z depende de
qué operación (la división o el producto) se realice primero. La Tabla 3.6 de
la pág. 49 muestra el orden en que se ejecutan los distintos operadores en una
sentencia, de mayor a menor precedencia:
Nombre Sintáxis
Postfijos [ ] .(params) expr++ expr-
Unarios ++expr —expr +expr -expr !
De creación (type) expr
Multiplicativo * /%
Adición +-
Shift << >> >>>
Relacional <> <= >= instanceof
Igualdad == !=
AND &
Or Excluyente ^
Or Incluyente |
Logico AND &&
Logico OR ||
Condicional ?:
Asignación = += -= *= /= %= &= ^= |= <<= >>= >>>=
Cuadro 3.6: Precedencia de Operadores.
En Java, todos los operadores binarios, excepto los operadores de asignación,

se evalúan de izquierda a derecha. Los operadores de asignación se evalúan de
derecha a izquierda, lo que significa que el valor de la izquierda se copia sobre

la variable de la derecha.
3.5. Estructuras de Programación
Las estructuras de programación o estructuras de control permiten tomar

decisiones y realizar un proceso repetidas veces. Son los denominados bifur-
caciones y bucles. En la mayoría de los lenguajes de programación, este tipo
de estructuras son comunes en cuanto a concepto, aunque su sintaxis varía de
un lenguaje a otro. La sintaxis de Java coincide prácticamente con la utiliza-
da en C/C++, lo que hace que para un programador de C/C++ no suponga
ninguna dificultad adicional.
3.5.1. Sentencias o Expresiones
Una expresión es un conjunto variables unidos por operadores. Son órdenes

que se le dan al computador para que realice una tarea determinada.
Una sentencia es una expresión que acaba en punto y coma (;). Se per-
mite incluir varias sentencias en una línea, aunque lo habitual es utilizar una
línea para cada sentencia. A continuación se muestra un ejemplo de una línea
compuesta de tres sentencias:
i = 0; j = 5; x = i + j;
3.5.2. Comentarios
Existen varias formas diferentes de introducir comentarios entre el códi-

go de Java. Son similares a la forma de realizar comentarios en el lenguaje
C/C++. Los comentarios son útiles para poder entender el código utilizado,
facilitando de ese modo futuras revisiones y correcciones. Además permite que
cualquier persona distinta al programador original pueda comprender el código
escrito de una forma más rápida.
Java interpreta que todo lo que aparece a la derecha de dos barras “//
” en una línea cualquiera del código es un comentario del programador y no
lo tiene en cuenta. El comentario puede empezar al comienzo de la línea o a
continuación de una instrucción que debe ser ejecutada. Otra forma de incluir
comentarios consiste en escribir el texto entre los símbolos “ /* */ ”. Este
segundo método es válido para comentar más de una línea de código. Por
ejemplo:
// Esta línea es un comentario

int a=1; // Comentario a la derecha de una sentencia
// Esta es la forma de comentar más de una línea utilizando
// las dos barras. Requiere incluir dos barras al comienzo de cada línea
/* Otra forma es mucho más cómoda para comentar un número elevado de
líneas ya que sólo requiere modificar el comienzo y el final. */
En Java existe además otra forma especial de introducir los comentarios

(utilizando /***/ más algunos caracteres especiales) que permite generar au-
tomáticamente la documentación sobre las clases y packages desarrollados por
el programador. Una vez introducidos los comentarios, el programa javadoc.exe
(incluido en el JDK) genera de forma automática la información de forma sim-
ilar a la presentada en la propia documentación del JDK.
Comentarios Iniciales
Todos los ficheros fuente deben comenzar con un comentario al estilo C

que indique el programador, o programadores, la fecha, una nota de copyright
y una pequeña descripción del propósito del programa. Por ejemplo:
/*
* Nombre de la clase
* Versión
* Copyright
*/
3.5.3. Sentencia import
La palabra import indica que son declaraciones que le avisan al compilador

que el programa usará.
En el caso de java.applet.* todas las clases que pertenecen al paquete

(packages) applet (por eso el applet.* .
El que produce que se usen todas las clases es el “*”. En el caso de java.awt.
Graphics indica que se usará el objeto Graphics del paquete awt.
Por ejemplo:
import java.applet.*;
import java.awt.Graphics;
3.5.4. Longitud de Líneas
Se deben evitar líneas de más de 80 caracteres, porque sino no son mane-

jadas correctamente por muchos terminales y herramientas.
Los ejemplos de uso en la documentación deben ir en líneas más cortas,
generalmente de no más de 70 caracteres.
3.5.5. Bifurcaciones
Las bifurcaciones permiten ejecutar una de entre varias acciones en función

del valor de una expresión lógica o relacional. Se tratan de estructuras muy
importantes ya que son las encargadas de controlar el flujo de ejecución de un
programa. Existen dos variantes del tipo if.
Bifurcación if
Esta estructura permite ejecutar un conjunto de sentencias en función del

valor que tenga la expresión de comparación. Ejemplo: se ejecuta si la expresión
de comparación (error < errorMinimo) tiene valor true:
protected void comprobarNuevoMinimo() {

if (error < errorMinimo)
{errorMinimo = error;
vectorDisMinimo = (double[ ])(vectorDis.clone());
} /* fin del if */
}
Las llaves {} sirven para agrupar en un bloque las sentencias que se han
de ejecutar, y no son necesarias si sólo hay una sentencia dentro del if.
Bifurcación if else
Análoga a la anterior, de la cual es una ampliación. Las sentencias incluidas

en el else se ejecutan en el caso de no cumplirse la expresión de comparación
(false),
Ejemplo:
public double decirSalidaActual(int indiceEtapa) {

if(pila != null)
{return pila[indiceEtapa];}
else
{System.out.println(“Fallo: Pila no creada”);
return 0;
}
}
3.5.6. Bucles
Un bucle se utiliza para realizar un proceso repetidas veces. Se denomina

también lazo o loop. El código incluido entre las llaves {} (opcionales si el
proceso repetitivo consta de una sola línea), se ejecutará mientras se cumpla
unas determinadas condiciones. Hay que prestar especial atención a los bucles
infinitos, hecho que ocurre cuando la condición de finalizar el bucle (booleanEx-

pression) no se llega a cumplir nunca. Se trata de un fallo muy típico, habitual
sobre todo entre programadores poco experimentados.
Bucle while
En el siguiente ejemplo se muestra que se ejecutará la sentencia fin++

mientras la expresión (capas.charAt(fin)!=‘,’ && capas.charAt(fin)!=-1) sea
verdadera.
for (int j=0; j < numeroCapas; j++)

{int fin = principio;
try {
while (capas.charAt(fin) != ‘,’ && capas.charAt(fin) != -1)
{fin++;
}
}
}
Bucle for
A continuación se podrá apreciar la utilización del bucle for:
/* calcular el nuevo vector de diseño */

for (int i = 0; i < vectorDis.length; i++)
{vectorDis[i] = vectorDis[i] + learningRate * S[i];
}
La sentencia int i = 0 (inicialización) se ejecuta al comienzo del for, e

i++ (incremento) después de vectorDis[i] = vectorDis[i] + learningRate * S[i]
(sentencia). La expresión booleana (vectorDis.length) se evalúa al comienzo de
cada iteración; el bucle termina cuando la expresión de comparación toma el
valor false.
Bucle do while
Es similar al bucle while pero con la particularidad de que el control está

al final del bucle (lo que hace que el bucle se ejecute al menos una vez,
independientemente de que la condición se cumpla o no). Una vez ejecutados
las sentencias, se evalúa la condición: si resulta true se vuelven a ejecutar las
sentencias incluidas en el bucle, mientras que si la condición se evalúa a false
finaliza el bucle.
do{
/* calcular el gradiente del vector fijar el vector de diseño */
problema.fijoVector(vectorDis);
/* incrementar el contador de iteraciones*/
step++;
} while (error > errorDeseado && step < iteracionesMaximas);
/* ... hasta que el error sea menor o igual que el deseado o */
/* se alcance el número de iteraciones pasado como argumento */
problema.fijoVector(vectorDis);
Sentencia return
Una forma de salir de un bucle es utilizar la sentencia return. Esta sen-

tencia sale también de un método o de una función. En el caso de que la
función devuelva alguna variable, este valor se deberá poner a continuación
del return.A continuación se muestra como sale de un método:
public double devuelveErrorMinimo()

{return errorMinimo;
}
Bloque try{...} catch{...} finally{...}
Java incorpora en el propio lenguaje la gestión de errores. El mejor mo-

mento para detectar los errores es durante la compilación. Sin embargo prácti-
camente sólo los errores de sintaxis son detectados en esta operación. El resto
de problemas surgen durante la ejecución de los programas.
Exception
En el lenguaje Java, una Exception es un cierto tipo de error o una

condición anormal que se ha producido durante la ejecución de un programa.
Algunas excepciones son fatales y provocan que se deba finalizar la ejecución
del programa. En este caso conviene terminar ordenadamente y dar un mensaje
explicando el tipo de error que se ha producido. Otras excepciones, como
por ejemplo no encontrar un fichero en el que hay que leer o escribir algo,
pueden ser recuperables. En este caso el programa debe dar al usuario la
oportunidad de corregir el error (dando por ejemplo un nuevo path del fichero
no encontrado).
Los errores se representan mediante clases derivadas de la clase Throw-
able, pero los que tiene que chequear un programador derivan de Exception
(java.lang.Exception que a su vez deriva de Throwable). Existen algunos tipos
de excepciones que Java obliga a tener en cuenta. Esto se hace mediante el
uso de bloques try, catch y finally.
El código dentro del bloque try está “vigilado”: Si se produce una situación
anormal y se lanza como consecuencia una excepción, el control pasa al bloque
catch que se hace cargo de la situación y decide lo que hay que hacer. Se
pueden incluir tantos bloques catch como se desee, cada uno de los cuales
tratará un tipo de excepción. Finalmente, si está presente, se ejecuta el bloque
finally, que es opcional, pero que en caso de existir se ejecuta siempre, sea
cual sea el tipo de error.
En el caso en que el código de un método pueda generar una Exception
y no se desee incluir en dicho método la gestión del error (es decir los bucles
try/catch correspondientes), es necesario que el método pase la Exception al
método desde el que ha sido llamado. Esto se consigue mediante la adición de
la palabra throws seguida del nombre de la Exception concreta, después de
la lista de argumentos del método. A su vez el método superior deberá incluir
los bloques try/catch o volver a pasar la Exception. De esta forma se puede ir
pasando la Exception de un método a otro hasta llegar al último método del

programa, el método main().
3.6. Clases en Java
Las clases son el centro de la Programación Orientada a Objetos (OOP

- Object Oriented Programming). Algunos conceptos importantes de la POO
son los siguientes:
1. Encapsulación: Las clases pueden ser declaradas como públicas (public)

y como package (accesibles sólo para otras clases del package). Las vari-
ables miembro y los métodos pueden ser public, private, protected y
package. De esta forma se puede controlar el acceso y evitar un uso
inadecuado.
2. Herencia: Una clase puede derivar de otra (extends), y en ese caso hereda
todas sus variables y métodos. Una clase derivada puede añadir nuevas
variables y métodos y/o redefinir las variables y métodos heredados.
3. Polimorfismo: Los objetos de distintas clases pertenecientes a una misma

jerarquía o que implementan una misma interface pueden tratarse de
una forma general e individualizada, al mismo tiempo. Esto facilita la
programación y el mantenimiento del código.
3.6.1. Características Importantes de las Clases
A continuación se enumeran algunas características importantes de las

clases:
1. Todas las variables y funciones de Java deben pertenecer a una clase.

No hay variables y funciones globales.
2. Si una clase deriva de otra (extends), hereda todas sus variables y méto-
dos.
3. Java tiene una jerarquía de clases estándar de la que pueden derivar las
clases que crean los usuarios.
4. Una clase sólo puede heredar de una única clase (en Java no hay herencia
múltiple). Si al definir una clase no se especifica de qué clase deriva, por
defecto la clase deriva de Object. La clase Object es la base de toda la
jerarquía de clases de Java.
5. En un fichero se pueden definir varias clases, pero en un fichero no puede
haber más que una clase public. Este fichero se debe llamar como la clase
public que contiene con extensión *.java. Con algunas excepciones, lo
habitual es escribir una sola clase por fichero.
6. Si una clase contenida en un fichero no es public, no es necesario que el
fichero se llame como la clase.
7. Los métodos de una clase pueden referirse de modo global al objeto de
esa clase al que se aplican por medio de la referencia this.
8. Las clases se pueden agrupar en packages, introduciendo una línea al
comienzo del fichero (package packageName;). Esta agrupación en pack-
ages está relacionada con la jerarquía de directorios y ficheros en la que
se guardan las clases.
3.6.2. Métodos o Funciones Miembros
Métodos de Objeto
Los métodos son funciones definidas dentro de una clase. Salvo los méto-
dos static o de clase, se aplican siempre a un objeto de la clase por medio
del operador punto (.). Dicho objeto es su argumento implícito. Los métodos
pueden además tener otros argumentos explícitos que van entre paréntesis, a
continuación del nombre del método.
La primera línea de la definición de un método se llama declaración o
header; el código comprendido entre las llaves {} es el cuerpo o body del
método. Considérese el siguiente ejemplo:
imprimoError=algor.devuelveErrorMinimo();
public double devuelveErrorMinimo()
{return errorMinimo;
}
La Clase Object
Como ya se ha dicho, la clase Object es la raíz de toda la jerarquía de clases

de Java. Todas las clases de Java derivan de Object.
La clase Object tiene métodos interesantes para cualquier objeto que son
heredados por cualquier clase. Entre ellos se pueden citar los siguientes:
1. Métodos que pueden ser redefinidos por el programador:
clone(): Crea un objeto a partir de otro objeto de la misma clase.

El método original heredado de Object lanza una CloneNotSupport-
edException. Si se desea poder clonar una clase hay que implemen-
tar la interface Cloneable y redefinir el método clone(). Este método
debe hacer una copia miembro a miembro del objeto original. No
debería llamar al operador new ni a los constructores.
equals(): Indica si dos objetos son o no iguales. Devuelve true si
son iguales, tanto si son referencias al mismo objeto como si son
objetos distintos con iguales valores de las variables miembro.
toString(): Devuelve un String que contiene una representación del
objeto como cadena de caracteres, por ejemplo para imprimirlo o
exportarlo.
finalize(): Este método ya se ha visto al hablar de los finalizadores.
2. Métodos que no pueden ser redefinidos (son métodos final):
getClass(): Devuelve un objeto de la clase Class, al cual se le pueden

aplicar métodos para determinar el nombre de la clase, su super-
clase, las interfaces implementadas, etc. Se puede crear un objeto
de la misma clase que otro sin saber de qué clase es.
notify(), notifyAll() y wait(): Son métodos relacionados con los
threads (hilos).
3.7. Clases de Mayor Utilidad
3.7.1. Clase Arrays
Los arrays de Java (vectores, matrices, hiper-matrices de más de dos di-

mensiones) se tratan como objetos de una clase predefinida. Los arrays son
objetos, pero con algunas características propias.
Los arrays pueden ser asignados a objetos de la clase Object y los métodos
de Object pueden ser utilizados con arrays.
Algunas de las características más importantes de los arrays son las si-
guientes:
1. Los arrays se crean con el operador new seguido del tipo y número de
elementos.
2. Se puede acceder al número de elementos de un array con la variable
miembro implícita length (por ejemplo, vect.length).
3. Se accede a los elementos de un array con los corchetes [ ] y un índice
que varía de 0 a length-1.
4. Se pueden crear arrays de objetos de cualquier tipo. En principio un array
de objetos es un array de referencias que hay que completar llamando al
operador new.
5. Los elementos de un array se inicializan al valor por defecto del tipo co-
rrespondiente (cero para valores numéricos, la cadena vacía para Strings,
false para boolean, null para referencias).
6. Como todos los objetos, los arrays se pasan como argumentos a los méto-
dos por referencia.
7. Se pueden crear arrays anónimos (por ejemplo, crear un nuevo array
como argumento actual en la llamada a un método).
Inicialización de Arrays
Los arrays se pueden inicializar con valores entre llaves {...} separados por
comas. También los arrays de objetos se pueden inicializar con varias llamadas
a new dentro de unas llaves {...}.
Si se igualan dos referencias a un array no se copia el array, sino que se

tiene un array con dos nombres, apuntando al mismo y único objeto.
Ejemplo de creación de una referencia a un array:
/*vector de pesos */
public double[ ] pesos;
También existen arrays bidimensionales, que se crean de un modo muy

similar al de C++ (con reserva dinámica de memoria). En Java una matriz
es un vector de vectores fila, o más en concreto un vector de referencias a los
vectores fila. Con este esquema, cada fila podría tener un número de elementos
diferente.
Una matriz se puede crear directamente en la siguiente forma:
/*vector de las entradas de los pares de entrenamiento*/
protected double[ ][ ] entradaEntrenamiento;
3.7.2. Clases String y StringBuffer
Las clases String y StringBuffer están orientadas a manejar cadenas de

caracteres. La clase String está orientada a manejar cadenas de caracteres
constantes, es decir, que no pueden cambiar. La clase StringBuffer permite
que el programador cambie la cadena insertando, borrando, etc. La primera
es más eficiente, mientras que la segunda permite más posibilidades.
Ambas clases pertenecen al package java.lang, y por lo tanto no hay que
importarlas. Hay que indicar que el operador de concatenación (+) entre ob-
jetos de tipo String utiliza internamente objetos de la clase StringBuffer y el
método append().
Los métodos de String se pueden utilizar directamente sobre literals (ca-
denas entre comillas), como por ejemplo: “Hola”.length().
Métodos de la Clase String
Algunos métodos de String y la función que realizan:
String(...): Constructores para crear Strings a partir de arrays de bytes

o de caracteres.
String(String str) yString(StringBuffer sb): Costructores a partir de un
objeto String o StringBuffer.
charAt(int): Devuelve el carácter en la posición especificada.
getChars(int, int, char[ ], int): Copia los caracteres indicados en la posi-
ción indicada de un array de caracteres.
length(): Devuelve el número de caracteres de la cadena.
toLowerCase(): Convierte en minúsculas (puede tener en cuenta el lo-
cale).
toUpperCase(): Convierte en mayúsculas (puede tener en cuenta el lo-
cale).
valueOf(): Devuelve la representación como String de sus argumento.
Admite Object, arrays de caracteres y los tipos primitivos.
3.7.3. Clase Double
La clase java.lang.Double deriva de Number, que a su vez deriva de Object.

Esta clase contiene un valor primitivo de tipo double.
Algunos Métodos de la Clase Double
Double(double) y Double(String): Los constructores de esta clase.

doubleValue(), floatValue(), longValue(), intValue(), shortValue(), byte-
Value(): Métodos para obtener el valor del tipo primitivo.
String toString(), Double valueOf(String): Conversores con la clase String.
isInfinite(), isNaN(): Métodos de chequear condiciones.
equals(Object): Compara con otro objeto.
3.7.4. Clase Integer
La clase java.lang.Integer tiene como variable miembro un valor de tipo

int.
Algunos Métodos de la Clase Integer
Integer(int) y Integer(String): Constructores de la clase.
doubleValue(), floatValue(), longValue(),intValue(), shortValue(), byte-

Value(): Conversores con otros tipos primitivos.
Integer decode(String), Integer parseInt(String), String toString(), In-

teger ValueOf(String): Conversores con String del sistema a partir del
nombre de dicha propiedad.
3.8. El AWT (Abstract Windows Toolkit)
3.8.1. Qué es el AWT
El AWT (Abstract Windows Toolkit) es la parte de Java que se ocupa de

construir interfaces gráficas de usuario. Aunque el AWT ha estado presente en
Java desde la versión 1.0, la versión 1.1 representó un cambio notable, sobre
todo en lo que respecta al modelo de eventos. La versión 1.2 ha incorporado un
modelo distinto de componentes llamado Swing, que también está disponible
en la versión 1.1 como package adicional.
3.8.2. Creación de una Interface Gráfica de Usuario
Para construir una interface gráfica de usuario hace falta:
1. Un “contenedor” o container : Es la ventana o parte de la ventana donde

se situarán los componentes (botones, barras de desplazamiento, etc.) y
donde se realizarán los dibujos. Se correspondería con un formulario o
una picture box de Visual Basic.
2. Los componentes: Son menúes, botones de comando, barras de desplaza-

miento, cajas y áreas de texto, botones de opción y selección, etc. Se
corresponderían con los controles de Visual Basic.
3. El modelo de eventos: El usuario controla la aplicación actuando sobre

los componentes, de ordinario con el ratón o con el teclado. Cada vez
que el usuario realiza una determinada acción, se produce el evento co-
rrespondiente, que el sistema operativo transmite al AWT.
El AWT crea un objeto de una determinada clase de evento, derivada de

AWT Event. Este evento es transmitido a un determinado método para que
lo gestione. En Visual Basic el entorno de desarrollo crea automáticamente el
procedimiento que va a gestionar el evento (uniendo el nombre del control con
el tipo del evento mediante el carácter) y el usuario no tiene más que introducir
el código. En Java es un poco más complicado, ya que el componente u objeto
que recibe el evento debe “registrar” o indicar previamente el objeto que se va
a hacer cargo de gestionar ese evento.
3.8.3. Objetos “event source” y Objetos “event listener”
El modelo de eventos de Java está basado en que los objetos sobre los que
se producen los eventos (event sources) “registran” los objetos que habrán
de gestionarlos (event listeners), para lo cual los event listeners habrán de
disponer de los métodos adecuados. Estos métodos se llamarán automática-
mente cuando se produzca el evento. La forma de garantizar que los event
listeners disponen de los métodos apropiados para gestionar los eventos es
obligarlos a implementar una determinada interface Listener. Las interfaces
Listener se corresponden con los tipos de eventos que se pueden producir.
Las capacidades gráficas del AWT resultan pobres y complicadas en com-
paración con lo que se puede conseguir con Visual Basic, pero tienen la ventaja
de poder ser ejecutadas casi en cualquier ordenador y con cualquier sistema
operativo.
3.8.4. Proceso a Seguir Para Crear Una Aplicación Interactiva

(Orientada a Eventos)
Pasos que se pueden seguir para construir una aplicación orientada a even-
tos sencilla, con interface gráfica de usuario:
1. Determinar los componentes que van a constituir la interface del usuario,

como botones, cajas de texto, menúes, etc.
2. Crear una clase para la aplicación que contenga la función main().
3. Crear una clase Ventana, sub-clase de Frame, que responda al evento
WindowClosing().
4. La función main() deberá crear un objeto de la clase Ventana (en el
que se van a introducir las componentes seleccionadas) y mostrarla por
pantalla con el tamaño y posición adecuados.
5. Añadir al objeto Ventana todos los componentes y menúes que deba
contener.
6. Definir los objetos Listener (objetos que se ocuparán de responder a los
eventos, cuyas clases implementan las distintas interfaces Listener) para
cada uno de los eventos que deban estar soportados. En aplicaciones
pequeñas, el propio objeto Ventana se puede ocupar de responder a los
eventos de sus componentes. En programas más grandes se puede crear
uno o más objetos de clases especiales para ocuparse de los eventos.
7. Finalmente, se deben implementar los métodos de las interfaces Listener
que se vayan a hacer cargo de la gestión de los eventos.
3.9. Errores más Frecuentes en la Programación con

Java
A continuación se presenta una varios ejemplos de errores, vistos desde el

punto de vista de la portabilidad, porque quizá el sine qua non de Java, en
última instancia sea perseguir una verdadera independencia de plataforma.
Los errores no tienen ningún orden de dificultad, no son más que algunos
de ellos en los que puede caer cualquier programador.
Hay muchísimas formas cometer fallos a la hora de programar en Java;

algunas se deben simplemente a malos hábitos y son muy difíciles de encon-
trar, mientras que otros saltan a la vista al instante. Los errores de progra-
mación más obvios, también son los que con más frecuencia cometen los pro-
gramadores.
Quizás muchos de los fallos se evitarían si los programadores intentarán
aplicar calidad a sus programas desde el momento mismo de concebir el progra-
ma, y no la tendencia de aplicar pureza a la aplicación en el último momento.
3.9.1. Scheduling de Hilos de Ejecución
El scheduling de los hilos de ejecución, es decir, el tiempo que el sistema

destina a la ejecución de cada uno de los hilos de ejecución, puede ser distinto
en diferentes plataformas. Si no se tienen en cuenta las prioridades o se deja
al azar la prevención de que dos hilos de ejecución accedan a un mismo objeto
al mismo tiempo, el programa no será portable.
El siguiente programa, por ejemplo, no es portable:
class Contador implements Runnable
static long valor = 0;
public void run() {
valor += 1;
public static void main( String args[] )
try
{
Thread hilo1 = new Thread( new Contador() );
hilo1.setPriority( 1 );
Thread hilo2 = new Thread( new Contador() );

hilo2.setPriority( 2 );
hilo1.start();
hilo2.start();
hilo1.join();
hilo2.join();
Systtem.out.println( valor );
} catch( Exception e ) {
e.printStackTrace();
}
Este programa puede no imprimir “2” en todas las plataformas, porque los
dos hilos de ejecución no están sincronizados y, desgraciadamente, este es un
problema muy profundo y no hay forma de detectar su presencia ni adivinar
el momento en que va a ocurrir.
Una solución simple, y drástica, es hacer todos los métodos sincronizados.
Pero esto también tiene problemas porque puede presentar como puntos sin
retorno obvios, lo que en realidad es una corrupción de datos.
El scheduling de los hilos de ejecución es uno de los aspectos más prob-
lemáticos de la programación Java, porque la naturaleza del problema se
vuelve global, al intervenir varios hilos de ejecución. No se puede buscar el
problema en una parte del programa, es imprescindible entender y tratar el
programa en su globalidad.
Además, hay ejemplos de contención de hilos que no serán detectados. Por
ejemplo, en la clase Contador anterior no se detectará el problema ya que la
contención está en el acceso al campo, en lugar de en el acceso al método.
3.9.2. Errores en el Uso de las Características de Portabilidad

de Java
Hay características de portabilidad en el API de Java. Es posible, pero

menos portable, escribir código que no haga uso de estas características. Muchas
de las propiedades del sistema proporcionan información sobre la portabilidad;

por ejemplo, se pueden utilizar las propiedades del sistema para conocer cuál
es el carácter definido como fin de línea o el que se emplea como terminador del
archivo, para emplear el adecuado a la plataforma en que se está ejecutando
el programa.
Java proporciona dos métodos para facilitar la escritura de programas
portables en este sentido. Por un lado, utilizar el método println() en vez de
imprimir las cadenas seguidas del terminador de cadena embebido; o también,
utilizar la expresión System.getProperty(“line.separator”) para conocer cuál es
el terminado de línea que se utiliza en la plataforma en que se está ejecutando
el programa.
En general, el uso de las propiedades facilita en gran modo la portabilidad
y debería extenderse su uso siempre que fuese aplicable.
3.9.3. Uso de Directorios Definidos
Un error muy común y fácil de cometer entre los programadores, aunque

igual de fácil de corregir es la designación en el código de nombre de los
archivos, que pueden dar lugar a problemas de portabilidad, pero cuando se
añade el directorio en que se sitúan, seguro que estos problemas aparecerán.
Estos fallos son más comunes entre programadores con viejos hábitos, que eran
dependientes del sistema operativo, y que son difíciles de olvidar.
La forma más portable de construir un File para un fichero en un direc-
torio es utilizar el constructor File(File,String). Otra forma sería utilizar las
propiedades para conocer cuál es el separador de ficheros y el directorio inicial;
o también, preguntarle al operador a través de una caja de diálogo.
Otro problema es la noción de camino absoluto, que es dependiente del
sistema.
En Unix los caminos absolutos empiezan por /, mientras que en Windows
pueden empezar por cualquier letra. Por esta razón, el uso de caminos abso-
lutos que no sean dependientes de una entrada por operador o de la consulta
de las propiedades del sistema no será portable.
El ejemplo siguiente proporciona una clase útil para la construcción de

nombres de archivos. La última versión del JDK es mucho más exhaustiva, y
detecta más fácilmente los errores cometidos en los directorios y nombres de
ficheros.
import java.io.File;
import java.util.StringTokenizer;
public class UtilFichero {
/* Crea un nuevo fichero con el nombre de otros. Si la base inicial es
* nula, parte del directorio actual
*/
public static File dirInicial( File base,String path[] ) {
File valor = base;

int i=0;
if( valor == null && path.length == 0 ) {
valor = new File( path[i++] );
}
for( ; i < path.length; i++ ) {
valor = new File( valor,path[i] );
}
return( valor );
}
public static File desdeOrigen( String path[] ) {
return( dirInicial( null,path ) );
public static File desdeProp( String nombrePropiedad ) {
String pd = System.getProperty( nombrePropiedad );

return( new File( pd ) );

}
// Utilizando la propiedad del sistema “user.dir”
public static File userDir() {
return( desdeProp( “user.dir” ) );

}
// Utilizando la propiedad del sistema “java.home”
public static File javaHome() {
return( desdeProp( “java.home” ) );

}
// Utilizando la propiedad del sistema “user.home”
public static File userHome() {
return( desdeProp( “user.home” ) );

}
/* Separa el primer argumento, utilizando el segundo argumetno como
* carácter separador.
* Es muy útil a la hora de crear caminos de ficheros portables
*/
public static String[] split( String p,String sep ) {
StringTokenizer st = new StringTokenizer( p,sep );

String valor[] = new String[st.countTokens()];
Figura 3.4: JDBC en Java.
for( int i=0; i < valor.length; i++ ) {

valor[i] = st.nextToken();
}
return( valor );
3.9.4. Carga de Drivers JDBC
El interfaz JDBC, definido por el paquete java.sql, proporciona gran fle-

xibilidad a la hora de codificar la carga del driver JDBC a utilizar. Esta fle-
xibilidad permite la sustitución de diferentes drivers sin que haya que mo-
dificar el código, a través de la clase DriverManager, que selecciona entre
los drivers disponibles en el momento de establecer la conexión. Los drivers
se pueden poner a disposición de DriverManager a través de la propiedad
del sistema jdbc.drivers o cargándolos explícitamente usando el método ja-
va.lang.Class.forName().
También es posible la carga de una selección de drivers, dejando que el

mecanismo de selección de DriverManager encuentre el adecuado en el mo-
mento de establecer la conexión con la base de datos.
Hay que tener siempre en cuenta los siguientes puntos:
La prueba de drivers se intenta siempre en el orden en que se han re-

gistrado, por lo que los primeros drivers tienen prioridad sobre los úl-
timos cargados, con la máxima prioridad para los drivers listados en
jdbc.drivers.
Un driver que incluya código nativo fallará al cargarlo sobre cualquier

plataforma diferente de la que fue diseñado; por lo que el programa
deberá recoger la excepción ClassNotFoundException.
Un driver con código nativo no debe registrarse con DriverManager has-

ta que no se sepa que la carga ha tenido éxito.
Un driver con código nativo no está protegido por la caja negra de Java,
así que puede presentar potenciales problemas de seguridad.
3.9.5. Terminación de Líneas
Las distintas plataformas de sistemas operativos tienen distintas conven-

ciones para la terminación de líneas en un fichero de texto. Por esto debería
utilizarse el método println(), o la propiedad del sistema line.separator, para
la salida; y para la entrada utilizar los métodos readLine().
Java internamente utiliza Unicode, que al ser un estándar internacional,

soluciona el problema a la hora de codificar; pero el problema persiste al leer
o escribir texto en un archivo.
En el JDK 1.1 se utilizan las clases java.io.Reader y java.io.Writer para
manejar la conversión del set de caracteres, pero el problema puede surgir
cuando se leen o escriben archivos ASCII planos, porque en el ASCII estándar
no hay un carácter específico para la terminación de líneas; algunas máquinas
utilizan \n, otras usan \r, y otras emplean la secuencia \r\n.
Enarbolando la bandera de la portabilidad, deberían utilizarse los métodos
println() para escribir una línea de texto, o colocar un marcador de fin de línea.
También, usar el método readLine() de la clase java.io.BufferedReader para
recoger una línea completa de texto.
Los otros métodos readLine() son igualmente útiles, pero el de la clase

BufferedReader proporciona al código también la traslación.
3.9.6. Entrada/Salida por Archivo
Las clases de entrada y salida del JDK 1.0 no son portables a plataformas
que no soporten formatos nativos de archivos no-ASCII. Es fácil para el pro-
gramador suponer alegremente que todo el mundo es ASCII. Pero la realidad
no es esa, los chinos y los japoneses, por ejemplo, no puedes escribir nada
con los caracteres ASCII. Hay que tener esto en cuenta si se quiere que los
programas viajen fuera del país propio.
3.9.7. Fuentes de Caracteres
El tamaño y disponibilidad de varios tipos de fuentes varía de pantalla a

pantalla, incluso en una misma plataforma hardware, dependiendo de la insta-
lación que se haya hecho. Esto es algo que no descalifica totalmente el progra-
ma, porque se verá defectuosamente, pero el programa podrá seguir usándose;
pero debería prevenirse, porque se presupone que el programador desea que
su software aparezca de la mejor manera posible en cualquier plataforma.
El modo mejor de evitar todo esto es no codificar directamente el tamaño
de los textos, dejar que los textos asuman su tamaño en relación al layout, y
utilizar los métodos de la clase FontMetrics para encontrar el tamaño en que
aparecen los caracteres de una cadena sobre un Canvas. Cuando se coloca una
fuente que no se encuentra entre las de defecto, hay que asegurarse siempre de
colocar alguna de respaldo en el bloque catch.
Cuando se crea un menú para seleccionar fuentes de caracteres, se debería
utilizar el método java.awt.Toolkit.getFontList(), en lugar de especificar una
lista de fuentes.
Cuando se actualice un programa del JDK 1.0 al JDK 1.1, hay que tener
en cuenta que los nombre de las fuentes de caracteres se han actualizado, tal
como se indica en la documentación del método getFontList().
Capítulo 4
Los Servlets
4.1. Servlets
Los servlets son programas de Java que construyen respuestas dinámicas

para el cliente, tal como páginas Web. Los servlets reciben y responden a las
demandas de los clientes Web, normalmente por HTTP.
Los servlets son más eficientes que los programas (CGI) porque son carga-
dos de una sola vez en la memoria, y cada demanda es manejada por un hilo
74
CAPÍTULO 4. LOS SERVLETS 75
de la máquina virtual de Java, no por el sistema operativo.

Además los servlets son escalables, dando soporte para una multi-aplicación
de configuración del servidor. [2, IBM Press]
Permiten utilizar datos caché, acceso a información de base de datos, y
compartir datos con otro servlets, archivos JSP y (en algunos ambientes) con
los bean empresariales.
4.1.1. Principios de Codificación de Servlet
Para crear un servlet de HTTP, es necesario extender las clases:

javax.servlet.HttpServlet y sustituir cualquier método que se desee imple-
mentar en el servlet. Por ejemplo, un servlet reemplaza el método doGet para
manejar las demandas Get de los clientes.
El HttpServletRequest representa los requerimientos de un cliente. Este

objeto da acceso al servlet, a la información incluida como datos en formato
HTML, encabezados HTTP, etc.
El HttpServletResponse representa la respuesta del servlet.
El servlet usa este objeto para devolverle datos al cliente como errores
de HTTP (200, 404, y otros), encabezados de respuesta (Content-Type, Set-
Cookie, y otros), y datos de salida para escribir cadenas de salida de respuesta
o salida impresa.
El principio de un servlet podría parecerse al siguiente ejemplo:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
public class MyServlet extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException{
4.1.2. Ciclo de Vida del Servlet
Las clases javax.servlet.http.HttpServlet definen métodos tales como:
Iniciar un servlet.
Solicitar servicios.
Quitar un servlet del servidor.
Éstos son conocidos como métodos del ciclo de vida y son llamados en la
siguiente secuencia:
Se construye el servlet.
Se inicializa con el método INIT.
Se manejan llamadas de los clientes al método de servicio.
Se saca el servlet de servicio.
Se destruye con el método destruir.
Se finaliza el servlet y la basura es recolectada.
En la figura 5.1 de la página 89 se puede apreciar gráficamente el Ciclo de

Vida de un Servlet.
4.1.3. Instanciación e Inicialización
El motor del servlet (la función del Servidor de Aplicaciones que proce-
sa servlets, archivos JSP, y otros tipos de server-side incluyendo codificación)
crea una instancia del servlet. El motor del servlet crea el objeto de confi-
guración del servlet y lo usa para pasar los parámetros de inicialización del
servlet al método INIT. La inicialización de los parámetros persiste hasta que
el servlet se destruye y es aplicada a todas las invocaciones de ese servlet hasta
destruirse.
Si la inicialización tiene éxito, el servlet está disponible para el servicio. Si
la inicialización falla, el motor del servlet descarga el servlet. El administrador
Figura 4.1: Ciclo de Vida de un Servlet.

puede inhabilitar una aplicación y el servlet para el servicio. En tales casos,

la aplicación y el servlet permanecen inhabilitados hasta que el administrador
los habilite.
4.1.4. Servicio de Demanda
Una demanda del cliente llega al servidor de aplicaciones. El motor del

servlet crea un objeto demanda y un objeto respuesta. El motor del servlet
invoca al método de servicio del servlet, procesa el requerimiento y usa métodos
del objeto respuesta para crear la respuesta para el cliente.
El método de servicio recibe información sobre el requerimiento del objeto
demanda, procesa el requerimiento, y usa los métodos del objeto respuesta
para crear la contestación para el cliente. El método de servicio puede invocar
otros métodos para procesar el requerimiento, tales como doGet (), doPost (),
o métodos del usuario.
4.1.5. Terminación
El motor del servlet invoca al método destroy () del servlet cuando apropia
y descarga el servlet. La Máquina Virtual de Java realiza la recolección de
basura después de la destrucción del servlet.
Cuando el contenedor Web ya no necesita que el servlet o una nueva ins-
tancia del servlet se recarguen, invoca al método destroy () del servlet. El
contenedor Web también puede llamar al método destroy () si el motor nece-
sita conservar recursos o una llamada pendiente a un método service () del
servlet excediendo el timeout. La Máquina Virtual de Java realiza recolección
de basura después del destroy.
4.1.6. Modelos de Acceso JSP
Se puede acceder a los archivos JSP de dos maneras:

El browser envía un requerimiento para los archivos JSP.
Los archivos JSP acceden a los beans u otros componentes que generan
contenido dinámico para ser enviado al browser como se muestra en la figura
Figura 4.2: Requerimiento de un Archivo JSP.
4.2 de la página 79.

Cuando el servidor Web recibe un requerimiento para un archivo JSP, el
servidor envía ese requerimiento al servidor de aplicaciones. El servidor de
aplicaciones analiza el archivo JSP y genera código fuente de Java que se
compila y se ejecuta como un servlet.
El requerimiento se envía a un servlet que genera contenido dinámico y
llama a un archivo JSP para enviar el contenido a un browser, como se muestra
en la figura 4.3 de la página 80.
Este modelo de acceso facilita la generación de contenido separado del

despliegue de contenido.
El servidor de aplicaciones proporciona un juego de métodos en el objeto
HttpServiceRequest object y el objeto HttpServiceResponse. Estos métodos
permiten una invocación de servlet para colocar un objeto (normalmente un
bean) en un objeto demanda y pasa ese requerimiento a otra página (nor-
malmente un archivo JSP) para el despliegue. La página invocada recupera el
beans del objeto demanda y genera el HTML que recibe el cliente.
4.1.7. Procesadores JSP
Cada procesador de JSP es un servlet que se puede adherir a una aplicación

Web para manejar todos los requerimientos JSP pertenecientes a la misma.
Cuando se instala el Application Server en un servidor Web, la configura-
ción del servidor Web pasa los requerimientos HTTP para los archivos JSP
Figura 4.3: Requerimiento de un Servlet.
(archivos con la extensión .jsp) al Application Server.

El procesador de JSP crea y compila un servlet desde cada archivo JSP.
El procesador produce estos archivos para cada JSP:
Archivos Java que contienen el código del lenguaje Java para el servlet.
Archivos de clase que se compilan en el servlet.
El procesador de JSP pone los archivos .java, y .class en un camino es-

pecífico al procesador. Los archivos .java y .class tienen el mismo nombre de
archivos. El procesador usa una convención de denominación que incluye el
agregado de subrayado de los caracteres y un sufijo para el nombre del archivo
JSP.
Por ejemplo, si el nombre del archivo JSP es simple.jsp, los archivos gene-
rados son: _simple_xjsp.java y _simple_xjsp.class.
Como todos los servlets, un servlet generado desde un archivo JSP se ex-
tiende desde javax.servlet.http.HttpServlet. El código Java de servlet contiene
declaraciones de importación para las clases necesarias y una declaración de

paquete, si la clase del servlet es parte de un paquete.
Si el archivo JSP contiene sintaxis de JSP (como directivas y scriptlets), el

procesador de JSP convierte la sintaxis de JSP al código Java equivalente. Si
el archivo JSP contiene etiquetas HTML, el procesador agrega el código Java
a fin de que el servlet realice la salida de HTML carácter por carácter.
4.1.8. Compilación Batch de Archivos JSP
WebSphere Application Server proporciona un compilador batch de JSP.

Al usar la función del compilador batch de archivos JSP, se habilitan respuestas
más rápidas al requerimiento inicial del cliente para los archivos JSP en el
servidor Web de producción.
El compilador batch ahorra recursos del sistema y proporciona seguridad en
el servidor de aplicaciones, especificando cuándo el servidor está chequeando
un archivo de clase o recompilando un archivo JSP. El servidor de aplicaciones
supervisará la compilación de los archivos JSP para cambios, y automática-
mente compilará y recargará los archivos JSP, siempre que el servidor de apli-
caciones descubra que el archivo JSP ha cambiado. Modificando este proceso,
se puede ahorrar tiempo y recursos consumidos por las compilaciones y asegu-
rar que se tenga el control de la compilación de los archivos JSP. También es
útil como una manera rápida al sincronizar todos los archivos JSP para una
aplicación.
4.1.9. Desarrollando Aplicaciones
Para WebSphere Application Server, las aplicaciones son combinaciones

de bloques que trabajan conjuntamente para el logro de una función de la
lógica comercial. Las aplicaciones Web son grupos de uno o más servlets, más
el contenido estático.
Aplicaciones Web = servlets + archivos JSP + archivos XML + archivos
HTML + gráficos.
El modelo de programación de WebSphere Application Server está basado
en la plataforma Java de Sun (J2SE). El ambiente J2SE soporta la base para
construir redes centrales de aplicaciones empresariales para correr sobre una
variedad de sistemas. El software J2SE consiste en los Java SDK Standard

Edition y el Java Runtime Environment (JRE) Standard Edition.
4.1.10. Fases de Inicialización y de Terminación
Un motor del servlet crea una instancia de un servlet en los siguientes

momentos:
Automáticamente en el arranque de la aplicación, si esa opción se con-

figura para el servlet.
En la primera demanda del cliente para el servlet después del arranque
de la aplicación.
Cuando el servlet se vuelve a cargar.
El método INIT ejecuta sólo una vez durante la vida del servlet. Ejecuta
cuando el motor del servlet carga el servlet. Con el Application Server se puede
configurar el servlet para ser cargado cuando comienza la aplicación o cuando
un cliente accede por primera vez al servlet. El método INIT no se repite a
menos que muchos clientes accedan al servlet.
El método destroy () ejecuta sólo una vez durante la vida del servlet. Eso
pasa cuando el motor del servlet detiene el servlet. Típicamente, se detienen
servlets como parte del proceso de detener la aplicación.
4.1.11. Rasgos de Java Servlet API
Algunos puntos de interés del Java Servlet API son:
Un despachador de requerimientos asociado a cada recurso (servlet).
Un despachador de requerimientos de recursos que pueden procesar de-

mandas HTTP (como servlets y archivos JSP) y los archivos relacionados a
esos recursos (como HTML estático y GIFs). El motor del servlet genera un
solo despachado de requerimiento por cada servlet o JSP cuando se produce
una instanciación. El despachador recibe el pedido del cliente y despacha la
demanda al recurso.
Un contexto del servlet para la aplicación.
4.1.12. Patrones y Guías de Servlets/JSP
A continuación se proporcionan las pautas específicas sobre cómo organizar

una aplicación que usa servlets y JSP’s.
Patrones Servlet/JSP.
Con este modelo es posible organizar una aplicación Web en el servlets y

JavaServer Pages de manera tal que es fácil de mantener el código.
Motivación.
Para aplicaciones que requieren modelado complejo sobre el nodo del servi-
dor de aplicación Web, no es fácil definir la granularidad de servlets y cómo
interactúan los servlets. Pero sin un buen diseño para el servlets y JSP es
difícil mantener la aplicación.
Además en la fase del análisis de un proyecto, usa casos y diagramas de

transición de estados ampliamente usados para describir el resultado de la fase
del análisis. Podría ser útil trazar esos resultados en el diseño e implementación
de la fase.
En un caso se puede contemplar el servlet como el evento central y procesa
todas las demandas del cliente. Ejecuta la acción necesaria para ese evento y
envía el requerimiento a uno (de muchos) JavaServer Page por desplegar el
resultado. Usando esta solución, puede ser difícil de desarrollar ese servlet. Así
como es responsable para un conjunto de casos de uso, se puede tener que
llevar a cabo mucha lógica en ese servlet.
En otro caso se puede tener tantos servlets como JavaServer Pages y en-
cadenarlos. Esto significa que un servlet obtiene un requerimiento, ejecuta la
acción correcta, y llama al JavaServer Page específico para ese servlet, para de-
splegar el resultado. Un requerimiento de ese JSP entonces obtiene otro servlet,
y así sucesivamente. Será difícil mantener muchos servlets y JSP, puede con-
fundirse al intentar entender el flujo de la aplicación.
Una solución que tiene una granularidad entre esos extremos es dividien-
do la aplicación en estados diferentes. Se intenta transferir un diagrama de
transición de estados (por ejemplo, modelado con RationalRose) en páginas
HTML, servlets y JavaServer Pages.
Applicabilidad.
Este modelo puede usarse en toda aplicación servlet /JSP. Es recomenda-

ble este modelo sobre todo en las aplicaciones Web complejas donde muchas
páginas Web y transiciones de páginas tienen que ser desarrolladas.
Componentes.
Los componentes en esta estructura son:
• Servlet: Un requerimiento dado recoge los datos requeridos para el

despliegue de un estado dado o invoca la acción que causa una tran-
sición fuera del estado. Esta responsabilidad lo hace el controlador
en un Modelo-Vista-Controlador (MVC) basado en la aplicación.
• JavaServerPage: Es el indicador de la generación de código HTML
para un resultado del requerimiento dado.
• Wrapper de Tareas: Encapsula el acceso al proceso empresarial
de negocios (datos back-end y función). Esta función realiza el mo-
delo de wrapper de tareas en una aplicación MVC.
• Páginas HTML: En caso de contenido estático y transiciones de
estado, no es necesario tecnologías complejas. Un indicador de es-
tado estático de página HTML.
Colaboradores.
Un flujo de aplicación Web puede capturarse en un diagrama de transición

de estado (que es, a propósito, una documentación buena para el flujo de la
aplicación). Un diagrama de transición de estado contiene nombres de estado
conectados con los nombres de las ramas.
La solución,es trazar cada componente del diagrama de transición de estado
a un componente de la arquitectura de e-business para que pueda manejarse
mediante WebSphere Aplication Server.
Se separa en el diagrama los estados estáticos y los estados dinámicos.

Las transiciones de estado estáticos son inherentes. Como ellos son estáticos
en el controlador y en las transiciones, se puede codificar un estado como una
página HTML que debe ser nombrado después del estado: < el Estado >.html.
Cuando hereda estados dinámicos, es un tanto más dificultoso. Conforme

a la arquitectura e-business, se divide el estado en modelo, vista y controlador.
Controlador.
El servlet actúa como el controlador de estado en este escenario. Esto

significa que se captura un servlet por estado dinámico. Nombrando la con-
vención, el servlet es llamado después del estado: < State>Servlet. Haciendo
esto se consigue un método fácil de documentación.
Pensando sobre cada interacción entre el navegador y el servidor de apli-
caciones Web (por ejemplo, el servlet) como una sola unidad de trabajo, de
sólo lectura o de actualización. Hay dos flujos básicos de modelos de control,
ambos, llevado a cabo por el servlet. Uno se ocupa del despliegue para un
estado dado, y el otro maneja las acciones que causan un cambio de estado.
Despliegue de Patrones.
Este modelo normalmente se manifiesta dentro de HTML como un link,

resultando en un requerimiento Get. El flujo de control para este modelo es:
• El servlet invoca el método apropiado de sólo lectura en el modelo

de estado (ese es el wrapper de la tarea) y selecciona el JSP para
ocuparse del resultado.
• El servlet inicializa el objeto de datos asociado con el JSP, carga el
resultado y coloca la vista del bean en un atributo HttpRequest.
• El servlet remite la demanda al JSP escogido.
• La Página de JavaServer genera el código del HTML.
• El servlet envía el requerimiento al JSP seleccionado.
• El JSP genera el código HTML.
Vistas.
Las vistas se implementan como un JSP.
Cosecuencias.
Usando este modelo, es posible conseguir un acercamiento bueno para di-

señar una aplicación Web, mediante la utilización de servlets, JSPs, wrapper
de tareas y páginas HTML [2].
Capítulo 5
Introducción al DB2
Express-C 9
DB2 Express-C es un miembro de la familia IBM DB2 de poderosas apli-

caciones de servidores de datos para manejar tanto datos relacionales como
XML. DB2 Express-C es una edición de DB2 libre, sin límites y fácil de usar.
La C en DB2 Express-C significa Comunidad. Una comunidad de usuarios
DB2 Express-C que se juntan para ayudarse unos a otros, tanto en línea como
fuera de ella. La comunidad DB2 Express-C consiste en una variedad de per-
sonas y compañías que diseñan, desarrollan, implementan o utilizan soluciones
de base de datos, como:
87
CAPÍTULO 5. INTRODUCCIÓN AL DB2 EXPRESS-C 9 88
Desarrolladores de aplicaciones que requieren un software de base de

datos de estándar abierto para construir aplicaciones standalone, cliente-
servidor, Web y empresariales.
ISVs, vendedores de hardware, vendedores de infraestructura de pila y

proveedores de otros tipos de solución que quieran incluir o empotrar un
completo servidor de datos como parte de sus soluciones.
Consultores, administradores de base de datos y arquitectos IT que nece-

siten un servidor de datos robusto para entrenamiento, desarrollo de
habilidades, evaluación y prototyping.
Startups, pequeñas y medianas compañías que necesitan un servidor de

datos confiable para sus aplicaciones y operaciones.
Estudiantes, profesores y otros usuarios académicos que quieran un servi-

dor de datos altamente versátil para enseñanza, courseware, proyectos e
investigaciones [3].
DB2 Express-C comparte el mismo núcleo de funcionalidad y código base

como las ediciones pagadas de DB2 para Linux, UNIX y Windows. DB2
Express-C puede correr en sistemas de 32-bits y 64-bits con sistemas operativos
Windows o Linux. Puede correr en un sistema que tenga cualquier cantidad
de núcleos y de memoria. No tiene ningún requerimiento especial de almace-
namiento o de configuración del sistema que sean especiales. DB2 Express-C
también incluye pureXML sin costo. pureXML es la tecnología única de DB2
para almacenar y procesar documentos XML nativamente. [4]
5.0.13. Servidores DB2
Todas las ediciones de servidores DB2 contienen el mismo núcleo de com-

ponentes; están empaquetados de tal manera que los usuarios puedan escoger
las funciones que necesitan al precio correcto. Figura 5.1 de la página 89 ilustra
las diferentes ediciones de productos DB2.
Como se muestra en la figura 5.1, DB2 Express-C es igual que DB2 Express
solo que sin algunos componentes. DB2 Express-C es libre a la comunidad.
La figura 5.1 también explica porqué es tan fácil actualizar desde DB2
Express-C. Si se desea actualizar a cualquier otro servidor DB2 en el futuro,
Figura 5.1: Servidores DB2.
todos los servidores DB2 tienen el mismo núcleo de componentes. Esto tam-
bién significa que una aplicación desarrollada para una edición trabajará, sin
ninguna modificación, en otra edición. Y cualquier habilidad aprendida en una
edición aplicará a las otras ediciones.
5.0.14. Clientes DB2 y Controladores
Un cliente DB2 incluye las funcionalidades necesarias para conectarse a

un servidor DB2, sin embargo, un cliente no siempre tiene que ser instalado.
Por ejemplo, una aplicación JDBC Type 4 puede conectarse directamente a
un servidor DB2, previsto del correcto controlador ya cargado. Los clientes
DB2 vienen en diferentes formas:
Cliente Servidor de Datos IBM (IBM Data Server Client): el más com-
pleto, incluye herramientas GUI, controladores.
Cliente de Tiempo de Ejecución de Servidor de Datos (IBM Data Server

Runtime Client): funcionalidad básica para conectarse e incluye contro-
ladores.
Módulos fusionados de Cliente de Tiempo de Ejecución DB2 para Win-

dows (DB2 Runtime Client Merge Modules for Windows): principal-
mente usado para incluir un cliente de Tiempo de Ejecución DB2 como
parte de la instalación de una aplicación Windows [5].
Aunque todos los clientes DB2 incluyen sus controladores requeridos, a

partir de DB2 9 se proveen controladores individuales también. Todos los
clientes DB2 y controladores son gratis y disponibles para descargar desde el
sitio Web de DB2 Express-C. Los clientes y controladores pueden ser usados
para conectarse a un servidor DB2 en Linux, UNIX o Windows. Para conec-
tarse a servidores DB2 para z/OS R
o DB2 para i5/OS R
es necesario ir a
través de un servidor DB2 Connect.
5.0.15. Características y Productos Relacionados
Las características incluidas en la versión gratuita de DB2 Express-C son:
La funcionalidad base de DB2.
Control Center, Data Studio y otras herramientas de manejo pureXML.
Utilización de recursos hasta 2GB y 2 núcleos.
Disponible en Linux, Windows, y Solaris (x86).
Las capacidades disponibles con la licencia de 12 meses de DB2 Express-C

son:
Fix packs.
Alta disponibilidad y Recuperación Critica (HADR).
Data Replication (Homogenous SQL).
Utilización de recursos hasta 4GB y 4 núcleos (en 2 tomas).
5.0.16. Características incluídas en otras ediciones de DB2:
Características pagadas en la edición DB2 Express:
pureXML.
Alta disponibilidad.
Federación Homogénea.
Características incluidas sin costo en la edición DB2 Workgroup:
Alta disponibilidad.
Disponible en AIX
R
, Solaris, y HP-UX además de Linux y Windows.
Características pagadas en la edición DB2 Workgroup:
pureXML.
Optimización de Performance (MQT, MDC, Query Parallelism).
Federación Homogénea.
Características incluídas sin costo en la edición DB2 Enterprise:
Particionamiento de Tablas (Range).
Materialized Query Tables (MQT ).
Multi-dimensional Clustering (MDC ).
Alta disponibilidad y Recuperación Critica (HADR).
Conexión Concentrada.
Características pagadas en la edición DB2 Enterprise:
pureXML.
Optimización de almacenamiento (incluido compresión).
Control de acceso avanzado (seguridad avanzada).
Optimización del Performance (Performance Experto, Query Patroller ).

Administración de datos Geodetic.

Federación Homogénea DB2.
Productos pagados relacionados a DB2 :
DB2 Connect.
DB2 Warehouse Editions.
WebSphere
R
Federation Server.
WebSphere Replication Server.
5.0.17. Características Incluidas con la Licencia de Suscripción

de DB2 Express-C
Fix Packs
Un fix pack de DB2 es un paquete de código corregido aplicado en un

producto DB2 instalado, para corregir publicaciones diferentes después de
que el producto fue liberado. Con una licencia de suscripción, la corrección de
paquetes es gratis para descargar e instalar [6].
Alta disponibilidad de Recuperación Critica (HADR)
Alta disponibilidad de Recuperación Crítica (HADR) es una caracterís-

tica de fiabilidad de base de datos que proporciona una alta disponibilidad
y la solución de recuperación de datos ante desastres de sitio completos así
como parciales. Un ambiente HADR generalmente consiste en dos servidores
de datos, el primario y el secundario (que puede estar en posiciones geográfi-
camente distantes). El servidor primario es donde la fuente de base de datos
es almacenada y accesada por aplicaciones de clientes.
Como las transacciones son procesadas sobre la base de datos primaria, los
registros de la base de datos automáticamente son transportados al servidor
secundario a través de la red. El servidor secundario tiene una copia clonada
de la base de datos primaria, por lo general creada por el back-up de la base
de datos primaria y restaurándolo sobre la base de datos secundaria. Cuando
los registros de la base de datos primaria son recibidos ellos son reproducidos
de nuevo y aplicados a la base de datos secundaria.
Por la repetición continua de los registros, la base de datos secundaria

mantiene una réplica en sincronización de la base de datos primaria que puede
asumir si la base de datos primaria falla.
Una solución completa de DB2-supported HADR
Capacidad rápida de solución ante fallas, con transparencia completa

para clientes y aplicación de cliente.
Atomicidad completa en las transacciones para prevenir perdida de datos.
Habilidad de actualizar sistemas o aplicaciones sin interrupción de ser-
vicios visibles.
Sistema remoto de fallas, proporcionando recuperación completa de de-
sastre local que puede dañar el centro de datos.
Administración fácil con herramientas graficas de DB2.
Todos esto con un impacto insignificante sobre funcionamiento total del
sistema.
Réplica de Datos
Esta característica permite la réplica de datos entre un servidor fuente

donde los cambios de datos con capturados, y un servidor objetivo donde el
cambio de datos son aplicados. La figura 5.2 de la página 94 proporciona una
descripción de cómo trabaja la réplica.
En la figura hay dos servidores, un servidor fuente y un servidor objetivo.
En el servidor fuente, el programa Capture captura el cambio hecho en la base
de datos. En el servidor objetivo, un programa Apply aplica los cambios de la
base de datos replica. La réplica es útil para una variedad de propósitos que
requieren replica de datos, incluyendo alivio de capacidad, sosteniendo el data
warehouse y el mercado de datos, revisando el historial de cambios. Usando las
características de la réplica SQL puedes replicar datos entre DB2 Express-C
y otros servidores DB2, incluyendo aquellos en otros sistemas Linux, UNIX,
z/OS, y i5/OS.
Figura 5.2: Réplica de SQL.
5.0.18. Características No Disponibles con DB2 Express-C
Esta sección describe alguna de las características disponibles en otras

ediciones de DB2 pero no en DB2 Express-C.
Particionamiento de la Base de Datos
La característica de particionamiento de la base de datos (DPF ) es solo

disponible con DB2 Enterprise Edition con la licencia de pago adicional. Esto
permite a la base de datos ser extendido a través de múltiples particiones los
cuales pueden estar alojados en varias computadoras. DPF está basado en una
arquitectura shared-nothing. Cada computadora, como es añadido al grupo de
partición, trae el poder adicional de procesamiento de datos con sus propias
CPUs y memoria. DPF es en particular útil en ambientes de servidor de datos
grandes como data warehouses donde las sentencias de los sistemas de apoyo
de decisión (DSS ) son controlados.
Concentrador de Conexión
El concentrador de conexiones es una característica que permite el soporte

de un largo número de usuarios conectados simultáneamente. Previamente,
toda conexión a la base de datos requiere un agente de base de datos. El con-
centrador de conexiones introduce el concepto de un agente lógico, permitiendo
un agente para mantener muchas conexiones.
Geodetic Extender
DB2 Geodetic Extender esta disponible con pago adicional para DB2 En-
terprise Edition. Este extender hace desarrollos para aplicaciones de inteligen-
cia de negocios y egovernment que requieren un análisis de localización geo-
gráfica mucho más sencillo. DB2 Geodetic Extender puede construir un globo
mundial virtual a cualquier escala. La mayoría de información de localización
es tomada usando sistemas worldwide, por ejemplo el sistema de satélites de
posicionamiento global (GPS ), y puede ser representado en coordenadas de
latitud/longitud (geocódigo). Los datos de negocios, como direcciones, pueden
ser convertidos a geocódigo con DB2 Geodetic Extender y aplicaciones a ni-
vel empresarial trabajan mejor cuando mantienen los datos en esta forma sin
proyección, saliendo las proyecciones del mapa (tierra a mapa plano) donde
ellos pertenecen, en la capa de presentación, para mostrar e imprimir mapas.
Workload Management (WLM)
Maneja cargas de trabajo en una base de datos en base a prioridades de

un usuario y de aplicaciones combinadas con la disponibilidad de recursos y
límites. Permite regular la carga de trabajo de tu base de datos y consultas,
de tal manera que consultas importantes y de alta prioridad pueden corer
inmediatamente, y , and previene consultas espontáneas que no tienen buen
rendimiento de monopolizar los recursos del sistema de manera que tu sistema
puede correr eficientemente. WLM is Nuevo en DB2 9.5 y prove mas poder
que las características de las herramientas Query Patroller y del DB2 Governor
que eran disponibles en versiones anteriores de DB2.
Figura 5.3: DB2 Connect.
5.0.19. Productos Pagados Relacionados con DB2
DB2 Connect
DB2 Connect es un software pagado que permite al cliente DB2 para

Linux, UNIX o Windows conectarse a un servidor DB2 para z/OS o para
i5/OS, como se muestra en la figura 5.3 de la página 96. DB2 Connect no es
requerido cuando la conexión ocurre en la dirección opuesta: cuando se conecta
desde DB2 para z/OS o i5/OS hacia DB2 para Linux, UNIX o Windows. DB2
Connect viene en dos ediciones principales dependiendo de las necesidades de
conexión: DB2 Connect Personal Edition y DB2 Connect Enterprise Edition.
WebSphere Federation Server
Antiguamente conocido como WebSphere Information Integrator (para so-

porte de federación), WebSphere Federation Server permite una federación de
base de datos; significando que puedes correr consultas de base de datos que
puedan trabajar con objetos de diferentes sistemas de base de datos relacional.
Por ejemplo, con WebSphere Federation Server, se puede correr la siguiente
consulta:
SELECT *
FROM Oracle.Table1 A
DB2.Table2 B
SQLServer.Table3 C
WHERE
A.col1 < 100
and B.col5 = 1000
and C.col2 = “Test’
La figura 5.4 de la página 98 provee una ilustración donde WebSphere

Federation Server es usado.
WebSphere Replication Server
Antiguamente conocido como WebSphere Information Integrator (para so-

porte de replicación), WebSphere Replication Server permite replicación SQL
en registros de base de datos cuando servidores de datos que no son de IBM
están involucrados. Esto también incluye una característica conocida como
Q-Replication para replicar información usando cola de mensajes.
5.0.20. Guía de Instalación de DB2 Express C
Este apartado explicará paso a paso una instalación básica de DB2 Express-
C en Windows. La misma installation wizard está
disponible en Linux ; por lo tanto los pasos son similares en ambas platafor-
mas.
Figura 5.4: WebSphere Federation Server.

Procedimiento
1. Obtener la imágen de DB2 Express-C. Descargar la imágen apropiada de

DB2 Express-C, u ordenar el Discovery Kit DVD que incluye la imágen
del DB2 Express -C de la página Web www.ibm.com/db2/express.
2. Descomprimir los archivos en el directorio que se desee.
3. Localizar los archivos. Dirígirse hacia el directorio (o unidad) en donde

se encuentran los archivos de instalación que se han descomprimido.
4. Correr el Launchpad. Ejecutar el DB2 Launchpad haciendo doble clic

en el archivo setup.exe. En Linux, ejecutar el commando db2setup como
root. En el Launchpad, clic en la opción Install Product en el panel
izquierdo de la ventana.
5. Correr el DB2 setup wizard. El DB2 setup wizard revisa si cumple todos
los requerimientos del sistema y ve si existe otra instalación de DB2.
Hacer clic en el botón Next para seguir con la instalación.
6. Revisar los términos de licencia. Leer y aceptar los términos de licen-

cia (seleccionar el radio button I Accept...) y clic al botón Next para
continuar.
7. Elegir el tipo de instalación. En este caso, seleccionar la opción Typical

(opción por defecto). La opción Compact realiza una instalación básica,
mientras la opción Custom permite personalizar la configuración especí-
fica que se quiere instalar. Clic en el botón Next para continuar.
8. Seleccionar la carpeta para la instalación. Esta pantalla permite elegir

la unidad y el directorio donde el código de DB2 es instalado en el
sistema. Asegurarse de que exista espacio suficiente para la instalación.
Usar la unidad y el directorio por defecto para este ejemplo (mostrado a
continuación): Unidad: C: Directorio: C:\Archivos de Programa\ IBM\
SQLLIB. Clic en el botón Next para continuar.
9. Configurar la información del usuario. Una vez que DB2 Express-C es-
tá instalado, asegurarse que los procesos de DB2 están corriendo como
Servicios del Sistema. Estos servicios requieren una cuenta del sistema
operativo para poder correrlo. En el ambiente de Windows, usar la cuen-
ta por defecto db2admin es recomendada. Si esta cuenta aun no existe,
DB2 la creará en el Sistema Operativo. También se puede especificar
una cuenta existente, pero esa cuenta debe tener los permisos de admi-
nistrador local. Se recomienda usar las opciones sugeridas. Asegurarse
de especificar el password para la cuenta. En Linux se usa el UserID por
defecto db2inst1 (dueño de la instancia), db2fenc1 (usuario para rutinas
limitadas) y dasusr1 (usuario del DB2 Administrator Server, DAS ). Clic
en el botón Next para continuar.
10. Configurar la instancia DB2. Pensar en el concepto de instancia DB2

como un contenedor para bases de datos. Una instancia debe existir
antes de que una base de datos pueda ser creada dentro de ella. En una
instalación en Windows, la instancia llamada DB2 se creará automáti-
camente. En Linux, el nombre por defecto de la instancia es db2inst1.
Por defecto, la instancia DB2 esta configurada para escuchar conexiones
TCP/IP en el puerto 50000. El protocolo por defecto y el puerto pueden
ser cambiados dándole clic en Protocols y el botón Startup, respectiva-
mente. Se recomienda usar las opciones por defecto para este ejemplo.
Clic en el botón Next para continuar.
11. Comenzar con la instalación. Revisar las opciones de instalación selec-

cionadas previamente. Hacer clic en el botón Install para comenzar a
copiar los archivos a la carpeta destino de instalación. DB2 también
realizará algunos procesos de configuración iniciales.
12. Primeros pasos. Luego que la instalación ha terminado, otra herramien-

ta llamada First Steps arranca automaticamente. First Steps también
puede ser arrancada con el comando db2fs.
13. La base de datos SAMPLE es una base datos que se puede usar para
probar DB2. Esta es creada automáticamente luego de la instalación de
DB2. Verificar que la base de datos exista abriendo la herramienta DB2
Control Center. Para abrir esta herramienta, del botón Inicio de Win-
dows elegir: Inicio → Programas → IBM DB2 →DB2COPY1 (Default)
→ General Administration Tools → Control Center. Ademas se puede
iniciar el Control Center con el comando db2cc.
14. Si la base de datos SAMPLE se muestra en el Control Center, se puede

saltar al paso 16. Si no se muestra, seleccionar el item Refresh del menu
Control Center View para asegurar que se puede ver toda la información
refrescada. Si la base de datos SAMPLE sigue sin aparecer, es porque no
ha sido creada. Habrá que crearla manualmente del First Steps. Elegir
donde dice Database Creation, y luego guiarse con el Wizard para crear
Figura 5.5: Ventana de Progreso en DB2.
la base de datos SAMPLE. Asegurarse que los objetos XML y SQL y

las opciones de datos son seleccionados, y luego clic en OK. Esta última
opción creará una base de datos UNICODE el cual fue requerido en la
version 9 para soportar XML puro (pureXML), pero no es necesario en
DB2 9.5.
15. La siguiente ventana que se visualiza en la figura 5.5 de la página 101,

aparece cuando la base de datos esta siendo creada. (Este procedimiento
puede tomar algunos minutos). Cuando la base de datos es creada, clic
en el botón OK y cerrar la herramienta First Steps.
1. Regresar al Control Center y verificar que la base de datos SAMPLE

aparezca en el panel Object Tree. Se debe refrescar la vista del Control
Center para ver los nuevos cambios efectuados. Para hacer esto, selec-
cionar el item Refresh del menu Control Center View.
2. Reiniciar la computadora. A pesar que este paso no esta mencionado

en la documentación oficial de instalación DB2, se recomienda reiniciar
el sistema (si es posible, por lo menos en Windows) para asegurarse
que todos los procesos comiencen satisfactoriamente y limpien cualquier
recurso de memoria que no han sido eliminados correctamente. Esto es
OPCIONAL.
Figura 5.6: Herramientas DB2.
5.0.21. Herramientas de DB2
En este apartado, se describirán algunas de las herramientas que se pueden

usar con DB2.
La elipse roja en la figura 5.6 de la página 102 muestra el área en la que
se centra este apartado.
La figura 5.7 lista todas las herramientas disponibles en el menú de inicio
de DB2. La mayoría de esas herramientas son las mismas en Linux y Windows.
La tabla 5.1 de la página 103 provee una lista de comandos que pueden ser
usados para iniciar algunas de las herramientas más populares tanto en Linux
o Windows.
Figura 5.7: Herramientas DB2: Menú Inicio.
Herramienta Comando
Editor de Comandos db2ce
Command Line processor db2
Ventana de Comandos db2cmd
Control Center db2cc
Task Center db2tc
Health Center db2hc
Configuration Assistant db2ca
First Steps db2fs
Cuadro 5.1: Comandos Para Iniciar Algunas Herramientas DB2.

Figura 5.8: Centro de Control de DB2.
Centro de Control (Control Center)
La herramienta primaria para la administración de DB2 es el Centro de

Control, ilustrado en la figura 5.8 de la página 104.
El Centro de Control es una herramienta de administración centralizada
que permite:
Ver el sistema, instancias, bases de datos y objetos de la base de datos;
Crear, modificar y manejar objetos de las bases de datos;
Lanzar otras herramientas gráficas de DB2.
El panel del lado izquierdo provee una visión jerárquica de los objetos de
la base de datos en el sistema, teniendo una carpeta para Tablas, Vistas, etc.
Al hacer doble clic sobre una carpeta, del lado derecho se listarán todos los
objetos relacionados, como por ejemplo, todas las tablas asociadas con la base
de datos SAMPLE. Si se selecciona una tabla en la parte alta del panel, en la
parte baja del lado derecho del panel se proveerá información más específica
acerca de esa tabla.
Al hacer clic derecho sobre los diferentes objetos/carpetas en el árbol de

objetos es posible ver el menú con las opciones aplicables a los objetos/carpetas
[6].
La primera vez que se lanza el Centro de Control, preguntará qué vista se
prefiere usar. La elección de la vista determina qué tipo de opciones y objetos
de la base de datos son expuestos:
La vista básica provee la funcionalidad elemental.
La vista avanzada muestra más opciones y mejoras.
La vista personalizada permite ajustar las mejoras específicas, opciones

y objetos que se mostrarán.
Cómo Lanzar el Centro de Control Hay varias formas de lanzar el Cen-

tro de Control :
Navegando a través del menú de inicio de Windows.
Ejecutando db2cc en la línea de comandos.
Dando clic en el icono de el Centro de Control en la barra de herramientas

de cualquier otra herramienta gráfica de DB2.
Desde el icono DB2 en Windows como se muestra en la figura 5.9 de

la página 106 (Da clic sobre el icono verde DB2 y seleccionar la opción
Central de Control de DB2 ).
El Editor de Comandos DB2
Usando el Editor de Comandos DB2 (editor de comandos), se pueden eje-

cutar comandos DB2, sentencias SQL y XQuery, analizar el plan de ejecución
de una sentencia, y ver o actualizar resultados de consultas.
La figura 5.10 de la página 106 muestra el Editor de Comandos.
Figura 5.9: Icono DB2 en Windows.
Figura 5.10: Editor de Comandos.

Figura 5.11: Botón Show SQL.
En el área de entrada, se pueden ingresar varias sentencias, tan largas hasta

que se presente el caracter de finalización. Si se presiona el botón ejecutar, las
sentencias serán ejecutadas una después de otra. Si se selecciona explícitamente
una sentencia, sólo esa sentencia será ejecutada. Debe existir una conexión
a la base de datos para devolver sentencias SQL, sin embargo, una de esas
sentencias puede ser una sentencia de conexión.
SQL Assist Wizard
Si no se está familiarizado con el lenguaje SQL se podría usar un asistente

para generar código SQL, el SQL Assist Wizard está disponible en el Editor de
Comandos para ayudarte. Como se muestra en la figura 5.11, invócalo desde
el Editor de Comandos dando clic sobre le último icono con el símbolo SQL.
Su uso es bastante claro. Primero indica el tipo de sentencia SQL para la
cual se necesita asistencia (SELECT, INSERT, UPDATE, DELETE). Depen-
diendo de que sentencia se haya elegido, diferentes opciones aparecerán. En
la parte baja de la ventana mostrará cómo la sentencia SQL es construida a
partir de diferentes elecciones en el asistente [4].
El Botón Show SQL
La mayoría de las herramientas gráficas y los asistentes en DB2 permiten

revisar el comando actual o la sentencia SQL que es creada como resultado de
usar la herramienta para realizar tal acción. Para ver esto, da clic en el botón
Show SQL en la herramienta en la que se está trabajando, como lo muestra la
figura 5.11 y figura 5.12 en las páginas 107 y 108 respectivamente.
La posibilidad de revisar las sentencias SQL y comandos es muy útil para
aprender sintaxis SQL, y para guardar comandos o sentencias para su posterior
uso. También se puede construir scripts re usando esos comandos y sentencias
generados [7].
Figura 5.12: Salida de un Botón Show SQL.

Capítulo 6
Eclipse
6.1. ¿Que es Eclipse?
Eclipse es principalmente una plataforma de programación, usada para

crear entornos integrados de desarrollo (del Inglés IDE).
Eclipse fue desarrollado originalmente por IBM Canadá, desarrollado por
OTI (Object Technology International) como reemplazo ó el sucesor de su
109
CAPÍTULO 6. ECLIPSE 110
familia de herramientas para VisualAge. Eclipse es ahora desarrollado por la

Fundación Eclipse, una organización independiente sin ánimo de lucro que
fomenta una comunidad de código abierto y un conjunto de productos com-
plementarios, capacidades y servicios.
Eclipse es también una comunidad de usuarios, extendiendo constante-

mente las áreas de aplicación cubiertas. Un ejemplo es el recientemente creado
Eclipse Modeling Project, cubriendo casi todas las áreas de Model Driven
Engineering.
La licencia de Eclipse fue liberada originalmente bajo la Common Public
License, pero después fue re-licenciada bajo la Eclipse Public License. La Free
Software Foundation ha dicho que ambas licencias son licencias de software
libre, pero son incompatibles con Licencia Pública General de GNU (GNU
GPL) [2].
6.2. ¿Como Utilizar Eclipse?
Eclipse es un entorno de desarrollo integrado de código abierto multi-

plataforma para desarrollar lo que el proyecto llama “Aplicaciones de Cliente
Enriquecido”, opuesto a las aplicaciones “Cliente-liviano” basadas en navega-
dores. Esta plataforma, típicamente ha sido usada para desarrollar entornos
de desarrollo integrados (del inglés IDE), como el IDE de Java llamado Java
Development Toolkit (JDT) y el compilador (ECJ) que se entrega como parte
de Eclipse y que son usados también para desarrollar el mismo Eclipse. Sin
embargo, también se puede usar para otros tipos de aplicaciones cliente, como
BitTorrent Azureus [8].
Frame principal de desarrollo de Eclipse.
El entorno de desarrollo integrado (IDE) de Eclipse emplea módulos (en in-

glés plug-in) para proporcionar toda su funcionalidad al frente de la plataforma
de cliente rico, a diferencia de otros entornos monolíticos donde las funciona-
lidades están todas incluidas, las necesite el usuario o no. Este mecanismo de
módulos es una plataforma ligera para componentes de software. Adicional-
mente a permitirle a Eclipse extenderse usando otros lenguajes de progra-
mación como son C/C++ y Python, permite a Eclipse trabajar con lenguajes
para procesado de texto como LaTeX, aplicaciones en red como Telnet y Sis-
tema de gestión de base de datos. La arquitectura plugin permite escribir
cualquier extensión deseada en el ambiente, como sería Gestión de la configu-
ración. Se provee soporte para Java y CVS en el SDK de Eclipse. Y no tiene
por qué ser usado únicamente para soportar otros lenguajes de programación.
La definición que da el proyecto Eclipse acerca de su software es una especie
de “herramienta universal” - un IDE abierto y extensible para todo y nada en
particular.
En cuanto a las aplicaciones clientes, eclipse provee al programador con

frameworks muy ricos para el desarrollo de aplicaciones gráficas, definición y
manipulación de modelos de software, aplicaciones web, etc. Por ejemplo, GEF
(Graphic Editing Framework - Framework para la edición gráfica) es un plugin
de Eclipse para el desarrollo de editores visuales que pueden ir desde proce-
sadores de texto hasta editores de diagramas UML, interfaces gráficas para el
usuario (GUI), etc. Dado que los editores realizados con GEF viven dentro de
Eclipse, además de poder ser usados conjuntamente con otros plugins, hacen
uso de su interfaz gráfica personalizable y profesional.
El SDK de Eclipse incluye las herramientas de desarrollo de Java, ofrecien-
do un IDE con un compilador de Java interno y un modelo completo de los
archivos fuente de Java. Esto permite técnicas avanzadas de refactorización
y análisis de código. El IDE también hace uso de un espacio de trabajo, en
este caso un grupo de metadata en un espacio para archivos plano, permitien-
do modificaciones externas a los archivos en tanto se refresque el espacio de
trabajo correspondiente.
La instalación del Eclipse es muy sencilla, se puede descargar gratuita-

mente de www.eclipse.org en forma de archivo ZIP y se descomprime en la
carpeta donde se quiere instalar. Para ejecutar solo hay que arrancar el fichero
Eclipse.exe . Una vez arrancado lo único que se pide es que se le dé la ruta
por defecto donde se quiere que Eclipse vaya guardando los proyectos que se
vayan creando.
Eclipse puede utilizar varias perspectivas en su ventana principal depen-

diendo del tipo de desarrollo que se vaya a realizar. En el presente trabajo se
utilizó la perspectiva “Java”. Una vez que se termina el proyecto, el mismo se
puede probar mediante la ejecución del programa para ver si funciona, ya que
el mismo posee un área donde se puede hacer correr el servidor de prueba y
probar la aplicación realizada, de esta forma es un entorno versatil y sencillo
para poder realizar los programas en java [2].
Capítulo 7
Introducción al Servidor
Tomcat 5.0
7.1. Descripción
Tomcat (también llamado Jakarta Tomcat o Apache Tomcat) funciona

como un contenedor de servlets desarrollado bajo el proyecto Jakarta en la
Apache Software Foundation. Tomcat implementa las especificaciones de los
servlets y de JavaServer Pages (JSP) de Sun Microsystems.
7.2. Entorno
Tomcat es un servidor web con soporte de servlets y JSPs. Tomcat no

es un servidor de aplicaciones, como JBoss o JOnAS. Incluye el compilador
Jasper, que compila JSPs convirtiéndolas en servlets. El motor de servlets de
Tomcat a menudo se presenta en combinación con el servidor Web Apache [9].
Tomcat puede funcionar como servidor web por sí mismo. En sus inicios
existió la percepción de que el uso de Tomcat de forma autónoma era sólo
recomendable para entornos de desarrollo y entornos con requisitos mínimos
de velocidad y gestión de transacciones. Hoy en día ya no existe esa percepción
y Tomcat es usado como servidor Web autónomo en entornos con alto nivel
de tráfico y alta disponibilidad.
114
CAPÍTULO 7. TOMCAT 115
Dado que Tomcat fue escrito en Java, funciona en cualquier sistema oper-
ativo que disponga de la máquina virtual Java [2].
7.3. Estado de su Desarrollo
Tomcat es mantenido y desarrollado por miembros de la Apache Software

Foundation y voluntarios independientes. Los usuarios disponen de libre acceso
a su código fuente y a su forma binaria en los términos establecidos en la
Apache Software Licence. Las primeras distribuciones de Tomcat fueron las
versiones 3.0.x. Las versiones más recientes son las 6.x, que implementan las
especificaciones de Servlet 2.5 y de JSP 2.1. A partir de la versión 4.0, Jakarta
Tomcat utiliza el contenedor de servlets Catalina [10].
7.4. Estructura de Directorios
La jerarquía de directorios de instalación de Tomcat incluye:
bin - arranque, cierre, y otros scripts y ejecutables.

common - clases comunes que pueden utilizar Catalina y las aplicaciones
web.
conf - ficheros XML y los correspondientes DTD para la configuración
de Tomcat.
logs - logs de Catalina y de las aplicaciones.
server - clases utilizadas solamente por Catalina.
shared - clases compartidas por todas las aplicaciones web.
webapps - directorio que contiene las aplicaciones web.
work - almacenamiento temporal de ficheros y directorios.
7.5. Características del Producto

Tomcat 3.x (distribución inicial):
• Implementado a partir de las especificaciones Servlet 2.2 y JSP 1.1.
• Recarga de servlets.
• Funciones básicas HTTP.
Tomcat 4.x:

• Contenedor de servlets rediseñado como Catalina.
• Motor JSP rediseñado con Jasper.
• Conector Coyote.
• Java Management Extensions (JMX), JSP Y administración basada
en Struts.
Tomcat 5.x:

• Recolección de basura reducida.
• Capa envolvente nativa para Windows y Unix para la integración
de las plataformas.
• Análisis rápido JSP.
Tomcat 6.x:
• Implementado de Servlet 2.5 y JSP 2.1.

• Soporte para Unified Expression Language 2.1.
• Diseñado para funcionar en Java SE 5.0 y posteriores.
• Soporte para Comet a través de la interfaz CometProcessor.
7.6. Historia
Tomcat empezó siendo una implementación de la especificación de los

servlets comenzada por James Duncan Davidson, que trabajaba como arqui-
tecto de software en Sun Microsystems y que posteriormente ayudó a hacer al
proyecto de código abierto y en su donación a la Apache Software Foundation.
Duncan Davidson inicialmente esperaba que el proyecto se convirtiese en
software de código abierto y dado que la mayoría de los proyectos de este tipo
CAPÍTULO 7. TOMCAT 117
tienen libros de O’Reilly asociados con un animal en la portada, quiso ponerle

al proyecto nombre de animal. Eligió Tomcat (gato), pretendiendo representar
la capacidad de cuidarse por sí mismo, de ser independiente [11].
Capítulo 8
Descripción de la Aplicación
8.1. Descripción General
El presente trabajo se basa en el desarrollo de un software que permite la

gestión de una típica empresa agro-ganadera de una manera muy amigable al
usuario final mediante una aplicación Web multiplataforma con acceso a base
de datos.
El Objetivo fue realizar una aplicación Web multiplataforma desarrollada
en Java, en la cual el usuario final pueda contar con un medio para gestionar
el establecimiento e interaccionar con otras disciplinas, a través de la red,
brindando de esta manera mayor rapidez y eficiencia en la administración del
mismo.
La presente implementación de la aplicación llamada SAG (Sistema Agro-
Ganadero) correrá en la plataforma Windows mediante el uso de software
multiplataforma.
8.2. Análisis
Como primera etapa en el desarrollo de la aplicación se realizó un análisis

exhaustivo de la principal problemática de gestión que posee una empresa
agro-ganadera. En las cuales se utilizaron distintas metodologías de análisis
como Diagramas de contexto que se muestran en la figura 8.1 de la página 119
118
CAPÍTULO 8. DESCRIPCIÓN DE LA APLICACIÓN 119
y casos de uso que son ejemplificados en la figura8.2 de la página119.
Figura 8.1: Diagrama de Contexto .
Figura 8.2: Caso de Uso.
8.3. Desarrollo
De ésta forma el desarrollo de la aplicación se ajusta a las necesidades

propias del establecimiento, ya que permite registrar y organizar la informa-
ción obtenida para cualquiera de las actividades del mismo, ya sean agrícolas o
ganaderas, transformándose en una base de operaciones para el usuario final,

ayudandolo a tomar las decisiones correctas en lo que se refiere a la adminis-
tración del establecimiento, ya que podrán ver reflejados todos los movimien-
tos, y así reducir los tiempos de respuesta para la toma de decisiones.
En la figura 8.3 de la página 120 se puede observar la página principal de

la Aplicación.
Figura 8.3: Página Principal de la Aplicación.
8.3.1. Módulos
El sistema consiste básicamente en ocho módulos bien definidos:
1. Agricultura.
2. Ganadería.
3. Empleados.
4. Bancos.
5. Clientes.
6. Proveedores.
7. Consultas.
8. Planillas.
Agricultura
Este módulo permite administrar los recursos productivos y las distintas

actividades realizadas como:
Cosechas.
Siembras.
Pulverizaciones.
Rollos.
Máquinas.
Campos.
Insumos .
Ventas.
Además permite gestionar las compras, ventas, rinde estimado y total. La

figura 8.4 de la página 122 visualiza la página principal de Agricultura con sus
diferentes secciones.
Figura 8.4: Formulario de Agricultura.
Cosecha
Éste módulo permite manejar todas las operaciones de cosechas propias

y a terceros, como también los traslados de las mismas. La figura 8.5 de la
página 123 ilustra la pantalla con el formulario de carga de cosechas a terceros.
Figura 8.5: Formulario de Carga Cosecha a Terceros.
Siembra
Éste módulo permite manejar todas las operaciones de siembra propia y a

terceros. La figura 8.6 de la página 124 ilustra la pantalla con el formulario de
carga de siembra propia.
Figura 8.6: Formulario de Carga Siembra Propia.
Rollos
La sección de Rollos permite acentar los datos de las producciones de rollos

propios y realizados a terceros. Dicha sección se visualiza en la figura 8.7 de
la página 125.
Figura 8.7: Formulario de Carga Rollos Propios.
Máquinas
Aquí es posible registrar el inventario de máquinas propias que posee la

empresa. La página principal de este módulo se puede observar mediante la
figura 8.8 de la página 126.
Figura 8.8: Formulario de Modificar Máquinas.
Pulverización
En este apartado es posible registrar los trabajos de pulverizaciones reali-

zadas por la empresa y, se puede visualizar su pantalla principal en la figura
8.9 de la página 127.
Figura 8.9: Formulario de Carga Pulverizaciones a Terceros.
Campos
Aquí se registran los campos propios y alquilados que posee la empresa.

Su pantalla principal se muestra en la figura 8.10 de la página 128.
Figura 8.10: Formulario de Carga Campos Propios.
Insumos
Los insumos son registrados en esta sección y su pantalla principal es la

que se muestra en la figura 8.11 de la página 129.
Figura 8.11: Principal de Insumos.
Ventas
Este módulo permite registrar las ventas realizadas por la empresa. Se

visualiza mediante la figura 8.12 de la página 130.
Figura 8.12: Principal de Ventas.
8.3.2. Ganadería
Este módulo permite llevar el control y la planificación de todos los lotes

destinados a ganadería, observando su producción y su evolución a través del
tiempo, además de manejar todos los movimientos de animales que se registren
en el establecimiento, icluyendo:
Ganado.
Sanidad.
Inseminación.
Reproducción.
Balanza.
Campos.
Isumos.
Además permite analizar detalladamente todos lon ingresos y egresos de
la actividad financiera de este sector. La figura 8.13 de la página 131
muestra la pantalla principal del módulo Ganadería, desde la cual se
puede acceder a sus diferentes secciones.
Figura 8.13: Pantalla Principal de Ganadería.
Ganado
Esta sección permite manejar las operaciones relacionadas con el ganado,

como ser, ingreso, egreso, muerte, parición, compra y venta. La figura 8.14 de
la página 132 muestra la pantalla de inicio correspondiente.
Figura 8.14: Pantalla Principal de la Sección Ganado.
Sanidad
Este apartado se encarga del registro de vacunación y baño del ganado. La

figura 8.15 de la página 133 muestra los formularios de carga correspondientes.
Figura 8.15: Formularios de Vacunación y Baño de Ganado.
Inseminación
Esta sección permite registrar todos los datos relacionados con las inse-
minaciones realizadas al ganado. La figura 8.16 de la página 134 visualiza el
formulario.
Figura 8.16: Formulario de Carga de Inseminaciones de Ganado.
Reproducción y Balanza
Estos módulos manejan el registro de los datos relacionados con la preñéz,

tacto y peso del ganado. La figura 8.17 de la página 135 vizualiza los formu-
larios correspondientes.
Figura 8.17: Formularios de Reproducción y Balanza.
8.3.3. Empleados
Este módulo maneja todas las operaciones de alta, baja y modificaciones

de la relación laboral existente entre los empleados y la empresa. La figura
8.18 de la página 136 visualiza la pantalla principal de éste módulo.
Figura 8.18: Página Principal de Empleados.
8.3.4. Bancos
El módulo de Bancos permite registrar los movimientos financieros de la

empresa, como ser, créditos bancarios, tarjetas de crédito, etc. En la figura
8.19 de la página 137 se puede observar la página inicial de éste módulo y la
figura 8.20 de la página 138 visualiza los diferentes formularios que componen
las seecciones disponibles.
Figura 8.19: Página Principal del Módulo Bancos.

Figura 8.20: Operaciones Financieras.
8.3.5. Clientes
Este módulo permite realizar las operaciones de altas, bajas y modifica-

ciones de la cartera de clientes de la empresa. El formulario de carga con los
datos relacionados se puede visualizar en la figura 8.21 de la página 139.
Figura 8.21: Principal de Clientes.
8.3.6. Proveedores
Este módulo permite registrar todos los datos relacionados con los provee-
dores de la empresa, como se puede observar en la figura 8.22 de la página
140.
Figura 8.22: Principal de Proveedores.
8.3.7. Consultas
Este módulo ofrece al sistema la posibilidad de realizar consulta de toda

la información disponible en la base de datos, mediante el armado de informes
y una gran variedad de listados. En la fgura 8.23 de la página 141 se pueden
apreciar algunos de los listados disponibles en el sistema.
Figura 8.23: Ejemplos de Listados Arrojados por el Sistema.
8.3.8. Planillas
Este módulo le ofrece al usuario la posibilidad de imprimir planillas vacías

con los datos existentes en el sistema para su utilización en el campo. La figura
de la página muestra algunas de las planillas disponibles para impresión.
Figura 8.24: Ejemplo de Planillas Disponibles en el Sistema.
8.4. Estructura de Datos
A continuación se mostrará todo lo relacionado con la estructura de la base

de datos utilizada por la aplicación, la base de datos corre sobre el motor de
base de datos multiplataforma DB2 Express-C.
En el siguiente gráfico, se puede observar la base de datos utilizada por la
aplicación.
Figura 8.25: Estructura de la Base de Datos.
La base de datos está compuesta por 28 tablas que se detallan a continua-

ción:
AREA:
• NRO_AREA: INTEGER NOT NULL.

• DES_AREA: VARCHAR(50) NOT NULL.
BANCO:
• COD_BANCO: INTEGER NOT NULL.

• NOMBRE_BANCO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• DIRECCION_BANCO: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.
• TELEFONO_BANCO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No

tiene’.
• TIPO_BANCO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• OBSERVACIONES_BANCO: VARCHAR(500) NOT NULL WITH DEFAULT
‘No tiene’.
• LOCALIDAD_BANCO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.
• PROVINCIA_BANCO: VARCHAR(50).
BANIO:
• COD_BANIO: INTEGER NOT NULL.

• FECHA_BANIO: DATE NOT NULL.
• EMPRESA: VARCHAR(30).
• PRODUCTO: VARCHAR(30).
• ENFERMEDAD: VARCHAR(30).
• CANT_CABEZAS: BIGINT.
• COSTO_CABEZA: BIGINT.
• OTRO: BIGINT.
• COSTO_TOTAL: BIGINT.
CAMPO:
• COD_CAMP: INTEGER NOT NULL.

• NOMBRE_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’.
• UBICACION_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.
• SUPERFICIE_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.
• FUNCION_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’.
• PORCENTAJE_KG_CAMP: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’.
• PRECIO_HA_CAMP: DOUBLE NOT NULL.
• TIPO_CAMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘Propio’.
• EMPRESA_CAMP: VARCHAR(50).
• CANT_LOTES_CAMP: INTEGER.
• KG_FIJADO_CAMP: DOUBLE.
CLIENTE:
• COD_CLIENT: INTEGER NOT NULL.

• NOMBRE: VARCHAR(50) NOT NULL WITH DEFAULT ‘Sin Nombre’.
• CUIT: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• TELEFONO: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• EMAIL: VARCHAR(50) NOT NULL WITH DEFAULT ’No tiene’.
• DOMICILIO: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’.
• LOCALIDAD: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’.
• NOMBREC: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• APELLIDOC: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• TELEFONOC: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• EMAILC: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• PROVINCIA: VARCHAR(30).
COSECHA:
• COD_COSECHA: INTEGER NOT NULL.

• FECHA_COSECHA: DATE.
• EMPRESA_COSECHA: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• MAQUINA_COSECHA: INTEGER.
• OPERADOR_MAQ_COSECHA: INTEGER.
• CAMPO_COSECHA: INTEGER.
• LOTE_CAMPO_COSECHA: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• SUPERFICIE_COSECHA: VARCHAR(50) WITH DEFAULT ‘0’.
• KG_HA_COSECHA: DOUBLE WITH DEFAULT 0.
• KG_EQUIPO_COSECHA: DOUBLE WITH DEFAULT 0.
• PROPIETARIO_EQUIPO_COSECHA: VARCHAR(100) WITH DEFAULT
‘No tiene’.
• PATENTE_EQUIPO_COSECHA: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• CANT_HA_COSECHA: DOUBLE WITH DEFAULT 0.
• IMPORTE_HA_COSECHA: DOUBLE WITH DEFAULT 0.

• IMPORTE_TOTAL_COSECHA: DOUBLE WITH DEFAULT 0.
• CULTIVO_COSECHA: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• TIPO_COSECHA: VARCHAR(50) WITH DEFAULT ‘Propia’.
• PORCENTAJE_PACTADO_COSECHA: DOUBLE WITH DEFAULT 0.
• TN_COSECHA: DOUBLE WITH DEFAULT 0.0.
• CLIENTE_COSECHA: INTEGER.
• FORMA_PAGO_COSECHA: VARCHAR(20).
• DESTINO_COSECHA: VARCHAR(50).
• OPERADOR2_MAQ_COSECHA: INTEGER NOT NULL WITH DEFAULT
0.
• CARTA_APORTE_COSECHA: BIGINT WITH DEFAULT 0.
• LOTE_NOM_COSECHA: VARCHAR(50) NOT NULL WITH DEFAULT ‘’.
CREDITO:
• COD_CRED: INTEGER NOT NULL.

• FECHAE_CRED: DATE.
• NRO_CRED: VARCHAR(20).
• DESTINO_CRED: VARCHAR(30).
• DURACION_CRED: INTEGER.
• EMPRESA_CRED: VARCHAR(30).
• BANCO_CRED: INTEGER.
• TASA_INTERES_CRED: INTEGER.
• TIPO_INTERES: VARCHAR(20).
• TIPO_INTERES1: VARCHAR(20).
• MONEDA_CRED: VARCHAR(30).
• TIPO_PAGO_CRED: VARCHAR(30).
• FECHAV_CRED: DATE.
• OBSERVACIONES_CRED: VARCHAR(50).
• TOTAL_CUOTAS_CRED: INTEGER.
• IMPORTE_CRED: DOUBLE.
FUMIGACION:
• COD_FUM: INTEGER NOT NULL.

• FECHA_FUM: DATE.
• EMPRESA_FUM: VARCHAR(50).
• CAMPO_FUM: INTEGER.
• LOTE_FUM: VARCHAR(50) WITH DEFAULT ‘’.
• LOTE_NOM_FUM: VARCHAR(50) WITH DEFAULT ‘’.
• MAQUINA_FUM: INTEGER.
• OPERADOR_FUM: INTEGER WITH DEFAULT 0.
• OPERADOR2_FUM: INTEGER WITH DEFAULT 0.
• CULTIVO_FUM: VARCHAR(40).
• CLIENTE_FUM: INTEGER.
• PRODUCTO1_FUM: VARCHAR(50) WITH DEFAULT ‘’.
• DOSIS1_FUM: DOUBLE WITH DEFAULT 0.0.
• MEDIDA1_FUM: VARCHAR(20) WITH DEFAULT ‘’.
• CANTIDAD1_FUM: DOUBLE WITH DEFAULT 0.0.
• HA_FUM: INTEGER.
• COSTO_HA_FUM: DOUBLE WITH DEFAULT 0.0.
• COSTO_TOTAL_FUM: DOUBLE WITH DEFAULT 0.0.
• TIPO_FUM: VARCHAR(50).
GANADO:
• COD_GANADO: INTEGER NOT NULL.

• EMPRESA_GANADO: VARCHAR(50).
• NRO_DTA_GANADO: INTEGER.
• NRO_RENSPA_GANADO: INTEGER.
• CANT_CON_CVNA_GANADO: INTEGER.
• CAN_SIN_CVNA_GANADO: INTEGER.
• CANT_TOTAL_GANADO: INTEGER.
• NRO_CVNA_DESDE_GANADO: INTEGER.
• NRO_CVNA_HASTA_GANADO: INTEGER.
• OBSERVACIONES_GANADO: VARCHAR(200).
• NRO_CVNA_GANADO: INTEGER.
• FECHA_GANADO: DATE.
• CATEGORIA_GANADO: VARCHAR(50).
• RAZA_GANADO: VARCHAR(50).
• NRO_COMPROBANTE_GANADO: VARCHAR(50).
• PESO_TOTAL_GANADO: DOUBLE.
• PESO_PROMEDIO_GANADO: DOUBLE.
• PRECIO_KG_GANADO: DOUBLE.
• IMPORTE_CABEZA_GANADO: DOUBLE.
• IMPORTE_TOTAL_GANADO: DOUBLE.
• TIPO_MOVIMIENTO_GANADO: VARCHAR(50).
INSEMINA:
• COD_INSEMINA: INTEGER NOT NULL.

• FECHA: DATE NOT NULL.
• RAZA: VARCHAR(20).
• RODEO: VARCHAR(20).
• CATEGORIA: VARCHAR(20).
• NRO_CARAVANA: BIGINT.
• TORO: VARCHAR(20).
• OBSERVACIONES: VARCHAR(200) NOT NULL WITH DEFAULT ‘’.
INSUMOS:
• COD_INS: INTEGER NOT NULL.

• NOMBRE_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’.
• MEDIDA_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’.
• CANTIDAD_INS: INTEGER NOT NULL WITH DEFAULT 0.
• TIPO_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’.
• PRECIO_INS: DOUBLE NOT NULL WITH DEFAULT 0.
• OBSERVACIONES_INS: VARCHAR(200) NOT NULL WITH DEFAULT ‘No
tiene’.
• FACT_INS: INTEGER NOT NULL WITH DEFAULT 0.
• NRO_FACT_INS: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• TIPO_ALIMENTO_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.
• TIPO_VETERINARIO_INS: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’.
• TIPO_COMBUSTIBLE_INS: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’.
• TIPO_AGROQUIMICO_INS: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’.
• TIPO_SEMILLA_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.
• TIPO_FERTILIZANTE_INS: VARCHAR(100) NOT NULL WITH DEFAULT
‘No tiene’ .
• MARCA_INS: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’.
• MAQUINA_INS: INTEGER NOT NULL WITH DEFAULT 0.
• PROVEEDOR_INS: INTEGER NOT NULL WITH DEFAULT 0.
• FECHA_INS: DATE.
• LUGAR_COMPRA_INS: VARCHAR(50) WITH DEFAULT ‘No tiene’.

• TIPO_PAGO_INS: VARCHAR(20) NOT NULL WITH DEFAULT ”.
• GASTO_TOTAL_INSUMO: DOUBLE NOT NULL WITH DEFAULT 0.
LOTES:
• COD_LOTE: INTEGER NOT NULL.

• CAMPO_LOTE: INTEGER NOT NULL.
• NOMBRE_LOTE: VARCHAR(20) NOT NULL.
MAQUINA:
• COD_MAQ: INTEGER NOT NULL.

• MARCA_MAQ: VARCHAR(100) NOT NULL WITH DEFAULT ‘No tiene’.
• MODELO_MAQ: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• PATENTE_MAQ: VARCHAR(50) NOT NULL.
• ANIO_MAQ: VARCHAR(10) NOT NULL WITH DEFAULT ‘No tiene’.
• PROPIETARIO_MAQ: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.
• DESC_MAQ: VARCHAR(500) NOT NULL WITH DEFAULT ‘No tiene’.
PAGO:
• COD_PAGO: INTEGER NOT NULL.

• NRO_CREDITO_PAGO: VARCHAR(50).
• TASA_INTERES_PAGO: INTEGER WITH DEFAULT 0.
• NRO_CUOTA_PAGO: INTEGER WITH DEFAULT 1.
• MONTO_IVA_PAGO: DOUBLE WITH DEFAULT 0.
• INTERES_PAGO: DOUBLE WITH DEFAULT 0.
• CAPITAL_PAGO: DOUBLE WITH DEFAULT 0.
• OBSERVACIONES_PAGO: VARCHAR(500) WITH DEFAULT ‘No tiene’.
• FECHA_PAGO: DATE.
• CONCEPTO_PAGO: VARCHAR(10) WITH DEFAULT ‘Credito’.
• NRO_TARJETA_PAGO: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• MONEDA_PAGO: VARCHAR(50) WITH DEFAULT ‘Pesos’.
• FECHA_VENC_TARJETA_PAGO: DATE.
• IMPORTE_TOTAL_PAGO: DOUBLE WITH DEFAULT 0.
• IMPORTE_TARJETA_PAGADO: DOUBLE WITH DEFAULT 0.
• SALDO_PAGO: DOUBLE WITH DEFAULT 0.
• RESUMEN_TARJETA_PAGO: VARCHAR(50).
• TIPO_PAGO: VARCHAR(25).
PERSONAL:
• COD_EMP: INTEGER NOT NULL.

• NOMBRE_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• APELLIDO_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• DOMICILIO_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• TELEFONO_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• FECHA_NAC_EMP: DATE NOT NULL.
• ESTADO_CIVIL_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.
• FECHA_INGRESO_EMP: DATE NOT NULL.
• CATEGORIA_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘Varios’.
• NRO_LEGAJO_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.
• CUIL_EMP: VARCHAR(15) NOT NULL WITH DEFAULT ‘No tiene’.
• BASICO_EMP: DOUBLE NOT NULL.
• NETO_EMP: DOUBLE NOT NULL.
• EMAIL_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• LOCALIDAD_EMP: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• DNI: INTEGER NOT NULL WITH DEFAULT 0 .
• ANTIGUEDAD_EMP: INTEGER NOT NULL WITH DEFAULT 0.
• EMPRESA_EMP: VARCHAR(50).
• EDAD_EMP: INTEGER.
• CELULAR_EMP: VARCHAR(30).
• PROVINCIA_EMP: VARCHAR(40).
PESAJE:
• COD_PESAJE: INTEGER NOT NULL.

• FECHA_PESAJE: DATE.
• RAZA_PESAJE: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• RODEO_PESAJE: VARCHAR(50).
• EMPRESA_PESAJE: VARCHAR(50).
• CANT_HEMBRAS_PESAJE: INTEGER WITH DEFAULT 0.
• CANT_MACHOS_PESAJE: INTEGER WITH DEFAULT 0.
• CANT_TOTAL_PESAJE: INTEGER WITH DEFAULT 0.
• PESO_TOTAL_PESAJE: DOUBLE WITH DEFAULT 0.
• PESO_PROMEDIO_PESAJE: DOUBLE WITH DEFAULT 0.
• OBSERVACION: VARCHAR(30).
PRENIEZ:
• COD_PRENIEZ: INTEGER NOT NULL.

• FECHA_PRENIEZ: DATE.
• CATEGORIA_PRENIEZ: VARCHAR(20).
• EMPRESA_PRENIEZ: VARCHAR(20).
• OBSERVACION_PRENIEZ: VARCHAR(50).
• NRO_CARAVANA_PRENIEZ: BIGINT.
• EDAD_PRENIEZ: INTEGER.
• MES_PRENIEZ: INTEGER.
PROVEEDOR:
• COD_PROV: INTEGER NOT NULL.

• NOMBRE_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• CUIT_PROV: VARCHAR(20) NOT NULL WITH DEFAULT ‘No tiene’.
• TELEFONO_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• EMAIL_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• DOMICILIO_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• LOCALIDAD_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• NOMBRE_RESP_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No

tiene’.
• APELLIDO_RESP_PROV: VARCHAR(50) NOT NULL WITH DEFAULT
‘No tiene’.
• TELEFONO_RESP_PROV: VARCHAR(50) NOT NULL WITH DEFAULT
‘No tiene’.
• EMAIL_RESP_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.
• RUBRO_PROV: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• DESC_PROV: VARCHAR(500) NOT NULL WITH DEFAULT ‘No tiene’.
• PROVINCIA_PROV: VARCHAR(30).
ROLLO:
• COD_ROLLO: INTEGER NOT NULL.

• FECHA_ROLLO: DATE.
• CAMPO_ROLLO: INTEGER.
• HA_ROLLO: VARCHAR(20) WITH DEFAULT ‘No tiene’.
• CANT_ROLLO: INTEGER WITH DEFAULT 0.
• OPERADOR_MAQ_ROLLO: INTEGER.
• MAQ_ROLLO: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• ESPECIE_ROLLO: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• TIPO_ROLLO: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• CLIENTE_ROLLO: INTEGER WITH DEFAULT 0.
• PRECIO_ROLLO: DOUBLE WITH DEFAULT 0.
• PORCENTAJE_ROLLO: DOUBLE WITH DEFAULT 0.
• EMPRESA_ROLLO: VARCHAR(100) WITH DEFAULT ‘No tiene’.
• LOTE_ROLLO: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• COSTO_HA_ROLLO: DOUBLE WITH DEFAULT 0.0.
• COSTO_OTRO_ROLLO: DOUBLE WITH DEFAULT 0.0.
• COSTO_TOTAL_ROLLO: DOUBLE WITH DEFAULT 0.0.
• IMPORTE_TOTAL: DOUBLE.
• OPERADOR2_MAQ_ROLLO: INTEGER WITH DEFAULT 0.
• LOTE_NOM_ROLLO: VARCHAR(50) WITH DEFAULT ‘’.
SIEMBRA:
• COD_SIEMBRA: INTEGER NOT NULL.

• FECHA_SIEMBRA: DATE.
• EMPRESA_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• CULTIVO_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• MAQUINA_SIEMBRA: INTEGER.
• OPERADOR_MAQ_SIEMBRA: INTEGER.
• CAMPO_SIEMBRA: INTEGER.
• CAMPO_TERC_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• LOTE_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘No tiene’.
• SUPERFICIE_SIEMBRA: DOUBLE WITH DEFAULT 0.
• KG_HA_SIEMBRA: DOUBLE WITH DEFAULT 0.
• SEMILLA_METRO_SIEMBRA: INTEGER WITH DEFAULT 0.
• CANT_HA_SIEMBRA: INTEGER WITH DEFAULT 0.
• COSTO_HA_SIEMBRA: DOUBLE WITH DEFAULT 0.
• COSTO_TOTAL_SIEMBRA: DOUBLE WITH DEFAULT 0 .
• TIPO_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘Propia’.
• PRECIO_HA_SIEMBRA: DOUBLE WITH DEFAULT 0.
• PRECIO_TOTAL_SIEMBRA: DOUBLE WITH DEFAULT 0.
• CLIENTE_SIEMBRA: INTEGER.
• VAR_HIBRIDO_SIEMBRA: VARCHAR(100).
• TIPO_FERTILIZANTE_SIEMBRA: VARCHAR(100).
• FERTILIZANTE_KG_HA_SIEMBRA: DOUBLE.
• OPERADOR2_MAQ_SIEMBRA: INTEGER NOT NULL WITH DEFAULT
0.
• LOTE_NOM_SIEMBRA: VARCHAR(50) WITH DEFAULT ‘’.
STOCK:
• COD_STOCK: INTEGER NOT NULL.

• EMPRESA_STOCK: VARCHAR(50).
• CULTIVO_STOCK: VARCHAR(50).
• FECHA_STOCK: DATE NOT NULL.
• CANT_TN_STOCK: DOUBLE NOT NULL.
TACTO:
• COD_TACTO: INTEGER NOT NULL.

• FECHA_TACTO: DATE.
• CATEGORIA_TACTO: VARCHAR(20).
• EMPRESA_TACTO: VARCHAR(20).
• OBSERVACION_TACTO: VARCHAR(50).
• CANT_PRENIADAS_TACTO: INTEGER.
• CANT_VACIAS_TACTO: INTEGER.
• CANT_TOTAL_TACTO: INTEGER.
• PORC_PRENIEZ_TACTO: DOUBLE.
• COSTO_CABEZA_TACTO: DOUBLE.
• COSTO_TOTAL_TACTO: DOUBLE.
TARJETA:
• COD_TARJETA: INTEGER NOT NULL.

• NRO_TARJETA: VARCHAR(20) NOT NULL WITH DEFAULT ‘0’.
• NOMBRE_TARJETA: VARCHAR(50) NOT NULL WITH DEFAULT ‘No
tiene’.
• BANCO_TARJETA: INTEGER NOT NULL WITH DEFAULT 0.
• TIPO_TARJETA: VARCHAR(50) NOT NULL WITH DEFAULT ‘No tiene’.
• FECHA_VENC_TARJETA: DATE NOT NULL.
• OBSERVACIONES_TARJETA: VARCHAR(500) NOT NULL WITH DEFAULT
‘No tiene’.
• TITULAR_TARJETA: VARCHAR(100) NOT NULL WITH DEFAULT ‘No
tiene’.
TRASLADOS:
• COD_TRASLADO: INTEGER NOT NULL.

• COSECHA_TRASLADO: INTEGER.
• CARTA_TRASLADO: VARCHAR(100) WITH DEFAULT ‘’.
• KG_EQUIPO_TRASLADO: DOUBLE WITH DEFAULT 0.
• PROPIETARIO_EQUIPO_TRASLADO: VARCHAR(100) WITH DEFAULT
‘’.
• PATENTE_EQUIPO_TRASLADO: VARCHAR(50) WITH DEFAULT ‘’.
• DESTINO_TRASLADO: VARCHAR(50) WITH DEFAULT ‘’.
• EMPRESA_TRASLADO: VARCHAR(50).
• FECHA_TRASLADO: DATE.
• OTRO_DESTINO_TRASLADO: VARCHAR(50).
USUARIO:
• NRO_USUARIO: INTEGER NOT NULL.

• NOMBRE_USUARIO: VARCHAR(20) NOT NULL.
• CLAVE: VARCHAR(10) NOT NULL.
• AREA: INTEGER NOT NULL WITH DEFAULT 0.
VACUNA:
• COD_VACUNA: INTEGER NOT NULL.

• FECHA_VACUNA: DATE.
• ENFERMEDAD: VARCHAR(30).
• GASTO_DOSIS: DOUBLE.
• OTRO: DOUBLE.
• GASTO_TOTAL: DOUBLE.
• TERNEROS: INTEGER.
• TERNERAS: INTEGER.
• VAQUILLONAS: INTEGER.
• NOVILLOS: INTEGER.
• TOROS: INTEGER.
• VACAS: INTEGER.
• TOTAL_VACUNA: INTEGER.
VENTA:
• COD_VENTA: INTEGER NOT NULL.

• FECHA_VENTA: DATE.
• EMPRESA_VENTA: VARCHAR(50).
• PRODUCTO_VENTA: VARCHAR(50).
• DESTINATARIO_VENTA: VARCHAR(50).
• CANTIDAD_VENTA: INTEGER.
• PRECIO_VENTA: DOUBLE WITH DEFAULT 0.
• TOTAL_VENTA: DOUBLE WITH DEFAULT 0.
• TNTOTALES: DOUBLE.
• TNVENDIDAS: DOUBLE.
• TNSTOCK: DOUBLE.
• IVA_VENTA: DOUBLE.
• OBSERVACIONES_VENTA: VARCHAR(100).
• FACTURA_VENTA: INTEGER WITH DEFAULT 0.
• CULTIVO_VENTA: VARCHAR(30).
• ESPECIE_VENTA: VARCHAR(30).
• NRO_FACTURA_VENTA: VARCHAR(30).
• TIPO_VENTA: VARCHAR(50).
• OTRO_DESTINO_VENTA: VARCHAR(50).
• MONEDA_VENTA: VARCHAR(25).
La figura 8.26 de la página 158 visualiza la estructura de campos de algunas

de las tablas que componen la base de datos AGRO, utilizada por el sistema
aplicativo SAG.
Figura 8.26: Tablas de la Base de Datos SAG.
8.5. Ejemplos de Código Fuente Utilizados
8.5.1. Servlets y HTML embebido
A continuación se transcribe un ejemplo de Servlet con HTML embebido,

utilizado por la aplicación, el mismo realiza una operación de alta de cosecha
propia (AgregarCosechaPropia.java).
package cosecha;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.NumberFormat;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import utilitarios.SagHTML;
public class AgregarCosechaPropia extends
javax.servlet.http.HttpServlet implements javax.servlet.Servlet {
private static final long serialVersionUID = 1L;
Connection conn;
public void init(ServletConfig cf) throws ServletException {
super.init(cf);
try {
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);
}catch (ClassNotFoundException e) {
System.out.println(”Imposible encontrar el driver:” +
e.getMessage());
try {
conn = DriverManager.getConnection(“jdbc:odbc:agro”);
}catch (SQLException e) {
System.out.println(“Imposible crear conexion:” + e.getMessage());

public void destroy() {
super.destroy();
try {
conn.close();
}catch (SQLException e){
System.out.println(“Imposible cerrar conexion:” + e.getMessage());
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException {
String usuario=request.getParameter(“usuario”);
String fecha=request.getParameter(“fecha”);
String empresa=request.getParameter(“empresa”);
String cultivo=request.getParameter(“cultivo”);
String maquina=request.getParameter(“maquina”);
String operador=request.getParameter(“operador”);
String operador2=request.getParameter(“operador2”);
String campo=request.getParameter(“campo”);
String cantidadha=request.getParameter(“cantidadha”);
//Importes totales
String importeha=request.getParameter(“importeha”);
String importetotal=request.getParameter(“importetotal”);
String lote=request.getParameter(“lotesel”);
String lotenom=request.getParameter(“lotenom”);
String tncosechadas=request.getParameter(“tncosechadas”);
String kgha=request.getParameter(“kgha”);
PrintWriter out= response.getWriter();
NumberFormat NF = NumberFormat.getInstance();
NF.setMaximumFractionDigits(2); //2 decimales
try{
Statement stm = conn.createStatement();
Statement stm1 = conn.createStatement();
stm.executeUpdate(“insert into cosecha(fecha_cosecha,empresa_cosecha,
maquina_cosecha,operador_maq_cosecha,campo_cosecha,lote_campo_cosecha,
kg_ha_cosecha,cant_ha_cosecha,importe_ha_cosecha,importe_total_cosecha,
cultivo_cosecha,tipo_cosecha,tn_cosecha,operador2_maq_cosecha,
lote_nom_cosecha) values(“‘+fecha+“’,“‘+empresa+”’,“+maquina+”,
“+operador+”,“+campo+”,“‘+lote+”’,“+kgha+”, “+cantidadha+”,“+importeha+”,
“+importetotal+”,“‘+cultivo+”’,‘Propia’,“+tncosechadas+”,“+operador2+”,
“‘+lotenom+”’)”);
stm5.executeUpdate(“insert into stock(empresa_stock,cultivo_stock,fecha_stock,
cant_tn_stock) values(“‘+empresa+”’,“‘+cultivo+”’,“‘+fecha+”’,
“+tncosechadas+”)”);
ResultSet rs1 = stm1.executeQuery(“Select * from maquina where cod_maq=
“+maquina+””);
ResultSet rs2 = stm2.executeQuery(“Select * from personal where cod_emp=
“+operador+””);
ResultSet rs3 = stm3.executeQuery(“Select * from campo where cod_camp=
“+campo+”“);
ResultSet rs4 = stm4.executeQuery(“Select * from personal where cod_emp=
“+operador2+””);
SagHTML.cabeceraGeneralHTML(out,“Agricultura“);
SagHTML.barraMenuCabecera(out, “Opciones de”,“Agricultura”, “Cosecha Propia”);
SagHTML.menuIzquierdoAgricultura(out,usuario);
SagHTML.cuadroConsultar(out);
SagHTML.cuadroBuscar(out);
SagHTML.scriptGeneral(out);
out.println(“<td width=18 align=left valign=top> </td>”);
out.println(“<td align=left valign=top><table width=650 border=0 cellspacing=0
cellpadding=0>”);
out.println(“<tr>”);
cellpadding=0>”);
cellpadding=0>”);
cellpadding=0>”);
out.println(“<td class=menu_table style=border-bottom:1px dotted #bdbdbd;
align=left valign=top colspan=2 width=344 >”);
out.println(“<img src=images/home-icon.gif alt= width=11 height=10
class=home-icon /><span class=blue_title>”);
out.println(“<SPAN class=red-titulo>Cosecha Propia</SPAN></span>
<strong style=color:#000000;></strong> </td>”);
out.println(“</TR>”);
out.println(”<td colspan=2 align=left valign=top ><SPAN class=blue_title>
Los datos se han agregado exitosamente.</SPAN><BR>”);
out.println(”</td>”);
out.println(”</tr>”);
out.println(”</TBODY>”);
out.println(“</TABLE>”);
out.println(“</TD>”);
out.println(“</TBODY>”);
out.println(“</TABLE>”);
out.println(“</TD>”);
out.println(“<TR>”);
out.println(“<TD align=center valign=top >”);
out.println(“<TABLE align=center border=0 >”);
out.println(“<TBODY>”);
out.println(“ <TR>”);
out.println(“ <TD align=center colspan=2><a href=Propios?
usuario=“+usuario+” ><IMG border=0 src=images/botones/propios.gif>
</a>  <a href=Terceros?usuario=“+usuario+” >
<IMG border=0 src=images/botones/terceros.gif”);
out.println(“ ></a>  <a href=AgregarTraslados?
usuario=“+usuario+” ><IMG border=0 src=images/botones/traslados.gif>
</a></TD>”);
out.println(“ </TR>”);
out.println(“<TD align=center colspan=2>”);
out.println(“<TABLE border=0>”);
out.println(“<TBODY>”);
out.println(“ <TD colspan=5><FIELDSET><LEGEND align=center>
<a href=Propios?usuario=“+usuario+” target=_self ><IMG border=0
src=images/botones/agregar.gif></a>
<a href=ModificarCosechaPropia target=_self ><IMG border=0
src=images/botones/modificar.gif></a>
<a href=EliminarCosechaPropia target=_self ><IMG border=0
src=images/botones/eliminar.gif></a></LEGEND>”);
out.println(“ <TABLE border=0 align=center>”);
out.println(“ <TBODY>”);
out.println(“ <TD>”);
out.println(“ <TABLE border=0>”);
out.println(“ <TBODY><FORM name=formcosecha
ACTION= METHOD=POST>”);
out.println(“ <TD align=left class=blue_title>Fecha:</TD>”);
out.println(“ <TD align=left class=red-titulo>“+fecha+”</TD>”);
out.println(“ <TD align=left rowspan=5 valign=top>”);
out.println(“ <FIELDSET><LEGEND class=red-titulo></LEGEND>”);
out.println(“ <TD align=left class=blue_title>Tipo de Cultivo:</TD>”);
out.println(“ <TD align=left class=red-titulo>“+cultivo+”</TD>”);
out.println(“ <TD align=left class=blue_title>Cantidad de Hectáreas:</TD>”);
out.println(“ <TD align=left>“+cantidadha+” ha.</TD>”);
out.println(“ <TD align=left class=blue_title>Toneladas Cosechadas:</TD>”);
out.println(“ <TD align=left>“+tncosechadas+” Tn.</TD>”);
out.println(“ <TD align=left class=blue_title>Rinde:</TD>”);
out.println(“ <TD align=left>“+kgha+” kg.</TD>”);
out.println(“ </TBODY>”);
out.println(“ </TABLE></FIELDSET>”);
out.println(“ <TD align=left class=blue_title>Empresa:</TD>”);
out.println(“<TD align=left>“+empresa+”</TD>”);
out.println(“ <TD align=left class=blue_title>Nombre del Campo:</TD>”);
while(rs3.next()){
out.println(“ <TD align=left>“+rs3.getString(“nombre_camp”)+”</TD>”);
out.println(“ <TD align=left class=blue_title>Nro. de Lote:</TD>”);
out.println(“ <TD align=left>“+lotenom+”</TD>”);

out.println(“ <TD colspan=2><HR></TD>”);
out.println(“<TD align=left class=blue_title>Máquina (Modelo - Año):</TD>”);
out.println(“<TD align=left>”);
String numero=“”;
while(rs1.next()){
numero = rs1.getString(“cod_maq”);
out.println(“ “+rs1.getString(“modelo_maq”)+”, “+rs1.getString(“anio_maq”)+””);
rs1.close();
out.println(“ </TD>”);
out.println(“ <TD align=left rowspan=3 valign=top>”);
out.println(“ <FIELDSET><LEGEND class=red-titulo></LEGEND>”);
out.println(“ <TD align=left class=blue_title>Importe por Hectárea:</TD>”);
out.println(“ <TD align=left>      &nbsp
; $   “+importeha+”</TD>”);
out.println(“ <TD colspan=2><HR></TD>”);
out.println(“ <TD align=left class=red-titulo>Importe Total:</TD>”);
out.println(“ <TD align=left class=red-titulo>     &nbsp
; $  “+importetotal+”</TD>”);
out.println(“ </TABLE></FIELDSET>”);
out.println(“ <TD align=left class=blue_title>Operador 1:</TD>”);
out.println(“ <TD align=left>”);
while(rs2.next()){
out.println(“ “+rs2.getString(“apellido_emp”)+”, “+rs2.getString(“nombre_emp”)+””);
out.println(“ <TD align=left class=blue_title>Operador 2:</TD>”);
out.println(“ <TD align=left>”);
if(operador2.equals(0)){
out.println(“ ‘No Tiene”’);
}else{
while(rs4.next()){
out.println(“ “+rs4.getString(“apellido_emp”)+”, “+rs4.getString(“nombre_emp”)+””);
out.println(“ </TABLE>”);
out.println(“<TABLE class=ingresar-bg width=252 height=64>”);
out.println(”<TBODY>”);
out.println(“</table></td>”);
out.println(“</tr>”);
out.println(“ <TD colspan=2 align=right>”);
out.println(“ <IMG border=0 src=images/atras.gif onClick=history.back()></TD>”);
out.println(“</table></td>”);
out.println(“</tr>”);
SagHTML.cuerpoPrincipalFinal(out);
SagHTML.finCuerpoPrincipal(out);
SagHTML.finHTML(out);
}catch(Exception e){
e.printStackTrace();
}
}
Capítulo 9
Conclusiones
9.1. Conclusiones Acerca de las Tecnologías y Soft-

ware Utilizados
Se ha podido comprobar las grandes ventajas de la utilización de tec-

nologías y software, tanto de base de datos como de desarrollo de aplicaciones,
que soportan sistemas distribuidos multiplataforma.
Esto ha resultado de gran utilidad al momento de desarrollar una aplicación
con Eclipse y DB2 Express-C 9, bajo Windows XP service pack 3, utilizando
Java 1.5, para implementarla en un entorno Windows, ha resultado sumamente
sencilla, rápida y eficiente.
El uso de Java se destaca en la Web y también sirve para crear todo tipo
de aplicaciones distribuidas en la Red (locales, Intranet o Internet).
En cuanto a las facilidades en el desarrollo de aplicaciones Java para en-
tornos multiplataforma, se pudo apreciar que Eclipse puede ser usado desde
la Intranet de una organización y/o desde la Internet, con lo cual el sistema
resulta más eficiente, más flexible y adaptable al cambio y, además, con un
soporte menos complejo.
Con respecto al motor de bases de datos DB2 Express-C, se debe destacar
la escalabilidad, integridad y seguridad permitiendo realizar respaldos en línea
con distintos grados de granularidad sin que esto afecte la disponibilidad de
acceso a los datos por parte de los usuarios; interfaces sencillas y entendibles,
171
completas, intuitivas y con diversos asistentes, permitiendo de esa manera una
mejor comprensión en la utilización de la herramienta.
Asimismo se pudo apreciar las facilidades del Scientific WorkPlace para

escribir libros, por la calidad del producto obtenido, la automatización en el
manejo de índices, la gestión dinámica de espacios, listas de figuras, de tablas,
referencias dinámicas a objetos, bibliografia, etc.
Se destaca la gran potencialidad de este conjunto de herramientas para el
desarrollo de aplicaciones de gran porte y alta complejidad, para su acceso
desde las Intranets de las organizaciones o desde la Internet.
Se hace notar además que los usuarios a cargo de la aplicación, han mani-
festado su interés en el producto desarrollado, ya que se encuentra actualmente
en uso por el establecimiento, debido a que pudieron observar las facilidades
y buen desempeño de la aplicación y las sencillas interfaces gráficas; además
de poder ser operado completamente desde la Intranet y/o Internet.
9.2. Líneas Futuras de Acción
Se considera que las principales líneas futuras de acción derivadas del pre-
sente trabajo serían las siguientes:
Desarrollar un esquema de seguridad más elaborado, incorporando crip-

tografía en la gestión de las claves por la utilización de Internet de la
aplicación.
Desarrollar un manejo de activadores desde la base de datos, para au-
tomatizar la obtención de las copias de seguridad, haciendo más eficiente
la aplicación.
Incorporar links específicos a la meteorología, bolsa de cereales y otros
para facilitar a los usuarios la toma de decisiones de las actividades
rurales, como siembra, cosecha, ganadería, etc.
Desarrollar ampliamente los módulos existentes, ya que actualmente solo
se utiliza para la gestión de altas, bajas y modificación de información y
consultas en base a la información ingresada a la aplicación.
Incorporar la posibilidad que la aplicación pueda ser manipulada desde
una Palm por el usuario final.
Bibliografía
[1] K. Rutledge. The Business Case for e-business. IBM Corp., 2000.
[2] P. Gómez C. Solares. E. Castillo, A. Cobo. JAVA - Un Lenguaje de
Programación Multiplataforma para Internet Ű 1/E. IBM Corp.
[3] Daniela Momiroska Paul Read Nicholas Summers Virginia Totanes Calis-
to Zuzarte. Nagraj Alur, Peter Haas. DB2 UDB High Function Business
Intelligence in e-business 1/E. IBM Corp., 2002.
[4] Louisa Ford Paul Jud Kang Yong Ying. Whei-Jen Chen, Rav Ahuja. Up
and Running with DB2 for Linux 1/E. IBM Corp., 2003.
[5] G. Vasudeva G. Galambos. Patterns for e-business. J. Adams, S. Koushik.
A Strategy for Reuse. IBM Corp., 2001.
[6] David Kline Glen Johnson. Whei-Jen Chen, Angus Beaton. DB2 UDB
Evaluation Guide for Linux and Windows 1/E. IBM Corp., 2003.
[7] Alexandre H. Guerra Thomas Mitchell Francis Reddington. Whei-
Jen Chen, Chris Fierros. DB2 UDB Exploitation of the Windows En-
vironment 1/E. IBM Corp., 2003.
[8] International Business Machines Corporation. WebSphere Studio Appli-
cation Developer Version 4 for use with the Windows 2000 and Windows
NT Operating System. IBM Press, 2002.
[9] A. S. Tanenbaum. Sistemas Operativos Distribuidos Ű 1/E. Prentice Hall
Hispanoamericana S.A.
[10] D. L. La Red Martínez. Sistemas Operativos. Moglia SRL.
[11] A. S. Tanenbaum. Sistemas Operativos Distribuidos Ű 1/E. Prentice Hall
Hispanoamericana S.A.
173
Índice alfabético
agricultura browser
modulo de, 121 navegador, 23
agricultura y ganadería bucles, 53
argentina, 1 do while, 55
agro-ganadería for, 54
actualidad, 1 while, 54
API bytecodes
interface de programación de apli- serie de códigos, 16
caciones, 32
API (Application Programming Inter- C++
face), 41 lenguaje de programación
aplicación orientado a objetos, 11
descripción de la, 118 C/C++, 50
aplicación interactiva, 65 código fuente, 158
applet, 15 Clase, 38
programa independiente, 21 clase
seguridad, 24 características, 57
applets, 21 clase en Java, 57
concepto, 23 clase object, 59
appletviewer clases de utilidad, 60
visualizador de applets, 21 clase Arrays, 60
arrays, 60 clases string y StringBuffer, 61
AWT Double, 62
concepto, 63 integer, 63
interface gráfica de usuario, 63 comentarios, 50
conclusiones, 171
bibliotecas Content-Type, 75
de clases, 35
bifurcaciones, 52 DB2
if, 52 Express-C 9, 87
if else, 53 destroy, 78
bloque try, catch, finally, 56 doGet, 75
174
ÍNDICE ALFABÉTICO 175
doGet (), 78 uso de directorios definidos, 68

doPost (), 78 estructuras de datos, 142
Double, 62 estructuras de programación, 50
métodos de la clase, 62 evento, 64
sources, 64
Eclipse eventos
entorno de desarrollo, 109 listeners, 64
ejemplo de expresión, 50
arrays, 61
bifurcación if, 52 garbage collection
bifurcación if else, 53 manejo automático de memoria,
bucle for, 54 17
bucle while, 54
clase, 38 herencia, 38, 41, 57
comentario, 51 herencia múltiple, 39
construcción de nombres de archivosHotJava, 28, 29
en Java, 69 HTML, 20, 23
do while, 55 lenguaje de marcación de hiper-
interface, 39 texto, 23
línea compuesta por tres senten- HttpServletRequest, 75
cias, 50 HttpServletResponse, 75
método, 58
import, 52
matriz, 61
inialización de arrays, 60
operadores incrementales y rela-
INIT, 76
cionales, 48
instanciación e inicialización, 76
programa no portable, 66
integer, 63
sentencia return, 55
métodos de la clase, 63
encapsulación, 57
interface, 39
errores
Internet Explorer, 27
gestión de, 56
Java, 19 Java, 36
errores de programación aplicaciones corporativas, 31
carga de drivers JDBC, 71 características, 12
entrada/salida por archivo, 73 conceptos básicos, 38
fuentes de caracteres, 73 Conceptos básicos de, 11
scheduling de los hilos de ejecu- errores de programación, 65
ción, 66 estructura general de un progra-
terminación de líneas, 72 ma, 36
uso de características de portabil- introducción a, 34
idad, 67 Jerarquía de clases en, 41
lenguaje y código en, 34 multithreading

limitaciones, 19 múltiples hilos de ejecución, 27
memoria, 17
orientado a objetos, 13 Nestcape Navigator, 26
restricción de seguridad, 25 Netscape, 11, 27
robustez de, 14
OO
seguridad, 15
programación orientada a objetos,
ventajas, 18
35
Java en browsers
OOP, 57
definición, 23
operadores, 45
Java Standalone, 21
aritméticos, 45
Java VM
de asignación, 46
máquina virtual Java, 16
de concatenación de cadenas de
JavaSript, 20
caracteres, 48
javax.servlet.HttpServlet, 75
incrementales, 46
JDK, 51, 72
precedencia de, 49
Java Development Kit, 15
racionales, 47
JIT
unarios, 46
just in time compiler, 28
JSP package, 40, 41
compilación batch de, 81 packages, 37
modelos de, 78 plugins, 19
procesadores, 79 polimorfismo, 57
JVM, 21 POO
programación orientada a objetos,
líneas
36
longitud, 52
portabilidad, 16
listener, 64
return
máquinas virtuales
do while, 55
concepto, 26
RTTI
métodos, 58
runtime type identification, 13
de la clase object, 59
de objeto, 58 sentencia, 50
módulos, 120 server-side, 76
malloc/free servicio
soporte de memoria dinámica, 20 de demanda, 78
Microsoft, 27 servlet, 74
Microsoft Explorer, 26 ciclo de vida del, 76
multiplataforma, 16, 18 codificación de, 75
desarrollo, 74
motor del, 76
servlets
código fuente de, 158
Set-Cookie, 75
software, 40
String, 61
métodos de la clase, 62
string, 42
StringBuffer, 61
Sun, 11, 24
thread, 17
Tomcat
Tomcat 5.0, 114
variable
clasificación, 42
local, 43
miembro de una clase, 43
referencia, 42
variables
miembro, 44
tipo primitivo, 42
visibilidad y vida de las, 44
Web
aplicaciones, 81
WWW, 22

Agricultura Precision Soft de Gestion Agroganadera

Cargado por

Copyright:

Formatos disponibles

Agricultura Precision Soft de Gestion Agroganadera

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Agricultura Precision Soft de Gestion Agroganadera

Cargado por

Copyright:

Formatos disponibles

Universidad Nacional del Nordeste

Facultad de Ciencias Exactas y Naturales y de Agrimensura

Licenciatura en Sistemas de Información

Aplicación Web para la Gestión Agro-Ganadera

Alumno: Lisandro Dardo Yaccuzzi - LU:32774

Los diversos avances tecnológicos derivados del conocimiento y la ciencia

Los objetivos planteados al inicio del trabajo, fueron totalmente cumplidos.

Se ha efectuado una amplia recopilación bibliográfica específica de los

Organización del Informe Final

Capitulo 1 - La Agro-Ganadería en la Actualidad: Se presenta una

Capitulo 2 - Conceptos básicos sobre Java: Se señalan los principales

Capitulo 3 - El lenguaje Java: Se indican los principales aspectos y

Capitulo 4 - Los Servlets: Se resumen los aspectos y características

Capitulo 5 - Introducción a DB2 Express-C 9: Se detallan las más

Capitulo 6 - Eclipse: Se presentan los principales aspectos de este en-

Capitulo 7 - Introducción al Servidor Tomcat: Se señalan los aspec-

Capitulo 8 - Aplicación: Se detallan los aspectos más significativos de

Capitulo 9 - Conclusiones: Se presentan las conclusiones a las que se

El DVD, adjunto al libro impreso, contiene lo siguiente:

Instaladores del software utilizado.

Resúmenes del trabajo realizado.

Libro del informe final.

Presentación para la defensa final.

Copia de seguridad de la base de datos de la aplicación.

Lisandro Dardo Yaccuzzi

2. Conceptos Básicos de Java 11

3.1.1. Bibliotecas de Clases Estándares de Java . . . . . . . . 36

3.8.4. Proceso a Seguir Para Crear Una Aplicación Interactiva

5. Introducción al DB2 Express-C 9 87

6.1. ¿Que es Eclipse? . . . . . . . . . . . . . . . . . . . . . . . . . . 109

8. Descripción de la Aplicación 118

Índice alfabético 174

1.1. La Agricultura Ayer y Hoy. . . . . . . . . . . . . . . . . . . . . 3

2.1. Logo de Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.1. Herencia en Java. . . . . . . . . . . . . . . . . . . . . . . . . . . 39

4.1. Ciclo de Vida de un Servlet. . . . . . . . . . . . . . . . . . . . . 77

5.1. Servidores DB2. . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

5.8. Centro de Control de DB2. . . . . . . . . . . . . . . . . . . . . 104

8.1. Diagrama de Contexto . . . . . . . . . . . . . . . . . . . . . . . 119

3.1. Tipos de Variables. . . . . . . . . . . . . . . . . . . . . . . . . . 43

5.1. Comandos Para Iniciar Algunas Herramientas DB2. . . . . . . 103

1.1. La Agricultura y la Ganadería en el Mundo y

Los diversos avances tecnológicos derivados del conocimiento y la ciencia

En la actualidad Argentina está obteniendo importantes logros en los sec-

1.2. La Agricultura, la Máquina Reemplaza al Mús-

Anteriormente la actividad agrícola se realizaba con la indispensable ayuda

Figura 1.1: La Agricultura Ayer y Hoy.

Las maquinarias que actualmente se utilizan ya traen incoporados dispo-

GPS (Global Positioning System).

Higrómetros (miden el grado de humedad).

Humedímetros y cuenta hectáreas.

Sistemas de gestión para el agro.

Figura 1.2: Distintos Dispositivos Tecnológicos Utilizados en la Agricultura.

1.2.1. Agricultura de Precisión

Consiste en determinar qué requerimientos tienen los suelos, y en qué sitios,

Figura 1.3: La Agricultura de Precisión.

La Agricultura de Precisión utiliza la tecnología con un objetivo claro

1.3. La Evolución de la Ganadería

La Ganadería es una actividad económica de origen muy antiguo que con-