Ing. Jorge L. Sandoval Rivera. Ing. Pedro Criollo Gonzáles

Facultad de Ingeniería
Industrial
Departamento de
Ingeniería Informática
RESPONSABLES DEL PROYECTO :
Ing. Jorge L. Sandoval Rivera.
Ing. Pedro Criollo Gonzáles
Índice
Página
Resumen
Introducción
Materiales y métodos
Resultados y discusión
Conclusiones y recomendaciones
Esquema del contenido
Capitulo I: Terminología y Entornos de Desarrollo Integrado
10
1.- Terminología
1.1. JRE ("Java Runtime Environment")
1.2. JDK,SDK,J2SE
1.3. J2EE (Java 2 Enterprise Edition)
1.4. Otros detalles de Importancia al trabajar con estos ambientes.
1.4.1. CLASSPATH
1.4.2. JARS
1.4.3. Recomendación para JARS y CLASSPATH
2.
Entornos de Desarrollo Integrado
2.1. IDE's del Lenguaje de Programación Java
2.1.1. JCreator
2.1.2. Eclipse
2.1.3. NetBeans
2.1.4. JDeveloper
Capitulo II: IDE ORACLE JDEVELOPER
2.1. Historia
2.2 Características
2.3. Ventajas
2.4. Interfaz principal
19
Capitulo III:
Conociendo el Entorno de JDeveloper
24
3.1. Introducción al editor gráfico
3.2. Creando una primera aplicación
3.2.1. Iniciar Jdeveloper
3.2.2. Crear la aplicación
3.2.3. Crear una clase
3.3. Explorando el editor de código
3.3.1. Plantillas de código
3.4. Compilar y ejecutar una clase
3.5. Trabajando con el asistente de código (code assist)
3.6. Refactoring code
3.7. Ver Historial de Modificación de código
3.8. Navegando a través del código
3.9. Depuración de programas
Capitulo IV: Desarrollo de Aplicaciones
4.1. Desarrollo de una aplicación de escritorio
4.2. Aplicación Conversión de temperaturas
4.3. Creando Tablas
4.4. Base de Datos
4.4.1. Conexión a la base de datos
4.4.2. Creando interfaz de acceso a la base de datos
BIBLIOGRAFIA
ANEXOS
62
Resumen
El presente manual contiene información sobre el manejo del entorno de desarrollo
integrado Oracle JDeveloper con el lenguaje de programación orientado a objetos java.
Aquí podemos encontrar la descripción de cómo trabajar en este IDE, así como una
descripción del contexto de este entorno.
Para poder utilizar este entorno de desarrollo se debe tener conocimientos del lenguaje
de programación java tanto a nivel de consola como en entorno gráfico y así poder
desarrollar aplicaciones de propósito general con java y applets.
Se ha dado un enfoque principalmente al uso del IDE Oracle JDeveloper, a pesar que se
utiliza con el lenguaje de programación java, el trabajo esta orientado básicamente a
utilizar java dentro de este entorno de desarrollo, explotar las ventajas del editor de
texto, los navegadores tanto de aplicaciones como de base de datos, la paleta de
componentes, su herramienta de dibujo que traduce los objetos en código de java,
El manual esta diseñado de tal manera que el aprendizaje del lenguaje de programación
java con este entorno de desarrollado integrado sea sencilla y esta estructurado de la
siguiente manera:
El primer capitulo, presenta los aspectos básicos y necesarios que permitan al alumno
entender el siguiente capitulo. Aspectos como
la terminología que diferencian los
diferentes programas o software como JRE, JDK, J2SE, SDK, JDEE, JARS, etc.
También la definición de un IDE, los diferentes IDEs que existen para diferentes
lenguajes de programación incluido java.
El segundo capitulo esta enfocado básicamente a describir el software JDeveloper, la
historia, características, ventajas y la interfaz principal de este programa.
El tercer capitulo esta diseñado para explorar las ventajas de este IDE, se presentan
ejemplos de aplicaciones sobre las diversas herramientas como el editor de código,
plantillas de código, renombrar elementos de los programas, navegar por el código, etc.
El cuarto capitulo incluye el desarrollo de aplicaciones desde una aplicación básica
hasta aplicaciones con base de datos, tratando de mostrar todas las bondades del
entorno de desarrollado integrado Oracle Jdeveloper.
INTRODUCCIÓN
El presente trabajo de investigación enfoca el desarrollo de aplicaciones de escritorio en
el lenguaje de programación java, utilizando el IDE Oracle JDeveloper 10.1.3.5.
Todo usuario desarrollador de aplicaciones de escritorio en el lenguaje de programación
orientado a objetos java, conoce que el lenguaje de programación java no cuenta con un
editor de texto para poder escribir los programas fuentes, en todo caso tendría que usar
programas accesorios del sistema operativo que utilice, para el caso nuestro es block de
notas en la plataforma Windows XP.
Es ésta una de las tantas razones por la cual los usuarios desarrolladores optan por
elegir un Entorno de Desarrollado Integrado (IDE) de los muchos que existen en el
mercado informático. Existen IDEs para los diferentes usuarios que pueden realizar
aplicaciones caseras, empresariales, profesionales, etc.
Para nuestro caso el IDE elegido es Oracle JDeveloper 10.1.3.5. , que es un software
libre y cuenta con un entorno de trabajo multidisciplinario, esto es desarrollar
aplicaciones: de escritorio, para servidor, para móviles, para clientes de una red, enlaces
con base de datos, etc.
Esto lo hace un IDE competente, razón por la cual se eligió para aplicarlo en la parte
práctica de los cursos de programación de computadoras, especialmente en el curso de
Programación II del plan de estudios de la Escuela de Ingeniería Informática de la
Facultad de Ingeniería Industrial de la Universidad Nacional de Piura.
En el curso de Programación II, se imparten conocimientos para desarrollar aplicaciones
con Interfaz Grafica de Usuario (GUI) con el lenguaje de programación orientado a
objetos java y aquí el IDE Oracle JDeveloper proporciona una herramienta gráfica para
poder dibujar la Interfaz Grafica de Usuario de una aplicación de escritorio así como
todos los componentes necesarios, La ventaja esta en el hecho que al dibujar los
diferentes objetos el IDE genera automáticamente la estructura del programa así como
las instrucciones (código) que son resultado de los objetos incluidos en la interfaz
principal.
Materiales y Métodos
Materiales
Los materiales que se han empleado los podemos dividir en dos grupos:
Hardware y Software
Hardware:
·
Una computadora para la instalación del programa JDeveloper, el desarrollo y
prueba
de
las
clases
que
conforman
las
diferentes
aplicaciones
proporcionadas como ejemplos.
·
Impresora
Software:
·
Sistema operativo Windows XP
·
Lenguaje de Programación Java
o Kit de herramientas: J2DK1.5.0_08, JRE1.5.0_08
o Entorno de Desarrollo de aplicaciones (IDE) Oracle JDeveloper
·
Office 2007
·
Navegador Internet Explorer 7.0
·
Navegador FireFox
Métodos
Se ha empleado el método de investigación analítico – deductivo.
Primero se realizó una recopilación de información para conocer todas las
clases que conforman el paquete gráfico de java, determinar la jerarquía de
las clases basadas en componentes y contenedores, el soporte teórico que va
a permitir realizar aplicaciones robustas y seguras.
A continuación se enfocó y analizó el problema desde el punto de vista de la
facilidad que debe tener el alumno en la secuencia de aprendizaje del lenguaje
de programación java con la herramienta integrada de desarrollo Oracle
JDeveloper.
Resultados y Discusión
Considerando los resultados de las pruebas realizadas al utilizar el IDE JDeveloper a
alumnos que anteriormente habían utilizado el IDE JCreator, se concluye que este
software proporciona al alumno ahorro de tiempo, al escribir considerablemente menor
líneas de código ya que el software tiene herramientas como plantillas de código que
permiten insertar código predefinido en el programa a desarrollar así como documentar
el programa a través de javadoc, modificar código a través de refactoring code, llevar un
historial de las acciones realizadas y principalmente su herramienta de dibujo de objetos
que permiten automatizar la generación de código en el programa.
Las pruebas realizadas consisten en solicitarles a través del profesor la creación de
programas en el lenguaje de programación java utilizando diferentes entornos
integrados de desarrollo como JCreator, JDeveloper, NetBeans. Entonces los alumnos
podrán apreciar las ventajas de cada entorno de desarrollo y de acuerdo a las pruebas
JDeveloper esta entre los IDES preferidos.
También se ha podido demostrar la facilidad con que se puede generar código a partir
de los modelos o diagramas de clases que permite el IDE diseñar. También la facilidad
para la generación de una interfaz grafica a partir de los campos de una tabla de una
base de datos para interactuar la aplicación con el usuario.
Asimismo se puede comprobar la facilidad de crear programas que se ejecuten en un
navegador del lado del cliente como son los applets, así como la generación de JARS,
que permiten empaquetar un grupo de clases.
Igualmente se puede comprobar la facilidad de ubicar los archivos que componen el
proyecto de una aplicación, al crear el IDE un grupo de carpetas donde se almacenan los
diferentes recursos entre ellas tenemos: src (source) para agrupar las clases del
programa fuente y classes para agrupar las clases compiladas y que se interpretaran al
momento de la ejecución del programa.
Conclusiones y Recomendaciones
Conclusiones:
·
Es factible demostrar como se reduce la complejidad de la programación gráfica
en java teniendo disponible un entorno de desarrollado integrado como
JDeveloper que proporciona las facilidades para escribir los programas
respectivos.
·
El entorno de desarrollado integrado es un software libre y que nos proporciona
todas
las
herramientas
complementarias
para
desarrollar
aplicaciones
empresariales tanto para escritorio como para un entorno de red.
·
Cualquier usuario con una computadora con los recursos básicos en procesador,
memoria RAM y disco duro entre los principales recursos, puede copiar y
descomprimir este software que se encuentra en forma gratuita en la red Internet,
esto significa que demanda de grandes recursos de hardware tal como lo hacen
otros entornos de desarrollo y esto va a perjudicar el rendimiento del equipo.
·
Este IDE, permite diseñar aplicaciones con el patrón Modelo-Vista-Controlador,
creando la estructura necesaria para albergar cada elemento del patrón en forma
ordenada.
·
Este IDE también nos da la facilidad de agregar librerías de java, que no estén
incluidas como parte de su API y que lo requieran algunas aplicaciones como
por ejemplo al interactuar con una base de datos se necesita agregar el driver o
controlador del gestor de base de datos con el que se va a interactuar, al entorno
de desarrollo para tener completos los elementos que necesita la aplicación.
Recomendaciones:
·
Se puede seguir apoyando el aprendizaje de los alumnos del curso de
programación con java de la institución anteriormente mencionada, si se
proporciona información agrupada en un manual de otros temas que este IDE
como es el JDeveloper puede facilitar como es la creación de Servlets, JSP,
Métodos Remotos, que este trabajo no incluye en sus objetivos.
·
Inculcar en los usuarios de este lenguaje como son los alumnos de la Escuela de
Ingeniería Informática de la Facultad de Ingeniería Industrial de la Universidad
Nacional de Piura que al iniciar el aprendizaje del diseño de programas con java
es necesario utilizar inicialmente las herramientas donde el alumno debe
aprender a crear la estructura del programa de tal manera que al utilizar el IDE
debe comprender la estructura para que a partir de ahí realizar las
modificaciones al programa para adaptarlo a sus necesidades
·
Reproducir este manual para que de alguna manera ponerlo a disposición de los
alumnos de programación gráfica con java y así facilitar el aprendizaje del
mismo.
10
CAPITULO I: TERMINOLOGIA Y ENTORNOS DE
DESARROLLO INTEGRADO (IDE)
1.- Terminología
Además de la amplia terminología individual que existe en Java, existen diversos
componentes ("KITS") que agrupan estas funcionalidades, y son estos
componentes con los que se trabaja "día a día" en proyectos Java.
1.1. JRE ("Java Runtime Environment")
Como su nombre lo indica este ambiente ("KIT") es utilizado solo para ejecutar
("Runtime") programas en Java. Esta situación se da cuando empresas de
Software diseñan alguna interfase gráfica o aplicación en Java para su
producto. Cabe mencionar que muchos productos que utilizan Java para su
interfase gráfica o instalación ya incluyen un JRE para evitarle la molestia de
instalarlo, uno de estos es Oracle ; sin embargo, muchos productos requieren
que usted posea este ambiente, si se pregunta: Porque me hacen que obtenga
forzosamente este JRE ? Una de las principales razones es costo ya que las
empresas deben pagar a Sun por distribuir este ambiente en su producto.
1.2. JDK,SDK,J2SE
"Java Development Kit"(JDK),"Standard Development Kit" (SDK) y "Java 2
Standard Edition" (J2SE) son nombres para el mismo componente e incluyen:
El API de Java, el JRE ( JVM ), compilador de Java y otras funcionalidades
definidas por Sun. Si no esta familiarizado programando en Java, el API de
Java es un conjunto de clases que es utilizado para generar programas básicos
en el lenguaje; utilizando una analogía, estas clases tienen la misma
funcionalidad que las funciones|clases estándar utilizadas en otros lenguajes
C,C++, Perl (Esto es precisamente la definición de API ("Application
Programming Interface")).
Partiendo de estas clases (API de Java) se generan TODOS los programas,
interfaces y elementos programados en Java, inclusive a partir de estas clases
usted puede definir otras clases especificas que serán utilizadas por su
programa o producto. Una vez que defina sus programas|clases en Java aún es
11
necesario compilarlas para producir lo que es denominado byte-code o class
files (este byte-code puede ser comparado con un binario) , y es este byte-code
el que interpreta el JRE("Java Runtime Environment").Este byte-code es el que
directamente ofrece la interoperabilidad de Java o el afamado "Write once run
everywhere"="Escríbalo una vez ejecútelo en todos lados".
Es una cantidad razonable de trabajo la que realiza el JDK|SDK, y por el hecho
de incluir tanto el compilador,API Java y el JRE existen diversas
implementaciones de JDK: JDK's de Sun (o J2SE) y JDK's de IBM.
1.3. J2EE (Java 2 Enterprise Edition)
J2EE es un grupo de especificaciones diseñadas por Sun que permiten la
creación de aplicaciones empresariales, esto sería: acceso a base de datos
(JDBC), utilización de directorios distribuidos (JNDI), acceso a métodos
remotos (RMI/CORBA),
funciones de correo electrónico (JavaMail),
aplicaciones Web(JSP y Servlets)...etc. Aquí es importante notar que J2EE es
solo una especificación, esto permite que diversos productos sean diseñados
alrededor de estas especificaciones algunos son Tomcat y Weblogic ; la
especificación más reciente de Sun es J2EE 1.4 , la cual esta conformada por:
JSP 2.0 ,Servlet 2.4, EJB 2.1 y Connector 1.5 entre otros API's.
Aunque
varios productos Java están diseñados alrededor
de estas
especificaciones, no todos cumplen con el estándar completo, esto es, Tomcat
solo emplea|cumple las especificaciones de JSP y Servlets, sin embargo,
existen productos como Websphere y algunos otros "Java Application Servers"
que son considerados "Fully J2EE Compliant" , en otras palabras, cumplen con
todas las especificaciones definidas por Sun.
Sun ofrece una implementación de TODAS estas especificaciones llamada
J2EE SDK , a pesar que el J2EE SDK es una implementación, esta es solo una
muestra ofrecida por Sun para utilizar las funcionalidades de las
especificaciones J2EE, aunque funcionaría en un Sistema de Producción su
diseño es poco escalable.
1.4.
Otros detalles de Importancia al trabajar con estos ambientes.
1.4.1. CLASSPATH
Es una variable de ambiente en su sistema extremadamente importante ya
12
que le indica al JDK donde se encuentran las clases que serán utilizadas al
compilar un programa, el CLASSPATH puede estar compuesto por
diversos directorios o JARS, como se muestra a continuación:
CLASSPATH=/usr/local/tomcat/lib/servlet.jar:/usr/local/enhydra/lib/enhydra.jar:
/home/JavaPrograms3:/usr/local/xml:/usr/local/xml/xp.jar:/usr/local/java_lib:
/usr/local/jsdkee/lib/j2ee.jar:/usr/local/jdk/jre/lib/ext/jndi.jar:
/usr/local/java_lib/postgresql.jar
Cuando se utiliza un directorio, el JDK buscará dentro de éste las clases
correspondientes, nótese que cuando se emplea un JAR debe especificarse
el archivo completo , si el JAR se encuentra dentro de un directorio no
será encontrado al menos que se indique el archivo JAR específicamente.
Por lo general debe agregar este CLASSPATH al archivo /etc/bashrc para
que sea definido para todo usuario del sistema.
1.4.2. JARS:
Es un grupo de clases comprimidas; una vez que defina 200 o 300 clases
en Java puede agruparlas para formar lo que es denominado "JAR File",
este JAR file puede ser considerado un ZIP o TAR file utilizado en
cualquier sistema de computo, la ventaja de los JAR files es su
compresión y la reducción de carga administrativa al movilizar clases .
1.4.3. Recomendación para JARs y CLASSPATH
Para evitar las dificultades de actualizar la variable CLASSPATH en cada
ocasión que sea agregada alguna clase:
· CLASES GENERALES: Generar un directorio global java_lib e
incluirlo dentro del CLASSPATH, de esta manera si adquiere clases de
postgres, objectspace o osmosislatina puede incluirlas dentro de este
directorio
y
evita
problemas
de
manutención,
concentrando
efectivamente todas las clases adicionales utilizadas por el JDK en un
solo directorio.
13
· JARS: Los archivos JAR son menos amigables al momento de intentar
concentrarlos en directorios, ya que como se menciono anteriormente es
necesario declararlos directamente en CLASSPATH. Para evitar estas
limitaciones es posible agregar los archivos JAR al directorio
$JAVA_HOME/jre/lib/ext/ donde $JAVA_HOME es el directorio raíz
del JDK , cualquier archivo JAR dentro de este directorio estará
disponible al ambiente Java, como si éste hubiera sido declarado en
CLASSPATH.
2. Entorno de Desarrollo Integrado
Un entorno de desarrollo integrado o IDE1 (acrónimo en inglés de integrated
development environment), es un programa informático compuesto por un conjunto
de herramientas de programación.
Puede dedicarse en exclusiva a un sólo lenguaje de programación o bien, poder
utilizarse para varios.
Dev C++, un IDE para el lenguaje de
programación C++.
WebDevStudio, un IDE en línea para el
lenguaje de programación C/C++.
1
Obtenido de http://es.wikipedia.org/wiki/Entorno_de_desarrollo_integrado
14
Un IDE es un entorno de programación que ha sido empaquetado como un
programa de aplicación, es decir, consiste de:
·
·
·
·
·
Editor de texto ó código
Compilador
Interprete
Depurador
Constructor de interfaz gráfica (GUI).
Los IDEs pueden ser aplicaciones por sí solas o pueden ser parte de aplicaciones
existentes. El lenguaje Visual Basic, por ejemplo, puede ser usado dentro de las
aplicaciones de Microsoft Office, lo que hace posible escribir sentencias Visual
Basic en forma de macros para Microsoft Word.
Los IDEs proveen un marco de trabajo amigable para la mayoría de los lenguajes de
programación tales como C++, Python, Java, C#, Delphi, Visual Basic, etc. En
algunos lenguajes, un IDE puede funcionar como un sistema en tiempo de
ejecución, en donde se permite utilizar el lenguaje de programación en forma
interactiva, sin necesidad de trabajo orientado a archivos de texto, como es el caso
de Smalltalk u Objective-C.
Es posible que un mismo IDE pueda funcionar con varios lenguajes de
programación. Este es el caso de Eclipse, al que mediante plugins se le puede añadir
soporte de lenguajes adicionales..
2.1. IDE's del Lenguaje de Programación Java
Mientras un JDK|SDK ofrece las herramientas para compilar y ejecutar
programas en Java éste no ofrece un ambiente de trabajo para proyectos
complejos, esto es, si usted compila una o dos clases quizás el comando javac
ofrecido en los JDK es suficiente, pero si su proyecto estará compuesto por 100
o 200 clases, javac sería muy deficiente.Los IDE's ("Integrated Development
Environment") ofrecen un ambiente gráfico en los que se tiene acceso a mayor
número de herramientas no ofrecidas en los JDK's: Debuggers más elaborados,
check-points dentro de la compilación,creación de WAR's (Web-Archives),
"Wizards" para acelerar desarrollo, entre otras cosas. Algunos IDE's son:
· NetBeans ( http://www.netbeans.org ) Open-Source
· Eclipse ( http://www.eclipse.org ) Open-Source
· Sun Java Studio ( http://www.sun.com/software/sundev/jde/index.xml ) de
Sun
15
· JBuilder ( http://www.borland.com/jbuilder ) de Borland
· WebSphere Studio ( http://www-
306.ibm.com/software/awdtools/studiositedev/ ) de IBM
· JDeveloper ( http://otn.oracle.com/products/jdev/content.html ) de Oracle
2.1.1 JCreator
JCreator es la herramienta de desarrollo para cada programador que le
gusta hacer lo que mejor sabe hacer: la programación. Es más rápido, más
eficiente y más fiable que la IDE de otros. JCreator ofrece al usuario una
amplia gama de funcionalidades tales como: Gestión de proyectos,
plantillas de proyecto, el código de terminación, interfaz de depuración,
editor con resaltado de sintaxis, magos y una interfaz de usuario totalmente
personalizable
Con JCreator directamente puede compilar o ejecutar el programa Java sin
activar el documento principal en primer lugar.
JCreator encontrará
automáticamente el archivo con el método principal o el archivo HTML
celebración de la applet de Java, a continuación, se iniciará la herramienta
adecuada.
JCreator está escrito enteramente en C + +, lo que hace que sea rápido y
eficaz en comparación con los editores basados en Java / s. IDE '
2.1.2. Eclipse
Es un entorno de desarrollo integrado de código abierto multiplataforma
para desarrollar lo que el proyecto llama "Aplicaciones de Cliente
Enriquecido", opuesto a las aplicaciones "Cliente-liviano" basadas en
navegadores. 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.
Eclipse
es
también
una
comunidad
de
usuarios,
extendiendo
constantemente las áreas de aplicación cubiertas. Un ejemplo es el
16
recientemente creado Eclipse Modeling Project, cubriendo casi todas las
áreas de Model Driven Engineering.
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 complementarios, capacidades y
servicios.
Arquitectura
La base para Eclipse es la Plataforma de cliente enriquecido (del Inglés
Rich Client Platform RCP). Los siguientes componentes constituyen la
plataforma de cliente enriquecido:
·
Plataforma principal - inicio de Eclipse, ejecución de plugins
·
OSGi - una plataforma para bundling estándar.
·
El Standard Widget Toolkit (SWT) - Un widget toolkit portable.
·
JFace - manejo de archivos, manejo de texto, editores de texto
·
El Workbench de Eclipse - vistas, editores, perspectivas, asistentes
Los widgets de Eclipse están implementados por una herramienta de
widget para Java llamada SWT, a diferencia de la mayoría de las
aplicaciones Java, que usan las opciones estándar Abstract Window
Toolkit (AWT) o Swing. La interfaz de usuario de Eclipse también tiene
una capa GUI intermedia llamada JFace, la cual simplifica la construcción
de aplicaciones basada en SWT.
El entorno de desarrollo integrado (IDE) de Eclipse emplea módulos (en
inglé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 funcionalidades están todas incluidas, las necesite el usuario o
no. Este mecanismo de módulos es una plataforma ligera para
componentes de software. Adicionalmente a permitirle a Eclipse
extenderse usando otros lenguajes de programació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 Sistema 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 configuración.
17
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".
El SDK de Eclipse incluye las herramientas de desarrollo de Java,
ofreciendo 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, permitiendo modificaciones externas a los archivos en
tanto se refresque el espacio de trabajo correspondiente.
2.1.3. NetBeans
NetBeans se refiere a una plataforma para el desarrollo de aplicaciones de
escritorio usando Java y un entorno de desarrollo integrado
Esta plataforma permite que las aplicaciones sean desarrolladas a partir de
un conjunto de componentes de software llamados módulos. Un módulo es
un archivo Java que contiene clases de java escritas para interactuar con las
APIs de NetBeans y un archivo especial (manifest file) que lo identifica
como módulo. Las aplicaciones construidas a partir de módulos pueden ser
extendidas agregándole nuevos módulos. Debido a que los módulos
pueden ser desarrollados independientemente, las aplicaciones basadas en
la plataforma NetBeans pueden ser extendidas fácilmente por otros
desarrolladores de software.
NetBeans es un proyecto de código abierto de gran éxito con una gran base
de usuarios, una comunidad en constante crecimiento, y con cerca de 100
socios en todo el mundo. Sun MicroSystems fundó el proyecto de código
abierto NetBeans en junio 2000 y continúa siendo el patrocinador principal
de los proyectos.
La Plataforma NetBeans es una base modular y extensible usada como
una estructura de integración para crear aplicaciones de escritorio grandes.
Empresas independientes asociadas, especializadas en desarrollo de
software, proporcionan extensiones adicionales que se integran fácilmente
en la plataforma y que pueden también utilizarse para desarrollar sus
propias herramientas y soluciones.
18
La plataforma ofrece servicios comunes a las aplicaciones de escritorio,
permitiéndole al desarrollador enfocarse en la lógica específica de su
aplicación.
Entre las características de la plataforma están:
· Administración de las interfaces de usuario (ej. menús y barras de
herramientas)
· Administración de las configuraciones del usuario
· Administración del almacenamiento (guardando y cargando cualquier
tipo de dato)
· Administración de ventanas
· Framework basado en asistentes (diálogos paso a paso)
2.1.4. JDeveloper
JDeveloper es un entorno de desarrollo integrado desarrollado por Oracle
Corporation para los lenguajes Java, HTML, XML, SQL, PL/SQL,
Javascript, PHP, Oracle ADF, UML y otros.
Es un software propietario pero gratuito desde 2005.
Las primeras versiones de 1998 estaban basadas en el entorno JBuilder de
Borland, pero desde la versión 9i de 2001 está basado en Java, no estando
ya relacionado con el código anterior de JBuilder.
Las últimas versiones estables son:
· Para JDK 6: 11.1.1.0.0 (abril de 2009)
· Para JDK 5: 10.1.3.5 (agosto de 2009).
19
CAPITULO II: IDE ORACLE JDEVELOPER
2.1. Historia
La primera versión de JDeveloper (1998) fue basada en la licencia de JBuilder
producto de Borland. JDeveloper pasó con una reescritura completa que se basa en
Java, para sus
versiones 9i (2001). La versión 10g (9.0.5) muestra el primer
lanzamiento mejorado del Oracle En 2006, aún debajo de la etiqueta 10g, y después
de un significativo retraso, Oracle lanza la versión 10.1.3 - el lanzamiento principal
más último. En octubre de 2006 Oracle lanzó la versión 10.1.3.1 que agregó la
ayuda para espec. final EJB3.0 junto con tiempo del diseño de BPEL y de ESB. En
enero de 2007 Oracle lanzó la versión 10.1.3.2 que agrega las capacidades de
WebCenter tales como crear y los portlets que consumen, puente de portlet/JSF, y
control de datos del depósito del contenido. Un lanzamiento de prueba de la versión
11g fue lanzado en mayo de 2007. En julio del año 2008 se lanza la versión
JDeveloper 10g 10.1.3.4, en octubre del mismo año se lanza la versión JDeveloper
11g 11.1.1.0.0, en diciembre del mismo año se lanza la versión JDeveloper 11g
11.1.1.0.1. en agosto del año 2009 se lanza la versión JDeveloper 10g.10.1.3.5.
El IDE ORACLE JDeveloper de este manual lo puede descargar de de la siguiente
dirección
www.oracle.com/technology/software/products/jdev/htdocs/soft10131.html y una
vez descargado, descomprimir el archivo jdevstudio10131.zip
2.2 Características
Es el editor para aplicaciones desarrolladas en Java de Oracle, dentro de sus
principales características cuenta con:
· El soporte de Oracle
· Es gratuito
· Fácil de usar, excelente para desarrolladores no experimentados en Java
· Permite desarrollar aplicaciones tanto para Desktop como para Web
· Excelente integración con Oracle 9i y 10g
· Permite generar diagramas de UML
o
Casos de uso – Especificación de Requerimientos
20
o
Diagramas de Actividad – Definición de procesos
o
Diagramas de Secuencia – Facilitan el modelado de flujos que siguen los
componentes del sistema
o
Diagrama de Clases – Representan la organización y las relaciones de las
clases y componentes del sistema
· Permite generar diagramas de Entidad Relación para Bases de datos
· Permite la integración con servidores de control de versiones.
· Integración con las herramientas de Pruebas de Junit
Otras Caracteristicas de Oracle JDeveloper
JDeveloper viene en tres ediciones; cada uno ofrece más características encima de
las otras, y todos son libres. Una lista de las características incluye:
Edición de Java Standar
· Ayuda del SE 5 de
· Control de la
· El eliminar errores
versión (sin
· El perfilar
· Cifre el redactor
embargo, la
· Ayuda de la
· Cifre la
ramificación no es
Java
hormiga
apoyada por el
· Ayuda de XML
· Refactoring
cliente interno de
· Abra el API y las
· Oscilación
CVS)
navegación
· Prueba de la
unidad
extensiones
· Intervención y
· Ayuda del usuario
métrica
Edición de J2EE
· JSP
· Servicios del Web
· Puntales
· UML
· JSF
· Desarrollo de la base de datos
· EJB
· Despliegue y gerencia
· TopLink
·
Edición del estudio
· Alimentador de originales
Databinding
· Caras del alimentador de
originales
· Móvil del alimentador de
originales
· Componentes del negocio del
alimentador de originales
21
· Oscilación del alimentador de
originales
· Despliegue del alimentador de
originales
· Diseñador de BPEL
· Diseñador de ESB
· Desarrollo de Portlet
· Puente de Portlet/JSF
JDeveloper es libre para el diseño y desarrollo. Oracle tiene una licencia runtime
cuando está desplegado fuera de un servidor del uso de Oracle. Para otros detalles,
vea el revelador de la red de la tecnología de Oracle licenciar los términos para
JDeveloper aquí: http://www.oracle.com/technology/software/popup-license/jdevlicense.html
2.3. Ventajas
En nuestro concepto los IDE son muy parecidos en las funcionalidades básicas para
desarrollo. Sin embargo JDeveloper va más allá de ser un IDE para crear
aplicaciones Java y lo que promueve es el concepto de IDE empresarial.
Una de las características principales de Oracle JDeveloper es que cubre todo el
ciclo de vida de una aplicación y de una manera muy declarativa.
Oracle ha centrado gran parte de su estrategia a nivel de herramientas de desarrollo
entorno a JDeveloper, esto quiere decir que el IDE cuenta con características que
cubren todo el ciclo de vida de una aplicación (análisis basado en UML, desarrollo,
prueba/debug, elementos para auditar), adicionalmente se puede hacer desarrollo
orientado a base de datos (modelamiento), desarrollo para XML, desarrollo para
SOA (BPEL, ESB, Webservices), desarrollo Web (javaScript, HTML, JSF).
Una de las ventajas más grandes es que para el desarrollador el ambiente, los menús,
etc, son los mismos; no se requiere de utilizar otras herramientas, el IDE se ajusta de
acuerdo al tipo de tecnologías que vayas a utilizar.
Adicional a las características que mencionamos, el IDE cuenta con un servidor
JavaEE embebido, el cual viene con la herramienta lo cual facilita toda la parte de
pruebas y despliegues.
La última pieza que diferencia a JDeveloper de los demás es ADF o Application
Development Framework, un framework end-to-end para construir aplicaciones
Java EE. Utilizando este framework en conjunto con JDeveloper se pueden crear
aplicaciones basadas en MVC de manera productiva y basada en los estándares de la
industria tales como EJB3, JPA, JSF.
Respecto a los plugins, los hay por parte de Oracle.
22
Es un IDE que cuenta una buena paleta de componentes y un diseño 100%
declarativo.
2.4. Interfaz Principal
Cuando inicias Oracle JDeveloper por primera vez, verá una pantalla similar a la de
la figura Nº01
Figura Nº 01
La interfaz se divide en varias partes distintas, como se observa. Desde arriba a la
izquierda, abajo a la derecha se ubica, el menú, la barra de herramientas, la barra de
navegación, la vista de árbol de la estructura de los proyectos y la zona de
presentación de los errores de los programas fuentes asimismo la paleta de
componentes así como su ventana de propiedades de acuerdo al componente
elegido.
23
De acuerdo al desarrollo de aplicaciones vamos a ir describiendo las diferentes
opciones con las que cuenta y que se aplican de acuerdo a las necesidades de los
usuarios.
24
CAPITULO III: CONOCIENDO EL ENTORNO DE
JDEVELOPER
3.1. Introducción al Editor Grafico
Las Interfaces graficas en java siempre han sido un poco complejas. El problema
esta cuando tienes que mover un botón y ponerlo mas a la izquierda y cosas por el
estilo y te tienes que lidiar con los Layout´s. En Swing la cosa se complica un
poco más así que creo que es necesario un buen editor grafico para java.
Sobretodo desde el punto de vista de una persona que al fin y al cabo es
programador y no diseñador..
En este punto se tratará de explicar brevemente como conseguir una GUI en java
de manera rápida con el editor grafico que acompaña al IDE Jdeveloper.
1. Crear una nueva área de trabajo, como “No template”, donde se incluirá el
nuevo proyecto. Para ello en Aplications-Navigator click en botón-derecho
“NewApplicaction workspace”, se nos abrirá una ventana como la que se muestra
a continuación en la figura 1.
Lo de no template lo haremos para
que Jdeveloper no nos añada ningún
patrón de diseño ni nada por el estilo.
Nuestro objetivo es crear una clase
java que tenga una serie de
componentes gráficos y métodos
vacíos que gestionen dichos
componentes, que serán
implementados por nosotros.
Destacar que lo que queremos es
crear una interfaz de forma rápida.
Una vez tenemos nuestro área de trabajo con nuestro proyecto .Sobre el proyecto
con el botón-derecho y seleccionamos New-->Client Tier-->Swing/awt-->Frame
Tal como se muestra en la figura 2.
25
Como podemos ver esto ya nos ha creado una clase vacía la cual extiende de
JFrame. También podemos observar que podemos ver la clase como diseño, como
código y como clase.
Nos vamos al tipo de vista diseño y deberíamos ver algo como lo que se muestra
en la figura 3.
Ahora solo se trata de añadir botones y componentes, como queramos nosotros,
mediante el Component palette de Jdeveloper, si no tenemos activo el component
lo activamos mediante View--> component palette.
En el component palette seleccionamos swing y simplemente se trata de
seleccionar lo que queremos y ponerlo en nuestra interfaz.
Para este ejemplo, se ha creado la interfaz que se ve a continuación. Como se
puede ver es un JTextarea, un JTexfield y un JButton.
26
Si nos vamos al tipo vista código de nuestra clase podemos observar el código que
ha generado JDeveloper por nosotros. Hasta el momento esta interfaz no genera
ningún evento y la clase java solo contiene una serie de componentes gráficos. El
código es puro Swing así que no estamos atados a JDeveloper para nada y
podremos usar este código en cualquier otro IDE.
Ahora trataremos de gestionar los eventos que provocara la interacción del usuario
con nuestra GUI. Para ello deberemos tener activado el Property Inspector, sino
es así lo activamos mediante View--> Property Inspector.
Imaginemos que lo que queremos es añadir el método que gestionara los eventos
del botón. Seleccionamos el botón en la vista de diseño de la clase y nos vamos al
Property Inspector.
Podemos observar que se nos abre una lista con las propiedades del componente
tal como se muestra en la figura 5. La primera pestaña se trata de las propiedades y
la segunda de los eventos. En este punto son los eventos lo que nos interesa.
.
27
Seleccionamos eventos y hacemos click en la casilla que aparece en blanco al lado
de Action Performed y se nos abra la siguiente pantalla y aceptamos. Tal como
podemos observar en la figura 6
Esto lo haremos con todos los componentes que queramos controlar, de tal forma
que después de hacerlo en nuestro JTextarea. Podemos observar que simplemente
tenemos una serie de componentes gráficos y dos métodos que están vacíos que se
encargaran de gestionar los eventos. El
código obtenido hasta ahora es el
siguiente:
package mypackage;
import javax.swing.JFrame;
import java.awt.Dimension;
import javax.swing.JButton;
import java.awt.Rectangle;
import javax.swing.JCheckBox;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
public class Frame1 extends JFrame
{ private JButton jButton1 = new JButton();
private JTextArea jTextArea1 = new JTextArea();
private JTextField jTextField1 = new JTextField();
public Frame1()
{
try
{
jbInit();
} catch(Exception e) { e.printStackTrace(); }
28
}
// Método que es invocado desde el constructor de la clase, aquí se desarrolla toda la creación de la
// interfaz.
private void jbInit() throws Exception
{
this.getContentPane().setLayout(null);
this.setSize(new Dimension(400, 300));
JButton1.setText("jButton1");
JButton1.setBounds(new Rectangle(300, 200, 75, 35));
JButton1.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
jButton1_actionPerformed(e);
}
});
jTextArea1.setText("jTextArea1");
jTextArea1.setBounds(new Rectangle(15, 30, 355, 140));
jTextField1.setText("jTextField1");
jTextField1.setBounds(new Rectangle(15, 190, 275, 60));
jTextField1.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent e)
{
jTextField1_actionPerformed(e);
}
});
this.getContentPane().add(jTextField1, null);
this.getContentPane().add(jTextArea1, null);
this.getContentPane().add(jButton1, null);
}
//metodo vacio que control evento de boton
private void jButton1_actionPerformed(ActionEvent e)
{
}
//metodo vacio que controla textfield
private void jTextField1_actionPerformed(ActionEvent e)
{
}
}
3.2. Creando una Primera Aplicación
De acuerdo a la experiencia obtenida a través de los cursos de programación
impartidos a lo largo de nuestro trabajo docente, hemos comprobado que a través de
ejemplos se tiene una llegada más rápida a los alumnos de los cursos de
programación motivo por el cual empezaremos describiendo el IDE creando nuestra
primera aplicación.
3.2.1. Iniciar JDeveloper.
Haga doble clic en el JDeveloper ejecutable (jdeveloper.exe)
encontrados en el escritorio del sistema operativo Windows
O en su defecto buscar el archivo ejecutable jdeveloper.exe en la
carpeta: C:\jdevstudio10134
29
Aparece una ventana de dialogo que indica que proporciona consejos o Tips
sobre el IDE, debemos cerrar dicha ventana.
3.2.2. Crear la aplicación
La aplicación es el más alto nivel en la estructura de control. Es una
visualización de todos los objetos que usted necesita mientras está trabajando.
Una aplicación realiza un seguimiento de sus proyectos, mientras está
desarrollando sus programas de Java.
Las aplicaciones se almacenan en archivos con la extensión .jws. Al abrir
JDeveloper, la última aplicación utilizada se abre por defecto, para que pueda
continuar donde lo dejó.
Al crear una nueva aplicación en JDeveloper, usted tiene la opción de basarlo
en una plantilla. La plantilla de aplicación que usted elija determina la
estructura del proyecto inicial, es decir, las carpetas del proyecto denominado
30
dentro de la aplicación. Puede modificar las plantillas existentes o crear otros
nuevos.
En JDeveloper siempre trabajar con proyectos que figuran que están
contenidos en una aplicación.
Un proyecto JDeveloper es una agrupación lógica de los archivos que están
relacionados. Un proyecto realiza un seguimiento de los archivos de origen,
paquetes, clases, imágenes y otros elementos que su programa puede necesitar.
Usted puede agregar múltiples proyectos a la aplicación para acceder
fácilmente, modificar y reutilizar el código fuente.
Proyectos de gestión de las variables de entorno como la fuente y las rutas de
salida utilizada para compilar y ejecutar sus programas. Los proyectos también
mantienen el compilador, en tiempo de ejecución, y las opciones de
depuración, así que usted puede personalizar el comportamiento de esas
herramientas en un proyecto.
El Navegador de Aplicaciones (Application Navigator) de JDeveloper es la
ventana principal desde la que se tiene acceso a todos los componentes de su
aplicación.
La estructura del Navegador de Aplicaciones es jerárquica y soporta las
aplicaciones, proyectos, imágenes, archivos. Html, y más. De forma
predeterminada, JDeveloper muestra el Navegador de Aplicaciones en el lado
izquierdo de la IDE.
Para crear una aplicación realizar los siguientes pasos:
1.- Haga anticlick en el nodo Aplicaciones en el Navegador de Aplicaciones y
seleccione Nueva Aplicación ... en el menú contextual.
31
2.- En el cuadro de diálogo Crear Aplicaciones (Create Application),
modificar el valor predeterminado Application1 solicitud del nombre de
MyFirstApp.
Tenga en cuenta el nombre de directorio por defecto el cual lo puede
cambiar de acuerdo a sus requerimientos.
3.- Haga click con el puntero del mouse apuntando hacia abajo en el campo de
plantillas de aplicación (Application Template) para invocar la lista
desplegable de plantillas disponibles.
Hacer click en No Template [All Technologies]. Aquí ésta aplicación del
proyecto tiene acceso a todas las tecnologías de JDeveloper.
32
Click OK.
4.- En el cuadro de diálogo Crear proyecto, cambiar el nombre predeterminado
del proyecto Project1 a MyProject y, a continuación, haga clic en Aceptar.
En el Navegador de aplicaciones (Applications Navigator), los proyectos
se muestra como el segundo nivel en la jerarquía en virtud de la aplicación.
Las aplicaciones de navegador debe tener este aspecto:
Hay que tener en cuenta que la carpeta del proyecto (MyProject) es un hijo
de la carpeta de aplicaciones (MyFirstApp).
3.2.3. Crear una clase
Para crear una clase Java, realice los siguientes pasos:
1.-
Haga clic en el nodo MyProject en el Navegador de Aplicaciones y
seleccione nuevo (New) ... opción del menú contextual.
33
2.-
Aparece New Gallery. De forma predeterminada aparece displayada la
primera categoría General que se destaca en la lista Categorías. También
aparecen las otras categorías que le permiten trabajar con diferentes
tecnologías para construir los diferentes niveles de una aplicación.
3.- En el cuadro de diálogo crear la clase de Java, cambiar el nombre
predeterminado de class1 a Dog(perro).
Debido a que no especificó el nombre del paquete al crear la aplicación, el
nombre del paquete por defecto es el nombre del proyecto en minúsculas.
Usted puede cambiar esta situación si se desea.
Acepte los demás valores predefinidos y hacer clic en OK.
34
4.- La nueva clase abre automáticamente el editor del código fuente, donde se
ve la estructura de la clase.
Para agregar un método a la clase. Después del método constructor, pulsar
[Enter] para agregar una línea nueva y escribir el siguiente código:
public String sayHi()
Observe que la línea de código que acaba de insertar tiene una línea roja
ondulada debajo de ella, lo que indica un problema con la sintaxis.
También hay cajas de color rojo en el margen derecho del editor de código
fuente. Si pasa el mouse encima de estas cajas o sobre la línea ondulada de
color rojo nos da una información sobre el error o errores del método.
5.-
Al final de la línea, pulsar [Ctrl] + [Shift] + [Enter]. JDeveloper
proporciona entonces la finalización automática de la estructura del
35
método, y los indicadores de error desaparecerán. Un cuadro verde aparece
en el margen superior derecho para mostrar que no hay errores de sintaxis.
6.- En la línea en blanco entre las dos llaves que se agregaron al método,
escribir el siguiente código para retornar una cadena:
return " woof " + "Kate";
Observar que cuando escribe el primer símbolo de comillas ("), JDeveloper
automáticamente le proporciona las comillas en segundo lugar, se
adjuntaba el cursor entre ellas, por lo que fácilmente puede escribir el
literal.
3.3. Explorando el Editor de Código
En los editores se escribe el código y diseño de interfaces de usuario. Por lo cual
vamos a explorar algunas de las características del editor de código fuente de Java.
3.3.1.- Plantillas de código (Using code templates)
Las plantillas de código ayudan a escribir código en forma rápida y eficaz
mientras usted está en el editor de código fuente. Usted puede modificar las
plantillas existentes o crear uno propio.
En este caso se muestra cómo utilizar el código de algunas de las plantillas
existentes en la clase Dog.
1.- Existe un código de plantilla para agregar el método main en la clase
definida en Java.
Pulsar [Enter] para agregar una nueva línea después del método sayHi().
Escribir la letra m, y pulsar [Ctrl] + [Enter] para aplicar plantillas de
código.
36
El método main de la plantilla se sugiere.
2.- Pulse Enter para aceptar la sugerencia e incorporar a la plantilla, quedando
de la siguiente manera:
3.- Crear un objeto de la clase Dog en el método main agregando el código
siguiente:
Dog myDog = new Dog();
37
Nota: La variable mydog se muestra en gris, porque aún no ha sido
utilizado en cualquier parte de la clase. Si pasa el ratón sobre la variable
mydog, se muestra una descripción para decirles que la variable no se ha
utilizado.
4.- Pulse [Ctrl] + [Enter] para ver la lista de plantillas que están disponibles.
38
5.- Para insertar un bucle for con el código de la plantilla.
Agregar una nueva línea después de la línea que crea la variable mydog,
tipear f y luego pulsar [Ctrl] + [Enter].
Tres plantillas se sugieren
6.- Hacer doble click en la segunda de las tres propuestas, basado en el forloop para seleccionarlo quedando de la siguiente manera incorporado la
estructura del bucle for.
39
7.- Modificar el código de la plantilla. Para reemplazar el contador i por la
variable count y limitar el bucle a 3 iteraciones.
8.- Escribir la instrucción System.out.println.
Coloque el cursor en una línea en blanco dentro de las llaves del bucle, y
tipear System. (asegúrese de incluir el punto en la final de la palabra.) Una
lista de código sugerido aparecerá.
40
Tipear la letra O y pulse [Enter] para seleccionar el código propuesto, se
agregará el objeto out. tipear. (Punto), y cuando la lista de código
propuesto aparece, escriba la letra P y haga doble clic en el código
println() sugerido.
9.- Agregar el código para utilizar el bucle y mostrar el mensaje sayHi. Dentro
de los paréntesis después de println, introducir el siguiente código:
count + myDog.sayHi()
41
10.- Hacer clic en la vista del editor y seleccione Reformat para reestructurar
el código.
11.- Su código debe tener este aspecto:
3.4. Compilando y Ejecutando una Clase
Cuando se compila correctamente un archivo .java, se crea un archivo .class en el
directorio \ src del proyecto. JDeveloper guarda automáticamente los archivos
.java. Cuando se ejecuta una clase, se compila automáticamente y se guarda.
1.- En las Applications Navigator, hacer click derecho en Dog.java y seleccionar
crear (Make) en el menú contextual.
42
2.- En la parte inferior derecha del IDE JDeveloper, la ventana de registro debe
mostrar una compilación exitosa. Si la ventana de registro no aparece, utilice
Ver | Iniciar sesión para que aparezca (o pulse [Ctrl] + [Shift] + [L]).
Tenga en cuenta que al utilizar la opción make para compilar la clase,
JDeveloper guarda todos los archivos en el proyecto.
3.- En el Applications Navigator o en el editor de código fuente, hacer click en la
clase Dog.java, y seleccionar Run en el menú contextual.
43
En la ventana de registro muestra 3 mensajes de la cadena 'Kate'.
3.5. Trabajando con el Asistente de Código (CODE ASSIST)
El Código de Asistencia (Code Assist) examina el código en el editor y
proporciona asistencia para solucionar problemas comunes. Aquí se utiliza la clase
Dog para explorar algunos ejemplos de las sugerencias que se ofrecen.
1.- Crear un objeto Cat(gato).
Al inicio del método principal, después de la primera llave, pulsar [Enter] para
crear una nueva línea y escribir el siguiente código:
Cat MyCat = new Cat ();
2.- Observar que el icono de la bombilla se ha aparecido a la izquierda de la nueva
línea. Coloca el puntero del mouse sobre este icono y aparece el mensaje de
"soluciones rápidas y el código de asistencias para esta línea".
44
3.- Haga clic en el icono de la bombilla de luz para ver las correcciones sugeridas.
La notificación de diferentes colores en las bombillas de luz y al lado las
sugerencias, y signos diferentes en su interior. La bombilla de luz ámbar que
contiene un signo de interrogación (?) Indica una sugerencia para mejorar el
código, mientras que la bombilla roja que contiene un signo de exclamación (!)
Sugiere una forma de corregir un error.
Se necesita una clase Cat con el fin de crear una instancia de un objeto Cat. Si
hace click en la primera sugerencia, JDeveloper invoca el cuadro de diálogo
Crear la clase donde se puede crear una clase Cat.
45
5.- Si no desea crear la clase Cat ahora, haga click en Cancelar para cerrar el cuadro
de diálogo Crear la clase. Sin embargo, recuerda que puede hacerlo después de
la siguiente manera:
Pulse [Enter] después de hacer: new Cat(); para abrir una nueva línea. En la
nueva línea de introducir el siguiente código:
//TODO create a Cat class
Seleccione View | Tasks Window para ver una lista de tareas que usted ha
creado.
46
7.- La opción Task Window (ventana de tareas) muestra una lista de las tareas que
usted ha creado (en este caso, es su única tarea).
8.- Si hace doble clic en una tarea de la lista, JDeveloper le lleva a la tarea
correspondiente, insertando el cursor al comienzo de la línea.
47
9.- Observar el cuadro rojo en el margen superior derecho del editor. Moviendo el
mouse sobre este icono le informa de que hay errores en su programa.
10.- Un cuadro más pequeño rojo en el punto apropiado del código da más
información sobre el error.
11.- Los marcadores de color rosado indican que tiene creada una tarea. Ubicar el
puntero del mouse sobre el marcador para ver que tarea es.
48
12.- Como comentario la línea que crea el objeto Cat. Tenga en cuenta que los
globos rojos han desaparecido, para ser sustituido por un marcador de color
verde que indica que no hay errores en el código.
13.- Hacer clic derecho en la ventana del editor y seleccionar la opción Reformat.
El código debería tener el siguiente aspecto:
49
3.6.- Refactoring Code (Código de refactorización)
Refactoring es una técnica de edición que modifica la estructura del código sin
alterar el comportamiento del programa. Una operación de refactorización es una
secuencia de cambios simples que transforma el código de un programa, pero lo
mantiene en un estado en el que se compila y se ejecuta correctamente.
JDeveloper
proporciona
un
conjunto
de
operaciones
de
refactorización
(Refactoring).
1.- Un ejemplo de una operación de refactorización es la sustitución de una
expresión constante en el contenido de un método por un parámetro. Esta
expresión se sustituye por el nombre del parámetro. El nuevo parámetro se
añade a la lista de parámetros del método y de todas las invocaciones del
método.
Para hacer esto en la clase Dog, haga clic derecho en el literal, 'Kate' en el
código del método sayHi () y seleccionar Refactor | Introduce parámeter ... en el
menú contextual.
2.- En el cuadro de diálogo Introduce Parameter, escribir en el campo name
p_name, y haga clic en Aceptar.
50
3.- Examine el código para ver los resultados de la operación de refactorización. La
declaración de método contiene ahora la cadena p_name en su lista de
parámetros, el parámetro p_name ha sustituido el literal "Kate" en el método de
valor de retorno, y el literal "Kate" se ha incluido como un parámetro en la
llamada al método.
4.- Otra operación de refactorización es obtener una nueva interfaz de los métodos
seleccionados en una clase existente.
Para hacer esto en la clase Dog, haga clic derecho en la declaración de la clase
Dog, y en el menú contextual, seleccione Refactor | Extract Interface...
51
5.- En el diálogo de Extract Interface, escriba IntAnimal como nombre de la
interfaz, y seleccione el método sayHi (String) en los miembros a la lista de
Extract. Haga clic en Aceptar.
6.- La interfaz de IntAnimal se crea y se abre en el editor de código fuente.
7.- Otra operación de refactorización simple es renombrar un método, por el cual
cada vez que aparece el nombre del método se sustituye por el nuevo nombre.
Para hacer esto en la interfaz de IntAnimal, haga clic en el método sayHi (), y en
el menú contextual, seleccione Refactor | Rename.
52
8.- En el cuadro de diálogo Rename Method, cambie el nombre del método sayHi
por sayHowDoYouDo. Seleccione la casilla de verificación Preview para ver
todos los usos que se ven afectados por el cambio de nombre. Haga clic en OK.
9.- La ventana de registro (log) se listan todos los usos del método sayHi (). Usted
debe examinar cada uso para comprobar si desea cambiar cada ocurrencia de
sayHi () por sayHowDoYouDo (). Si es así, haga clic en Do Refactoring en la
barra de herramientas de la ventana log ( registro).
10.- Tenga en cuenta que el cambio de nombre ha tenido lugar en la interfaz de
IntAnimal ......
11.- .....y en la clase Dog
53
3.7. Ver Historial de Modificación del Código ( Viewing Code Modification History )
JDeveloper tiene incorporado la característica historia (History). Esta historia local
no requiere un sistema de control de versiones para proporcionar un cambio reciente
de registro y visualizar "este" entre las versiones. Las versiones se crean
automáticamente sobre la base de las interacciones del usuario, tales como Save
(Guardar), Compile (Compilar), Rename (Renombrar), y así sucesivamente.
1.- Notificación de las tres pestañas (fichas) en el pie de la ventana del editor. Hacer
click en la pestaña Historial (History).
2.- Se muestra la ventana history. La parte superior de la ventana contiene una lista
de las revisiones y las fechas, mientras que una lista de cambios en el código se
muestra en la parte inferior de la ventana. Las dos ventanas están sincronizadas,
54
de modo que el detalle en la parte inferior de la ventana coincide con la
selección en la parte superior.
Las revisiones para la fecha seleccionada y el tiempo se resumen en la línea de
estado en la parte inferior del IDE, en este caso 3 diferencias: 0 añadido, 0
eliminado, 3 cambiado.
3.- El color lila cajas indican cambios en el código. En la parte superior de la
ventana, seleccione Introduce Parameter.
En la porción inferior izquierda del editor, la posición del ratón sobre el lado
derecho de la flecha verde en el cuadro de color lila que contiene la declaración
del método sayHi (). Observe que se muestra un mensaje indicando que al hacer
clic derecho en la flecha verde le permite sustituir la diferencia adyacentes. En
este caso, haciendo clic en la flecha verde para revertir sayHowDoYouDo () por
sayHi ().
4.- Las cajas verdes indican las adiciones al código.
55
En la parte superior de la ventana, seleccione Expand Statement (Expandir
Declaración) en la parte inferior de la lista. En la parte inferior de la ventana,
seleccione el retorno "woof" + p_name; En la línea del cuadro verde en la
derecha de la ventana. Colocar el cursor sobre la X de color rojo con el ratón.
Observe el mensaje que indica que para eliminar la adición (s), haga clic derecho
en la X.
3.8. Navegando a Través del Código (navigating through code )
JDeveloper ofrece maneras fáciles de navegar a través del código relacionado a
Javadoc, y la posibilidad de ampliar o contraer secciones de código en la
navegación. Para explorar estas características, realizar los siguientes pasos:
1.-
Haga clic en la pestaña source del archivo Dog.java en el editor.
Usted puede navegar de una parte del código a otra parte relacionada.
Un ejemplo de esto es la navegación de un método para la declaración de una
interface. Un método que implementa una declaración de una interface muestra
una llamada fuera del icono en la margen izquierda. Al hacer click en este icono
te lleva a donde se declara el método.
Haga click en el icono que esta junto
al método sayHowDoYouDo () del archivo Dog.java.
56
2.- JDeveloper te lleva a la interface IntAnimal en donde el método esta declarado y
resalta el nombre del método para usted.
3.- Para retornar a la clase Dog donde estaba inicialmente, hacer clic en el botón
verde de la barra de herramientas
4.- También puede navegar en el Javadoc para un elemento dado. En el editor del
archivo de Dog.java, hacer clic derecho en la lista de parámetros para el método
sayHowDoYouDo (). Desde el menú contextual, seleccione Quick Javadoc.
5.- La etiqueta Javadoc para el objeto String se muestra.
57
6.- El código minimizado le permite ampliar las secciones de contrato de código,
haciendo que grandes programas sean más navegables.
Coloca tu ratón en el espacio entre las líneas de puntos y sólida a la izquierda de
la línea de Cat.
Nótese que el color azul muestra la línea vertical junto al cuerpo del método
principal.
7.- Hacer clic en el signo menos (-) de la parte superior de la línea azul vertical para
contraer esta sección de código.
58
8.- Colocar el cursor sobre el signo más (+) situado junto a la sección de contrato de
código. Las líneas de código contratadas en la pantalla se muestran en un cuadro
sombreado azul.
3.9.- Depuración de Programas (debugging java programs )
El depurador (debugger) integrado en JDeveloper permite depurar programas java
en el editor del código fuente.
En Este punto se muestra cómo controlar la ejecución de un programa mediante el
establecimiento de puntos de interrupción (breakpoint). Cuando la ejecución del
programa se encuentra con un punto de interrupción, el programa hace una pausa, y
el depurador muestra la línea que contiene el punto de interrupción en el editor de
código fuente. Usted puede usar el depurador(debugger) para ver el estado del
programa.
1.- Establezca un punto de interrupción (breakpoint) en el archivo Dog.java. Para
ello, haga clic en el margen izquierdo de la línea:
System.out.println (count + myDog.sayHowDoYouDo ( "Kate"));
El icono de punto de interrupción, aparece como una bola roja, y se muestra en
el margen izquierdo.
59
2.- Clic derecho en el editor de código y seleccionar Debug desde el menú
contextual.
3.- La ejecución del programa se produce hasta el punto de interrupción. La flecha
roja en el margen izquierdo del editor del código fuente indica que la ruptura se
está produciendo. La ventana del depurador se abre y muestra la depuración de
seguimiento.
60
4.- Haga clic en Step Over sobre el icono de la barra de herramientas de la ventana
del registro de depurador que ejecute la primera iteración del método
myDog.sayHowDoYouDo ().
5.- Tenga en cuenta que la ventana de registro muestra el primer mensaje de woof
Kate.
6.- Notificación de la ventana de datos inteligente en la parte inferior derecha de la
pantalla. Seleccione la variable count, y haga doble clic en la columna Valor
para mostrar el cuadro de diálogo Modify Value.
61
7.- Tipear 2 como Nuevo valor y hacer. Click en OK.
8.- En la barra de herramientas de depuración de registro de la ventana, haga clic en
Resume para continuar con la ejecución del programa.
9.- La variable count se incrementa y excede su límite, por lo que el programa
termina, y el depurador se desconecta.
62
CAPITULO IV: DESARROLLO DE APLICACIONES
4.1. Desarrollo de una Aplicación de Escritorio
En este ejemplo se desarrolla, una aplicación de escritorio siguiendo la arquitectura
modelo - vista – controlador.
El modelo de un componente está donde están almacenados sus datos, por ejemplo
el estado de un botón (pulsado, bajo el ratón, etc.) o los valores de una lista. La vista
es la representación en pantalla del componente, por ejemplo la forma (color,
bordes, etc.) en que aparece un botón o una lista. Finalmente, el controlador es la
parte del componente que gestiona la entrada, por ejemplo el código que describe
qué hacer cuando hacemos clic sobre el botón, también llamado manejador del
evento. Vamos a utilizar esta filosofía para dividir nuestra aplicación en vistas y
documentos
Creacion de la Aplicacion
Primero crear la aplicación siguiendo el modelo vista-controlador. Para ello, desde
el navegador de objetos
1.- Haz clic con el botón derecho sobre la carpeta Applications
2.- Elegir "New Application".
3.- En el cuadro de diálogo "Create Application", de la plantilla debemos elegir
Java Application [Swing, ADF BC], para que nuestra aplicación sea creada con
dos proyectos por defecto: Model y View, siguiendo la arquitectura MVC.
Name
GestionTaller
Directory name
Elige el directorio donde quieras guardar la aplicación
Application template:
Java Application [Swing ADF BC]
La plantilla de aplicación [Swing, ADF BC], podemos decir que se utiliza para
construir aplicaciones rápidas basadas en ADF Swing. Los componentes ADF
Business Components se utilizan para construir el modelo de datos.
También en la ventana de "Create Application", puedes hacer clic en el botón
"Manage Templates" para conocer diferentes conceptos.
63
En la parte derecha de la ventana "Manage Application Templates" encontrarás
las tecnologías que por defecto se le asignan a la plantilla [Swing, ADF BC]. Si
seleccionas por ejemplo: Rich Client View podras ver una descripción de dicha
tecnología.
Por tanto, ADF Swing es una capa que enlaza los componentes Swing estándar
con la capa de Oracle Application Development Framework (ADF). Se usa
para construir aplicaciones cliente que requieren una respuesta inmediata hacia el
usuario o los eventos que cambian la pantalla del usuario, y que encuentran mejor
soporte en Swing que en la Web. Otra razón para construir clientes Swing es
cuando, por razones de negocio, las aplicaciones necesitan trabajar off-line,
desconectadas de la red. ADF Business Components gobierna la interacción
entre el resto de la aplicación y los datos almacenados en la base de datos,
proveyendo de servicios de validación y otras lógicas de negocio.
Quedando en el navegador de aplicaciones:
CREACION DE LA INTERFAZ
64
Esta aplicación consta de más de un formulario por lo tanto comenzaremos con
primer formulario que consiste en una ventana login.
VENTANA DE LOGIN
Nuestro primer formulario va a ser la ventana de login de la aplicación. Este
formulario comprobará que el usuario y contraseña coinciden con uno dado.
Posteriormente se puede mejorar incorporando un contador de intentos fallidos o,
lo que es más importante, validando el usuario con la base de datos para permitir
la entrada de varios usuarios a la aplicación, cada uno con sus correspondientes
permisos.
Para crear el formulario nos dirigimos al navegador de objetos, hacemos clic con
el botón derecho sobre la carpeta View de nuestra aplicación y elegimos New.
Dentro de la categoría Client Tier ( Swing/AWT elegimos el ítem Frame para
crear un programa fuente de tipo JFrame.
En la ventana creada introducimos Login como nombre del formulario e Inicio
de sesión en el atributo título y pulsamos Aceptar.
Esta Interfaz Gráfica debe contar con las siguientes características:
§ Amigable: que facilite la tarea al usuario,
§ Agradable: utilizar colores suaves y evitar los diseños estridentes de mal gusto,
alinear correctamente los elementos, etc.
§ Intuitiva: lo más fácil es situar los botones, menús, etc., de forma similar a los
que el usuario esté acostumbrado, o sea, basarse en las características generales
de cualquier aplicación Windows o Linux.
§ Homogénea: toda la interfaz de nuestra aplicación debe guardar el
mismo aspecto, por ejemplo, utilizando distintas tonalidades dentro del mismo
color para los fondos, utilizar el mismo tipo de letra para objetos similares, etc.
65
Comentarios y legibilidad del código: Un aspecto interno de nuestra aplicación
relativo a la forma de programar es que nuestros formularios sólo deben tener el
código estrictamente necesario para que funcionen y desarrollen las capacidades
previstas. En ocasiones JDeveloper puede generar código automático que nos
ayuda pero otras veces sólo entorpece la lectura, cuando nos encontremos con este
tipo de situaciones eliminaremos el código sobrante para hacer más legible nuestro
código fuente. Además, utilizaremos los comentarios adecuadamente tanto para
comentar expresiones complicadas o especiales como para describir la
funcionalidad de los métodos o para introducir información adicional como
creador del programa, fecha, copyright,... etc. En este apartado también deberemos
cuidar la organización de nuestra aplicación: evitar archivos innecesarios, utilizar
nombres significativos para las clases, etc.
En la ventana de Login. En primer lugar en el Inspector de Propiedades para
modificar la propiedad Size a 365,233.
Seguidamente, vamos a crear una serie de componentes Swing arrastrándolos
hacia el formulario desde la Paleta de Componentes situada en la parte derecha de
la aplicación. Estos controles, que nos van a servir para la introducción del usuario
y la contraseña, tienen las propiedades siguientes:
Nombre
Tipo
txUsuario JTextField
txPass
Size
135,20
JPasswordField 135,20
Bounds
Text
Horizontal
Alignment
195, 65,
Introduzca un
135, 20
usuario valido
195, 90,
Introduzca
135, 20
contraseña
lbUsuario JLabel
55,20
Usuario:
lbPass
75,20
Contraseña: Right
JLabel
btAceptar JButton
tooltipText
Right
95,25
Para alinear el lbUsuario a la misma altura que está txUsuario los seleccionamos
ambos, primero uno y luego otro con la tecla Ctrl pulsada y elegimos Align/Top
del menú contextual que aparece al hacer clic con el botón derecho. Igual hacemos
con los controles lbPass y txPass. Por último, alineamos a la derecha los controles
lbUsuario y lbPass con la opción Align/Right y el control btAceptar a la
derecha con los cuadros de texto.
En ocasiones, para propiedades que tienen el mismo valor podemos seleccionar
todos los controles con la tecla Ctrl y aplicarles la propiedad a todos a la vez. Por
66
ejemplo, pruébalo para establecer la fuente Ms Sans Serif, 11 en todos los
controles del formulario.
Ahora vamos a asignar un icono a la ventana que acabamos
de crear, o sea, una imagen que aparezca a la izquierda de
la barra de título y en la barra de tareas cuando esté
minimizada.
Para conseguir esto, hemos de introducir una serie de líneas
de código en nuestra clase Login. Así que nos vamos a la
parte inferior de el área donde estamos diseñando, donde pone Source, Desgin,
History y elegimos la primera etiqueta (Source). Nos aparecerá el código de
nuestra ventana Login, que actualmente tan sólo debe estar formado por el
constructor de la clase y por el método jbInit(), que como sabes se ejecuta cada
vez que se invoca el constructor, o sea, cada vez que tiene lugar una sentencia ...
new Login().
A continuación, introducimos un nuevo atributo en nuestra clase llamado icono, y
una nueva sentencia en el método jbInit() del formulario Login, debe quedar algo
como lo que sigue (en negrita lo que debemos introducir):
public class Login extends JFrame {
private JTextField jtxUsuario = new JTextField();
private JTextField jtxPass = new JTextField();
...
private ImageIcon icono = new
ImageIcon(getClass().getResource(“images/icono.png”));
private Image miImagen=icono.getImage();
public Login() {
...
}
private void jbInit() throws Exception {
...
this.setIconImage(miImagen);
...
}
67
Por supuesto, tanto la imagen como el directorio deben existir. Si te fijas, la
imagen está guardada en un directorio llamado images que está dentro del
directorio src, al mismo nivel de jerarquía que la carpeta view de nuestro
proyecto.
Al introducir el código, JDeveloper te indicará mediante un globito rojo en la parte
izquierda de la ventana los paquetes que son necesarios importar para las clases
que estés utilizando, javax.swing.ImageIcon y java.awt.Image para las clases
ImageIcon e Image, respectivamente.
Todo esto queda reflejado en modo visual si nos vamos a las propiedades del
formulario, veremos que en la propiedad iconImage aparece miImagen como
icono de la barra de título.
Clase Principal
Una vez que hemos creado nuestra ventana de entrada necesitamos añadir una
clase principal que contenga la aplicación y que tenga asociada la interfaz gráfica
anterior.
Para ello hay que seleccionar proyecto (carpeta) view y hacer click File, click
New y dentro de Client Tier ( Swing/AWT escoger Java Application, darle un
nombre (por ejemplo Principal), e indicar que se le desea añadir un frame por
defecto.
Seleccionar la opción "Existing frame" y, tras pulsar el botón "Browse" escribir
el nombre del frame con la interfaz gráfica, que en este caso es Login. Conviene
dejar activa la caja de comprobación "Center frame on screen" para que el frame
aparezca justo en el centro del monitor cuando se ejecute la aplicación.
68
Ya estamos preparados para ejecutar la aplicación. Para ello seleccionamos
previamente en el navegador de objetos la clase con la aplicación (Principal), y
hacemos Run.
Creación de la interfaz gráfica de usuario (GUI) mediante JFC/Swing
En los apartados anteriores hemos creado una ventana de Login para nuestra
aplicación y una clase lanzadora llamada Principal. Ahora necesitamos crear la
interfaz gráfica de la que constará nuestra aplicación, que aparecerá una vez que el
usuario haya introducido los datos de acceso correctos.
Para ello en el IDE JDeveloper crear la ventana de menú
y la típica ventana de "Acerca de..." prácticamente de
forma automática. Esto lo conseguimos haciendo clic con
el botón derecho sobre View o clic en el menú File,
escogiendo la opción de New y dentro de Client Tier (
Swing/AWT. Así podemos crear un nuevo frame y
escoger si queremos que tenga barra de menú, barra de
herramientas, barra de estado o cuadro de diálogo
"Acerca de". Elegiremos todas las opciones.
Rápidamente podemos comprobar cómo se han creado
dos nuevas clases, menu.java y menu_AboutBoxPanel1.java.
69
Ahora sólo te recomendamos que cambies las imágenes que se han creado de sitio
y las introduzcas en la carpeta Images que está al mismo nivel de jerarquía que la
carpeta view de nuestro proyecto. ¿Sabrías qué parte del código de la clase
menú.java hay que modificar para que haga referencia a la nueva ruta de las
imágenes?
Seguidamente introduciremos el siguiente código en el evento MousedClicked
del control btAceptar de la ventana de Login:
try{
boolean acceso =this.hacerLogin(this.txUsuario.getText(),
this.txPass.getText());
if (!acceso) {
this.lbAcceso.setText("Acceso denegado");
} else {
menu ppal = new menu(); // creamos la ventana ppal que es de tipo menú
ppal.setVisible(true);
// y la visualizamos
this.setVisible(false);// ocultamos la ventana de login
}
} catch (Exception ex) { ex.printStackTrace(); }
De esta forma, cuando el usuario introduzca los datos de acceso correctos y le dé
al botón Aceptar, se lanzará la clase menu.java que contiene la interfaz de la
aplicación. El método hacerLogin lo introduciremos dentro de la clase Login y lo
único que hará por ahora será validar el usuario y la contraseña:
public boolean hacerLogin (String u, String p) {
if (u.equals("invitado") && p.equals("invitado")) return true;
return false;
}
Nos vamos a la clase Principal y con el botón
ejecutamos la aplicación, o bien con F11. Introducimos
el usuario y contraseña (invitado - invitado) y
comprobamos cómo al darle a Aceptar se muestra la
70
interfaz gráfica, y también el cuadro de información que se obtiene al pulsar el
menú Help.
Observarás que la ventana de menú se ha visualizado en tamaño pequeño y en la
esquina superior izquierda de la pantalla. Nos interesa que se visualice de forma
maximizada y que, si se restaura, aparezca en el centro de la pantalla. Esto nos va
a interesar para todas las ventanas que hagamos, por lo que decidimos crear una
nueva clase cuyo código puedan utilizar todas las ventanas que lo necesiten.
Llamamos a la clase pantalla y el código puede ser algo como lo siguiente:
public class pantalla {
public pantalla() {
}
static void centrar(JFrame f) {
// Calculo el tamaño de la pantalla y de la ventana
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = f.getSize();
// Si es mayor, igualo el tamaño de la ventana al de la pantalla
if (frameSize.height > screenSize.height) {
frameSize.height = screenSize.height;
}
if (frameSize.width > screenSize.width) {
frameSize.width = screenSize.width;
}
// Sitúo la ventana en el centro de la pantalla
f.setLocation( ( screenSize.width - frameSize.width ) / 2, (screenSize.height frameSize.height ) / 2 );
f.setVisible(true);
}
static void maximizar(JFrame f){
int state = f.getExtendedState();
state |= f.MAXIMIZED_BOTH;
// Maximizamos el frame
f.setExtendedState(state);
}
}
Podemos utilizar este código cada vez que creemos una ventana nueva, tan sólo
tendremos que hacer:
pantalla.centrar(miventana) o pantalla.maximizar(miventana).
71
El resultado es que hemos creado una ventana de menú que aparece centrada y
maximizada cuando el usuario introduce los datos correctos de acceso, y un
cuadro "Acerca de".
Al comienzo de la presentación se te muestran las clases que tiene hasta este
momento nuestra aplicación: Principal.java y Login.java, para luego continuar
creando una nueva ventana llamada "Gestion de Taller"
CAMBIOS EN LA INTERFAZ
Llegados a este punto tenemos la ventana menú y el cuadro "Acerca de" que ha
creado JDeveloper. Ahora es el momento de hacer los cambios necesarios para
adaptar estas ventanas a nuestra aplicación y crear nuevas ventanas para dotar de
contenido y consistencia a nuestro proyecto.
Vamos a realizar algunos cambios en nuestra
aplicación.
Estos cambios podremos realizarlos
dirigiéndonos a la pestaña Source del
formulario que queramos modificar, o por
ejemplo arrastrando desde el grupo Swing o
Swing Containers de la Paleta de
Componentes.
PANTALLA DE BIENVENIDA
La pantalla de bienvenida o ventana splash es una práctica
habitual en las aplicaciones de hoy en día. Usar una ventana
splash es una forma de avisar al usuario de que algo está
ocurriendo en la aplicación durante el periodo de arranque.
§ Algunas ventanas splash pueden ser cerradas pinchando en cualquier lugar de la
ventana,
§ otras se cierran solas y
§ otras permanecen después que la aplicación haya comenzado.
Vamos a lanzar primero la ventana splash y después la ventana de Login.
En primer lugar vamos a crear un JPanel (File/New/Swing/AWT ( Panel) que
contenga lo que queremos que muestre la ventana splash, que va a ser tan sólo una
barra de progreso utilizando el componente Swing JProgressBar. Seleccionamos
72
los valores mínimos y máximos de la barra de progreso en 0 y 40, respectivamente
(propiedades minimium y maximium). También se pueden seleccionar estos
valores con los métodos setMinimum y setMaximum, o en el constructor al crear
la barra de progreso. La propiedad StringPainted hace que la barra de progreso
muestre un String (cadena) de porcentaje dentro de sus límites. Por defecto, la
cadena indica el porcentaje completo de la barra de progreso. El String de
porcentaje es el valor devuelto por el método getPercentComplete formateado a
porcentaje. Otra alternativa es mostrar un String diferente con setString.
Para ir cambiando el valor de la barra de progreso utilizamos un temporizador (un
ejemplar de la clase Timer). Este objeto se arranca con el método Start() y
dispara un evento action cada segundo. El método oyente del evento action es
ActionPerformed y lo que hace es llevar un contador para ir modificando el valor
de la barra de progreso.
El código completo lo mostramos a continuación. Observa que el JPanel que
hemos creado tiene un método main(), con lo cual ya no necesitamos la clase
Principal para lanzar nuestra aplicación, sino que se lanzaría desde ésta nueva
clase llamada Inicio.
public class Inicio extends JPanel implements ActionListener {
private Timer timer = new Timer(100, this);
private JProgressBar barraprogreso = new JProgressBar();
private int cont=0;
public Inicio() {
try {
jbInit();
} catch (Exception e) {
e.printStackTrace();
}
}
private void jbInit() throws Exception {
barraprogreso.setBounds(new Rectangle(80, 235, 230, 15));
barraprogreso.setStringPainted(true);
barraprogreso.setMaximum(40);
this.add(barraprogreso, null);
this.actionPerformed(null);
this.timer.start();
this.setBackground(new Color(115, 147, 245));
73
this.setLayout(null);
}
public void actionPerformed(ActionEvent e) {
this.cont=this.cont+1;
this. barraprogreso.setValue(cont);
}
public static void main(String[] a){
JWindow f = new JWindow(); //creo una ventana sin barra de título
f.add(new Inicio()); //añado el JPanel a la ventana
f.pack();
f.setSize(400,300);
f.setVisible(true);
//aquí mejor usar el método pantalla.centrar
JFrame f2 = new Login();
// creamos la ventana de login
try { Thread.sleep (5000); } catch (Exception e) {}
pantalla.centrar(f2);
f.setVisible(false);
//cerramos la ventana splash
}
}
Pues bien, ya hemos conseguido crear nuestra ventana splash. Si la ejecutamos
verás que no queda centrada, y además, nos interesaría que apareciera también una
imagen característica de la aplicación. Centrar la ventana se puede hacer con
nuestra clase pantalla.java, sobrecargando el método centrar() para que pueda
servir también para objetos JWindow. Para poner una imagen de fondo en un
JPanel debemos sobrecargar el método public void paintComponent(Graphics
g) para que dibuje la imagen que queramos. La imagen de fondo la puedes crear
con un programa de manipulación de imágenes sencillo como es GIMP.
En nuestro ejemplo lo que
hemos hecho es crear un
fondo degradado y añadir una
imagen característica y el
título y versión de la
aplicación.
74
4.2. Desarrollo De Aplicación Conversión de Temperatura
Si la ventana de Applications Navigator no
está abierta, entonces eligir: View, Application
Navigator
Seleccione Applications en la ventana del Navegador de Aplicaciones
Hacer click derecho y seleccionar New Application en menú contextual
JDeveloper mostrará su cuadro de diálogo
Create Application.
.-Introducir un Nombre de aplicación:
convierteCelsiusFarenheit
.- Haga clic en el botón ACEPTAR.
JDeveloper mostrará su cuadro de diálogo
Create Project
.- Introduzca un Nombre del proyecto: conversionCF
.-Haga clic en el botón Aceptar.
RESULTADO
Crear una nueva Aplicación y Frame
Seleccione el proyecto
convierteCelsiusFarenheit en la ventana de
Application Navigator.
.- Click derecho sobre nombre proyecto
.- click New
75
JDeveloper mostrará cuadro de diálogo New
Gallery.
Ampliar el nivel de clientes en el nodo de árbol de
las categorías de la New Gallery del cuadro de
diálogo.
Seleccione Swing / AWT en el árbol de categorías.
Elija de Java Application de la lista de artículos.
Haga clic en el botón Aceptar
JDeveloper muestra el cuadro de diálogo de Create Java Aplication.
Introduzca un Nombre: frmconversionCaF en el
cuadro de diálogo de Crear aplicaciones Java.
java.lang.Object indica que es la clase base de la
cual hereda la nueva clase que estamos creando.
Agregar el formulario (ventana) predeterminado
cuya casilla está marcado.
Esto permite crear una instancia del formulario en
esta clase que contiene el void main(…)
La casilla de Center Frame ( formulario) en la
pantalla, está marcado.
Haga clic en el botón Aceptar.
JDeveloper muestra el cuadro de diálogo Create
Frame.
Introducir en name: frmConversion
Observe que la lista desplegable contiene
javax.swing.JFrame ya que están creando una
clase que hereda de JFrame
Escribir un título para la ventana: Conversión
de Celsius a Fahrenheit
Haga clic en el botón Aceptar
Si desea puede activar casillas de verificación que
indican: MenuBar( Barra de Menús), Tool Bar
(Barra de Herramientas), Status Bar (Barra de
Estado) About Box (Acerca de), esta última crea
una clase aparte con una ventana o formulario.
76
En la ventana de aplicaciones debe mostrar
las dos clases creadas dentro del paquete
temperatura:
Si deseamos modificar el nombre del la
clase que contiene el void main, procedemos
de la siguiente manera:
Botón derecho en frmconversionCaF.java
Click en Refactor
Click en Rename….
Aparece ventana de dialogo: Rename
frmConversionCaF
Sobrescribir nuevo nombre: ConversionCaF
Click en Aceptar, aquí busca todas las ocurrencias de frmConversionCaF y las
reemplaza por ConversionCaF en todo el proyecto.
Hacer doble click en ConversionCaF.java de la ventana de aplicaciones
Y aparece seleccionado pestaña Source de la ventana que muestra el código
generado hasta ahora por el JDeveloper.
//programa que contiene main: ConversionCaF.java
package temperatura;
import java.awt.Dimension;
import java.awt.Toolkit;
import javax.swing.JFrame;
import javax.swing.UIManager;
public class ConversionCaF {
public ConversionCaF() {
JFrame frame = new frmConversion();
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
Dimension frameSize = frame.getSize();
if (frameSize.height > screenSize.height) {
frameSize.height = screenSize.height;
}
if (frameSize.width > screenSize.width) {
frameSize.width = screenSize.width;
}
frame.setLocation((screenSize.width - frameSize.width) / 2,
(screenSize.height - frameSize.height) / 2);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
public static void main(String[] args) {
try {
77
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception e) {
e.printStackTrace();
}
new ConversionCaF();
}
}
Hacer doble clic en frmConversion.java en la ventana de Application
Navigator.
Seleccione la etiqueta Fuente (Source)
Debe mostrar el siguiente código generado:
package temperatura;
import java.awt.Dimension;
import javax.swing.JFrame;
public class frmConversion extends JFrame {
public frmConversion() {
try {
jbInit();
} catch (Exception e) {
e.printStackTrace();
}
}
private void jbInit() throws Exception {
this.getContentPane().setLayout( null );
this.setSize( new Dimension(400, 300) );
this.setTitle( "Conversion de Celsius a Farenheit" );
}
}
CREAR INTERFAZ GRAFICA
Hacer clic en la pestaña Design de la ventana
frmConversion.java
Para ir a la ventana de diseño
Ubicar la paleta de componentes
Si fuera necesario para activarla hacer:
Click View
Click Component Palette
Diseñar la siguiente Interfaz
Insertar JLabel: Hacer click en
de la paleta de componentes
78
Dibujar un rectángulo sobre la ventana en una
ubicación adecuada, tal como lo muestra la figura
Propiedades del objeto (property Inspector)
Haciendo click derecho sobre objeto JLabel
Click Property Inspector
Aparece cuadro de dialogo de propiedades
Elegir propiedad Text
Escribir en lado derecho de esta propiedad text:
Grados Celsius
De la misma forma se procede con las otras etiquetas
de la ventana
Alinear Etiquetas (JLabel) de la ventana:
.- Seleccionar etiquetas con títulos: Grado Celsius y Grados Fahrenheit,
manteniendo presionado tecla CTRL y hacer click en cada etiqueta, tal como lo
muestra la figura.
De la barra de herramientas hacer click en el
ícono Align Right tal como muestra figura y
automáticamente se alinearan los objetos
Siguiendo el ejemplo de las etiquetas (JLabels)
agregar:
Objeto
JTextField
JTextField
JButton
JButton
name
Text
txtgradosCelsius
txtgradosFharenheit
btnCalcular
Calcular
btnSalir
Salir
La interfaz debe quedar
Font
12,Dialog,Bold
12,Dialog,Bold
79
4.3. Creando Tablas
El objetivo de este ejemplo es describir el proceso para crear una aplicación de
escritorio en Java utilizando JDeveloper, la cual mostrará la información en un
JTable.
Seleccionamos la clase que contiene el frame para nuestra aplicación y aparecerán
las siguientes vistas:
Code Editor
Esta vista aparece en el centro del JDeveloper y tiene como objetivo permitirnos
crear y modificar el código de nuestra aplicación. Comúnmente nos muestra el
código de Java de la aplicación, sin embargo en clases que sean: Marcos (Frames) ,
Dialogos (Dialogs) o Paneles (Panel) nos mostrará el diseño de estos.
Ahora observemos que nos aparecerá en la sección de código la vista del marco que
estamos diseñando. Es muy importante hacer notar que el editor de interfaz de
JDeveloper, en su parte inferior encontraremos 3 pestañas:
· Source: Nos muestra el código de la clase que estamos implementando.
· Design: Nos muestra como luce la vista del marco que estamos diseñando.
· History: Nos muestra el histórico de cambios del archivo.
Structure.
La cual tendrá unas carpetas que indicarán:
· UI: Es la estructura de los componentes que aparecen en pantalla, en nuestro
frame.
80
· Menu: En caso de hubiésemos seleccionado un menú en la pantalla de
configuración de la aplicación, en esta sección aparecen los elemento del Menu
superior.
· Other: Aquí podemos encontrar las imágenes o elementos como models, arrays
que utilizamos en nuestra vista.
Nuestro primer objetivo es asignarle a la vista un Layout, que nos permita organizar
los componentes de nuestra interfaz gráfica.
Component Palette
Esta es una vista muy importante para el desarrollo de este manual es la Paleta de
componentes, en la cual podemos encontrar los componentes que tenemos
disponibles para nuestra aplicación de Swing. Es muy importante señalar que en la
parte superior está vista cuenta con un selector de tipos de componentes. En ese
selector podemos encontrar los Swing containers, componentes que pueden
contener a otros. Y la paleta de Swing, todos los componentes como botones,
cuadros de texto, los JTable, etc.
Agregando el JTable
Una vez creado el proyecto, es necesario diseñar el layout que va a tener nuestra a
aplicación, por lo cual nos vamos a apoyar en la imagen anterior de JDeveloper.
En la vista de Structure debemos seleccionar la carpeta de UI -> this ->
panelCenter. Una vez que haya sido seleccionado debemos utilizar en inspector de
propiedades Property Inspector, donde buscaremos la propiedad de layout y le
asignaremos el BorderLayout.
En el layout seleccionaremos en la Paleta de componentes la categoría de Swing
Containers, de la cual utilizaremos el JScrollPane, que nos ayudará a proveer de
Barras de Scroll al JTable y proveer de encabezados al JTable, ya que si una tabla
no está dentro de un JTable, está no mostrará los encabezados.
Para terminar con la interfaz gráfica seleccionaremos en la Paleta de componentes
la categoría de Swing, para agregar el JTable en nuestro JScrollPane.
Cuando realicemos estos pasos es conveniente observar siempre la vista de
Structure, para corroborar que nuestra interfaz gráfica tenga la estructura correcta.
Nota: Es importante renombrar los componentes de manera que tengan nombres
claros, esto se puede lograr seleccionando el componente en la vista de Structure y
utilizando el segundo botón del mouse y seleccionar la opción de Refactoring.
Aparecerá un dialogo en el cual podemos cambiar el nombre del componente. O
81
bien podemos utilizar la vista de Inspector de propiedades y modificar la
propiedad name.
Creando el Table Model
Con la interfaz gráfica diseñada es tiempo de utilizar el tab de código de nuestro
editor, asignar al JTable los encabezados y de registros. En Swing hay dos formas
de enviar esta información a un JTable:
· Usando un par de arreglos
o Un array unidimensional (Object[]) para los títulos
o Un array bidimensional (Object[][]) para los registros
· Usando Vectores
o Un Vector de objetos para los títulos
o Un Vector de Vectores para los registros, en el cual habrá un vector por cada
registro.
Para este ejemplo se utilizarán arreglos.
Arreglo para los titulos
/**
* Indica cuales serán los títulos del JTable.
* Se utiliza un arreglo statico y final, debido a los títulos
* no cambiarán con el paso del tiempo.
*/
public static final String[] titulos = {"Usuario", "Nombre", "Departamento"};
Arreglo de los registros
/**
* Se inicializa un arreglo bidimensional para simular el contenido de la
* tabla
*/
public String[][] registros = {
{"aperez","Adrian Perez", "Contabilidad"},
{"jlopez","Jesús Lopez", "Administrativo"},
{"cramos","Claudia Ramos", "Recursos Humanos"}};
Una vez que tenemos los títulos y los registros es necesario crear un TableModel, el
cual es una interfaz que describe como deben realizarse las operaciones de
actualización en un JTable. En este caso se utiliza un DefaultTableModel que es
una implementación sencilla pero útil para muchos de los escenarios con los que
trabajamos. Sin embargo si los elementos que vamos a desplegar son muchos y la
82
actualización es muy frecuente quizás sea necesario crear una implementación
propia que cumpla con nuestras necesidades.
DefaultTableModel model = new DefaultTableModel();
Aplicando el Table model al JTable
Una vez que ya contamos con el TableModel, el JTable en la interfaz Gráfica, es
necesario realizar la asignación de los títulos y registros al TableModel y el
TableModel al JTable. Para la cual nos posicionaremos en el método que inicializa
la interfaz gráfica en una aplicación desarrollada con el JDeveloper, jbinit().
private void jbInit() throws Exception {
this.getContentPane().setLayout( layoutMain );
// Asignamos los titulos y los registros al table model
model.setDataVector(registros,titulos);
// El table model es asignado al jTable de la aplicación
lista.setModel(model);
// Continua el código de inicialización
}
Por último ejecutamos la aplicación presionando siguiendo los pasos del ejemplo de
creación de una aplicación de JDeveloper.
La aplicación creada luce de la siguiente manera:
4.4. Base de Datos
4.4.1. Conexión a la Base de Datos
1. Para hacer las pruebas, usaremos Access. Proceda a crear la Base de Datos
Ventas, en ella creará la tabla Socios con los siguientes campos:
codigo char(3)
83
nombre char(50)
direccion char(80)
telefono char(10)
2. En Windows usando ODBC creamos un dns al que llamaremos “dns_mdb”
hacia la base de datos access Ventas.mdb
3. Crear una nueva aplicación
4. Habilite el panel Connection Navigator
5. En la seccion Database haga Clic derecho e inicie con la creación de una
Nueva conexión. Asigne un nombre a la conexión y luego indique el tipo de
conexión: Bridge JDBC-ODBC
Marque siguiente, como la base de datos Access no requiere autentificación,
deje en blanco los cuadros de texto usuario y clave.
84
6. Ahora debe anotar el nombre del dns creado:
7. Verifique si los parámetros ingresados son los correctos, presionando el
boton Test
8. Inspeccione en la seccion Database y debera ver las tablas, al hacer doble
click accedera a la estructura de dicha tabla
85
9. En la parte inferior del panel que muestra la estructura se muestra una
pestaña que indica Data, desde ella podrá acceder a los registros
4.4.2. Creando una Interfaz de Acceso a la Base de Datos
1. Inicie un nuevo proyecto
2. Creamos un diagrama de componentes de negocio
86
3.
Asigne un nombre al diagrama
4.
En el panel Connection Navigator, ubique la tabla Socios
5. Arrastre la tabla Socios al diseñador
87
6.
Se habra creado:
7. Ahora vamos a crear el código del componente
8. Dígale siguiente a cada uno de los pasos:
88
9. Finalmente Terminar
10. Active el panel Database Control Panel, desde el View, este panel le
mostrara cada uno de los campos:
11. Ahora vamos a crear un formulario:
89
12. Señalamos el nombre para el formulario:
13. Luego arrastre los campos desde el panel Database Control Panel
90
14. Haga el mismo procedimiento pero arrastrando tabla
15. Finalmente obtendrá el siguiente diseño
16. Ejecute
91
Ejemplo 3: Otra forma
1. Creamos un formulario:
2. Indicamos la plantilla: Single Columns
3. Seleccione los campos a mostrar:
92
4. Obtendrá el siguiente diseño:
5. Ejecutamos
93
BIBLIOGRAFÍA
1.
Cuenca Jiménez Pedro Manuel, "Programación en Java". Ediciones Anaya
Multimedia. 1997.
2.
Framiñán Torres José Manuel. "Manual Imprescindible de Java". Ediciones
Anaya Multimedia. 1997
3.
Froufe Agustín: Java 2, Manual de Usuario y Tutorial
4.
Gosling J., K.Arnold: Java Didáctica y Programación, Addison-Wesley
Primera edición, Marzo de 1997
5.
"JDK 1.2 Documentation".
www.sun.com. 1997. (Documentación de la API de Java del JDK).
6.
Sanz Alamillo Javier. "Novedades y cambios con Java 2".
7.
Vasquez Julio, Balta Victor: “Guia de programación Java 2”
BIBLIOGRAFÍA ELECTRONICA
8.
Portal de JDeveloper
www.jdeveloperla.com
9.
Pagina oficial de JDeveloper
http://www.oracle.com/technology/products/jdev/index.html
10.
Características de JDeveloper
http://wiki.cetechihuahua.gob.mx/index.php/IDE-JDeveloper"
11.
Java® 2 SDK, Standard Edition Documentation.
http://java.sun.com/j2se
12.
History of JDeveloper Releases.
http://radio.weblogs.com/0118231/stories/2005/02/25/historyOfJdeveloperR
eleases.html
13.
Aplicaciones Java Swing con ORACLE JDeveloper
http://indomable.wordpress.com/2007/11/04/aplicaciones-java-swingcon-oracle-jdeveloper-101310-clase-1/
14.
Wikepedia Enciclopedia Libre
http://es.wikipedia.org/wiki/JDeveloper"
94
ANEXOS
Tips en JDeveloper
1.- Como Crear un JAR
·
Primero debe desarrollar la aplicación
·
Elegir el proyecto del cual debe estar definida la clase principal
·
Ir a File
·
Ir a New
·
Ó En Nombre de proyecto: Hacer anticlick
·
Ir a General
·
Seleccionar deployment profiles
·
Seleccionar JAR File
·
Seleccionar Aceptar
·
Escribir nombre de deployment miJar
·
Seleccionar Aceptar
·
Aparece JAR Options
·
En Main Class seleccionar Browse
·
Seleccionar HIERACHY
·
Seleccionar DM
·
Elegir nombre de clase principal
·
Aceptar
Resultado
·
Se crea miJar.deploy
·
Hacer anticlick en miJar.deploy
·
Seleccionar Deploy To Jar File
Si tiene errores no crea JAR en caso contrario ya tenemos nuestro JAR
2.- Como incluir una librería
·
·
·
clik Tools
click en Configure Palette (configura paleta componentes)
En panel izquierdo click add (para agregar un nombre al paquete ejemplo swing
containers)
95
·
·
·
·
·
·
·
·
·
·
Escribir el nombre de la nueva opción
Seleccionar page type ……… java
Seleccionar aceptar
En panel derecho click add (para agregar clases a la nueva opcion ejemplo
jbutton)
De la lista library elegir swing and awt
De la opción javax elegir swing
Hacer click Joptionpane
Seleccionar instalar - si
Seleccionar aceptar
Si no desea seguir agregando entonces aceptar y salir de la ventana de
configuración
3.- Importar un Jar
·
Hacer anticlick sobre el nombre de un proyecto ejemplo: xxx.jpr
·
En el arbol ir a Profiles/Development/Libraries
·
Una vez ahí en la parte derecha de la pantalla deberás hacer un new..
·
Aparecerá una ventana en la que debes incluir la ruta del .jar que deseas
añadir a tu proyecto.
·
Seleccionar el nombre del Jar
·
Seleccionar aceptar
4.- Aplicación Java Swing
En este ejemplo trataré de detallar al máximo cada paso a realizarse así como iré
señalando algunas ayudas con las que cuentas este IDE, y dar doble clic el
jdeveloper para poder comenzar a trabajar.
96
Luego de la pantalla de carga aparecerá la pantalla principal y damos clic derecho
dentro de Applications Navigator en Applications y seleccionamos New
Application…
Nos aparecerá la siguiente pantalla en la cual en el campo Application Name
pondremos nuestro nombre de la aplicación para este ejemplo realizaremos una
aplicación para un departamento médico en el Directory Name se especifica la
dirección en donde se alojará nuestro Proyecto, dentro de Application Package
Prefix pondremos una abreviatura para identificar nuestro proyecto (para este
ejemplo use el prefijo dm), en el Application Template seleccionaremos entre el
menú la opción Java Application [Java,Swing] y pulsamos en Aceptar.
97
El resultado será el siguiente:
Para desarrollar una aplicación con una interfaz gráfica de usuario no podemos
descuidar la parte del modelado de clases principales que es la que nos proveerán
del conocimiento necesario que será necesario para desarrollar nuestra aplicación
como por ejemplo las clases persona, paciente, etc., realizaremos una aplicación
aplicando el Modelo Vista Controlador, realizaremos nuestro diagrama de clases
para esta aplicación.
98
Ahora damos un clic derecho en Client y seleccionamos la opción New…
En esta pantalla seleccionamos dentro de las categorías La opción Diagrams y
dentro de Ítems la opción Java Class Diagram y pulsamos Aceptar.
En esta pantalla pondremos un nombre a nuestro diagrama en Name y pulsamos
Aceptar. (Para este ejemplo el nombre del diagrama es DiagramaDM).
99
Ahora nos dirigimos a la paleta de componentes (Component Palete) y damos un
clic en Java Class
Ahora damos un click en cualquier parte del área para dibujar nuestro diagrama y
ponemos el nombre de nuestra clase, es este caso: Persona veremos que también en
el navegador nuestra clase persona ya creada.
Ahora damos dos clicks en la parte designada para atributos y nos aparece un mini
pantalla para escribir aquí los atributos como es una aplicación sencilla solo
pondremos un par de atributos como: nombres, apellidos, sexo, estado civil.
100
Ahora damos un click fuera del área de dibujo y luego damos doble click en Persona
y podemos ver nuestros atributos escritos, para generar los métodos accesores: Get y
Set de cada atributo, damos un click derecho en cualquier área limpia y
seleccionamos la opción: Generate Accessors…
Ahora seleccionamos todos nuestros atributos y pulsamos aceptar y podemos ver
como todos estos métodos aparecen ya codificados en nuestra clase.
Regresamos a nuestro diagrama y creamos en esta ocasión la clase Paciente y esta
clase será una clase hija de la clase Persona, para eso haremos uno de la flecha
Extends que nos provee la paleta y haremos un marcado desde la clase Paciente
hasta la clase Persona.
101
Ahora pondremos un par de atributos como: Observaciones y antecedentes.
Crearemos también la clase FichaMedica con los siguientes atributos: Numero de
Ficha y Paciente, observe como al momento de fijar el atributo private Paciente
paciente; se crea la relación entre las 2 clases : Paciente y FichaMedica.
102
Como en esta aplicación haremos que los datos posteriormente se guarden en un
archivo haremos que cada una de estas clases implemente la interfaz serializable de
la siguiente manera: dando click derecho en cada clase y seleccionando Source y
Luego Implement Interface… como se muestra en la figura adjunta.
Luego en la pantalla que se nos presenta escribir Serializable, en el momento de
comenzar a tipiar comienza a aparecer este nombre de interfaz en la parte inferior
pudiendo seleccionar el del paquete java.io y listo.
Ahora solo nos resta crear la clase ListaDeFichas la cual no poseerá constructor.
¿Por qué no crearemos un constructor para esta clase? Porque esta será la clase que
poseerá los métodos de : guardar, actualizar, abrir, eliminar, eliminar todos y
mostrar los elementos en una tabla, por ejemplo para guardar una FichaMedica
(ficha) nosotros crearemos una instancia de FichaMedica, a este objeto ficha creado
le asignaremos los datos de numero de ficha y paciente; datos que serán recogidos
103
de nuestra interfaz gráfica de usuario que la construiremos en breve; este objeto
ficha se almacenará de la siguiente manera: ListaDeFichas.guardar(ficha); entonces
no necesitaremos instanciar en cada momento la clase ListaDeFichas ya que
crearemos métodos estáticos para operar las fichas; entonces nuestra clase
ListaDeFichas tendrá un atributo estático del tipo Vector<FichaMedica> en el que
se operarán las fichas. Por el momento el cuerpo de esos métodos estarán vacíos
hasta que los necesitemos.
Nuestro diagrama quedará de la siguiente manera por el momento.
Para compilar y guardar todo lo que hemos hecho en esta clase daremos un click en
el icono a manera de dos disquetes o en cada clase daremos un click en el icono del
104
disquete o Ctrl+S; esta herramienta también nos provee de ayudas como: un
historial History con el cual podemos ver todos los cambios que ha ido sufriendo
nuestra clase, un Source en el cual podemos ver todo el código fuente de nuestra
clase y un Design en el cual se visualizará de una manera gráfica los componentes
de nuestra clase en caso que puedan ser vistos, esta ayuda nos servirá cuando
diseñemos nuestras clases java Swing (interfaces gráficas de usuario).
En esta pantalla dentro del Output Directory copia la línea justo hasta antes de que
comience el nombre de tu proyecto y pulsa Aceptar:
(Para mi caso copie: D:\Archivos de Programa\jdevstudio10131\jdev\mywork).
105
Posteriormente abre por ejemplo “Mi PC” y en la parte de Dirección tipea o copia la
dirección
antes
mencionada
“D:\Archivos
de
Programa\jdevstudio10131\jdev\mywork” da un enter y podrás ver a nuestro
proyecto físicamente.
106
Para importar una aplicación haremos los siguiente, nos dirigimos a nuestra carpeta
jdevstudio10131 donde se encuentra nuestro IDE luego vamos a la carpeta jdev y
por último a mywork y ahí pegamos la aplicación (si la aplicación la tenemos como
un archivo con extensión .zip o tar, rar , o cualquier tipo de formato que indique
compresión debemos descomprimir el archivo y pegar la carpeta resultante en esta
dirección).
Una vez hecho esto solo resta que el IDE lo reconozca dentro del Applications
Navigator para eso damos un click derecho en Applications y seleccionamos la
opción Add to Applications…
107
Seleccionamos el proyecto a importar y pulsamos Open y en la siguiente pantalla
seleccionamos el archivo con extensión .jws y pulsamos Open y listo ya estará
nuestra aplicación en el Applications Navigator lista para poder ser operada.
Nota: Este proyecto ha sido obtenido de Internet de la dirección:
http://indomable.wordpress.com/2007/11/04/aplicaciones-java-swing-conoracle-jdeveloper-101310-clase-1/
Nosotros los autores del manual, consideramos que este ejemplo incluido en el
anexo, sera de ayuda para los alumnos de nuestra Universidad Nacional de Piura por
lo que se incluye en este trabajo