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 19

2.1. Historia

2.2 Características

2.3. Ventajas

2.4. Interfaz principal

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 62

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

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

Java

• Cifre el redactor

• Cifre la

navegación

• Refactoring

• Oscilación

• Prueba de la

unidad

• Control de la

versión (sin

embargo, la

ramificación no es

apoyada por el

cliente interno de

CVS)

• Intervención y

métrica

• El eliminar errores

• El perfilar

• Ayuda de la

hormiga

• Ayuda de XML

• Abra el API y las

extensiones

• Ayuda del usuario

Edición de J2EE

• JSP

• Puntales

• JSF

• EJB

• TopLink

• Servicios del Web

• UML

• Desarrollo de la base de datos

• Despliegue y gerencia

•

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/jdev-

license.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 for-

loop 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 Size Bounds Text Horizontal Alignment

tooltipText

txUsuario JTextField 135,20 195, 65,

135, 20

Introduzca un

usuario valido

txPass JPasswordField 135,20 195, 90,

135, 20

Introduzca

contraseña

lbUsuario JLabel 55,20 Usuario: Right

lbPass JLabel 75,20 Contraseña: Right

btAceptar JButton 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 name Text Font JTextField txtgradosCelsius JTextField txtgradosFharenheit JButton btnCalcular Calcular 12,Dialog,Bold JButton btnSalir Salir 12,Dialog,Bold

La interfaz debe quedar

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-swing-

con-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-con-

oracle-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