Por:

Rafael Evelio Puerta Mejia

Ingeniero Informático
Contenido
PARTE 1. ............................................................................................................................................................... 3
MANUAL DE CREACIÓN DE UNA APLICACIÓN DE JAVA ESCRITORIO UTILIZANDO EL IDE DE PROGRAMACIÓN
NETBEANS. ........................................................................................................................................................... 3
PASOS PARA LA CREACIÓN DEL PROYECTO ........................................................................................................ 8
PARTE 2. ............................................................................................................................................................. 12
CÓDIGOS PARA NUESTRA APLICACIÓN DE ESCRITORIO .................................................................................. 12
PARTE 3. ............................................................................................................................................................. 25
PROGRAMACIÓN DE EVENTOS PARA LOS BOTONES ....................................................................................... 25
ENTIDAD ..................................................................................................................................................... 27
DAOS .......................................................................................................................................................... 34
PARTE 4. ............................................................................................................................................................. 41
INVOCACIÓN DE MÉTODOS DENTRO DE LOS BOTONES .................................................................................. 41
PARTE 1.

MANUAL DE CREACIÓN DE UNA APLICACIÓN DE JAVA ESCRITORIO

UTILIZANDO EL IDE DE PROGRAMACIÓN NETBEANS.

Para la creación de cualquier aplicación de java utilizando el IDE de programación

Netbeans se debe comenzar inicializando el programa, una vez inicializada la aplicación
procedemos a crear una nueva aplicación así:

Paso 1:

Presionamos el icono de nuevo se despliega la ventana new Proyect o proyecto

nuevo.
Paso 2:

Seleccionamos la categoría del proyecto, y escogemos java, y en proyecto

seleccionamos Java Application y presionamos el botón siguiente.

Paso 3:

En esta ventana que se nos despliega en la aplicación tenemos los elementos

siguientes:

 Nombre proyecto: en este cuadro de texto lo utilizaremos para darle un

nombre a nuestra aplicación, siguiendo los estándares para nombrar un
proyecto, com – comercial, edu – educativo, también el nombre del
proyecto debe ir separado por puntos o guiones, así ejemplo:
o com.Proyecto_Comercial.
o com.ProyectoComercial.
  Ubicación del proyecto: es la carpeta donde almacenaremos nuestro
proyecto y la ubicación del mismo dentro del disco duro o una memoria
USB, SD u otro dispositivo de almacenamiento.

 Carpeta proyecto: esta se nos crea automáticamente al seleccionar la

ubicación y el nombre del proyecto.

 Usar una carpeta dedicada para almacenar las bibliotecas: si tenemos

bibliotecas adicionales que requiera nuestro proyecto, diferentes a las que
ya por defecto trae el sistema como por ejemplo java.util.scanner, y
deseamos diferenciarlas de las que ya poseemos creamos una carpeta
adicional donde las tendremos para ser incorporadas más adelante al
proyecto.

 Crear clase principal: este elemento me permite crear o no un java.class,

que contendrá el método public static void main (String [] args) con el cual
el sistema compilará y ejecutará el código de programación de nuestra
aplicación.

Una vez terminado de ingresar el nombre y modificar los elementos que se deseen

procedemos a presionar el botón terminar y con esto ya nuestra

aplicación será creada por el IDE de Netbeans, el cual se encarga de crear las carpetas,
los paquetes necesarios y las clases para el inicio de la aplicación, además de cargar las
librerías básicas.
Cuando Netbeans termina de crear nuestro proyecto se abre la siguiente ventana:

En la cual podemos observar los siguientes elementos:

1. En la parte superior de la ventana podemos observar el nombre de la aplicación,

la barra de menú y el menú de iconos
2. Debajo de esta en la parte izquierda de la ventana podemos encontrar un menú
desplegable donde están ubicados como proyecto (Project), archivos (File) que
nos permitirán navegar dentro de nuestra aplicación y abrir o cerrar los
diferentes java.class que estemos trabajando en el momento

3. Hacia el centro de la ventana nos encontramos con el área de trabajo, en esta

área se abrirán los distintos java.class con los que estemos trabajando, es
también en este espacio donde podremos escribir el código para nuestra
aplicación.
PASOS PARA LA CREACIÓN DEL PROYECTO

Recordemos que para nuestra aplicación en particular estaremos trabajando el

modelo de aplicaciones MVC (modelo vista – controlador), este modelo en
particular establece que las aplicaciones se deben dividir en distintas capas estas
capas están compuestas principalmente por dos capas:

1. la capa de la vista: esta capa es donde estarán los distintos java.class que
serán utilizados para mostrar, acá estarán los JFrame que conformarán
nuestra aplicación.
2. La capa controladora: esta capa está conformada principalmente por los
java.class que contendrán los distintos métodos, procedimientos y funciones
que necesita la aplicación para funcionar, entre ellos tenemos los métodos y
funciones principales como las conexiones a las bases de datos, el abrir,
cerrar, leer y escribir en archivos de texto, los métodos del CRUD (créate,
read, update, delete) que podamos necesitar en nuestros proyectos.

Para crear estas capas en Netbeans debemos crear java paquetes o JavaPackage, estos
paquetes dentro de nuestro proyecto, se convertirán en carpetas, las cuales serán
utilizadas para almacenar los java.class necesarios para nuestro proyecto.

Para crearlos debemos ubicarnos sobre el nombre de nuestra aplicación en el cuadro

proyecto y darle clic derecho con el mouse en nuevo y seleccionando JavaPackage
Cuando hacemos esto se nos despliega una ventana donde podemos darle el nombre
a los paquetes así:

Es acá donde daremos nombre a las distintas capas que utilizaremos en nuestro
proyecto, quedando así nuestro proyecto:
Nótese que se han creado dos nuevos elementos un paquete vista y un paquete
persistencia, este último es donde colocaremos los java.class, que conforman la parte
del controlador. Inicialmente utilizaremos dos capas, pero en proyectos más
estructurados y más avanzados a los que estamos desarrollando existirán otras capas
adicionales a estas.

Ya con las capas creadas procedemos a crear los java.class necesarios para nuestra
aplicación de escritorio para ellos lo que tenemos que hacer es lo siguiente:

Nos ubicamos en el paquete vista, y presionamos el clic derecho del mouse y

seleccionamos nuevo – java class

Esto nos permite crear un archivo de java, el cual lo nombraremos guardando

los estándares de programación y las buenas prácticas para el nombramiento de
las clases de java.
Cuando hacemos esto se nos abre una ventana como esta

donde podremos nombrar nuestro java.class, para nombrar el archivo en este

caso como lo que vamos a crear son ventanas y estas ventanas a si ves tendrán
distintas funciones y para ayudar a quien revisa el código nombraremos los
formularios con las siglas frm – y el nombre del formulario, ejemplo:

frmFormularioVentas

si es una ventana lo nombraremos con la abreviatura vnt así:

vtnInicio --- vtnMenuPrincipal

una vez nombrado el java class con el nombre correspondiente a lo que vamos
a crear en el procedemos a escribir nuestro código.
PARTE 2.

CÓDIGOS PARA NUESTRA APLICACIÓN DE ESCRITORIO

Ya tenemos todo listo para empezar a crear nuestra aplicación, es en este momento
donde tenemos que escribir los códigos, comandos funciones, métodos y
procedimientos basados en el lenguaje de programación java que nuestra aplicación
necesitara. Para dar comienzo a esto lo primero que debemos hacer es crear un diseño
de lo que vamos a construir, esto con el fin de tener una guía o modelo para la creación
de nuestra aplicación, muchas veces este diseño inicial estará dado por una persona
que se encargó de levantar los requerimientos de proyecto que se llama el analista, el
cual da una visión inicial del proyecto y de las necesidades del cliente. En nuestro caso
nuestro cliente somos nosotros mismos, aunque el objetivo de esta aplicación es poder
brindar un programa que solucione un problema matemático.

El diseño lo podemos crear a mano o a través de aplicaciones de dibujo.

Ahora si empecemos con los códigos.

Para crear nuestras ventanas y formularios lo que debemos hacer una vez tenemos
listo el java.class es empezar a agregar códigos el primer código que debemos agregar
es el siguiente:
Agregamos la sentencia extends JFrame esta nos permite crear una extensión de la
clase JFrame que es la clase donde se encuentran todos los métodos para crear una
ventana, esta clase pertenece a la librería swing de javax.

Ya una vez agregada esta línea a nuestra ventana podemos ir a nuestro java.class donde
tenemos el método main, que previamente fue creado por el IDE de Netbeans y
agregamos el código con el cual podemos ver nuestra ventana en ejecución asi:

Primero creamos el objeto tipo ventana openVentana, luego hacemos uso de una de
las funciones del objeto y es hacerlo visible con setVisible(true).
Listo ya tenemos la primera ventana de nuestra aplicación ahora vamos a ponerle los
elementos necesarios en nuestro caso vamos a hacer una ventana con los siguientes
elementos:

 Un escritorio donde colocaremos los elementos de la ventana (DesktopPane).

 Unos label o etiquetas.
 Unos campos de texto o textField, de ser necesario y si se necesita un
passwordField si necesitamos contraseña.
 Un panel para contener los campos de texto y etiquetas.
 Botones.
 Imágenes para decoración de los label y los botones.
Identificados los elementos a utilizar en nuestro código los tenemos que declarar;
proceso en el cual le decimos a java que vamos a usar unos elementos que van a estar
en nuestra java.class, así como veremos a continuación:

Una vez que has declarado los distintos elementos, como ya lo hemos indicado
anteriormente respetando los estándares de programación.
El siguiente paso en la creación de nuestra ventana es la construcción de la ventana
para ello utilizaremos un elemento de las clases de java que se denomina el constructor
Dentro del constructor lo primero que debemos hacer es establecer algunas
propiedades las cuales nos van ayudar en la visualización y el funcionamiento de la
ventana, realizado esto debemos establecer ya los elementos de la ventana, para ello
existen varias formas de hacerlo acá dos formas la primera es coger cada elemento y
establecer primero construir el elemento, darle las propiedades (color, tipo de letra,
tamaño de letra), fijar el elemento al panel, o ventana o escritorio según sea el
elemento, y por ultimo darle un tamaño al elemento y ubicarlo en una posición; esta
posición está formada por 4 elementos: x, y, width, height, las dos primeras x & y son
la ubicación en la pantalla según el plano cartesiano invertido de la ventana.

Los otros dos elementos width y height son el ancho y el alto del elemento.
Una vez realizado esto el resultado que veremos es el siguiente:
La otra forma en la cual podemos crear los elementos dentro del constructor de
nuestra ventana es el siguiente:
1. Definir cada objeto creándolo con la instrucción = new, y el tipo de elemento
que estamos creando ejemplo:
btnAceptar = new JButton(“Aceptar”);
2. Definir las propiedades de cada elemento ya sea tipo de letra, forma y tamaño
como el color del elemento cada uno en secuencia según la cantidad de
elementos que se posean ejemplo:
lblnombre.setForeground(Color.red);
lblnombre.setFont(new java.awt.Font("Tekton Pro Cond", 1, 14));
3. Una vez establecidos las propiedades de los elementos y sus propiedades
agregamos todos ellos al panel, al escritorio o a la ventana directamente asi:
add(lblNombre);
4. Por ultimo ubicamos los elementos dentro del panel, escritorio o ventana y le
proporcionamos un tamaño a este según sea el elemento o el diseño que
tenemos así:
lblnombre.setBounds(20,20,150,30);
Nótese que en la imagen anterior tenemos un error en una línea de código esto sucede
porque tenemos un elemento que no debe ir y es el siguiente:

Dentro de los paréntesis tenemos unas palabras Icono – o imagen, estas nos están
diciendo que en este espacio debemos tener un objeto con una referencia a una
imagen o un icono, esta imagen debe ser declarada y creada previamente al llamado
de esta línea de código donde lo vamos a utilizar.

Ahora vamos a insertar y manejar imágenes en nuestros elementos, para insertar una
imagen tenemos que hacer lo siguiente:
1. Debemos crear una carpeta o folder dentro de nuestro proyecto que servirá de
repositorio o almacenaje para nuestras imágenes asi:

Sobre el paquete fuente o source package damos clic derecho con el mouse,
luego en nuevo y buscamos folder o carpeta, en caso de que no lo encuentres
en la lista debes seguir la siguiente ruta:
Nuevo – otros, cuando le demos demos clic izquierdo se nos abre una ventana
en la cual podemos buscar el folder,

Cuando lo encuentres, que se encuentra al final de la lista de categorías y casi al

final de tipo de archivos, lo debes seleccionar y presionar el botón siguiente

lo que nos llevaría a la siguiente ventana donde le daremos el

nombre al folder y para terminar le damos clic en el botón terminar

La carpeta o folder que contendrá las imágenes la llamaremos Image.

2. Con la carpeta creada debemos guardar en la carpeta las imágenes que vamos a
tener para la aplicación, estas imágenes deben ser en formatos de imágenes
como lo son las JPG, GIF, PNG. En su gran mayoría las imágenes se encuentran
en estos formatos, para ingresar las imágenes a la carpeta, lo que debemos hacer
es lo siguiente:
a. Abrir la carpeta del sistema donde se encuentran las imágenes, ya sea en
el disco duro, una memoria USB, una memoria SD o un disco externo.
b. Seleccionar los archivos ya sea con el mouse o con el teclado, si es con el
teclado presionamos ctrl + c, para copiar los elementos.
c. Si seleccionamos los elementos con el mouse arrastramos los elementos
sin soltar el botón izquierdo del mouse y lo llevamos a Netbeans donde
los vamos a soltar sobre la carpeta o folder recién creada.

3. Ya con las imágenes cargada en nuestra carpeta podemos proceder a llamarla

por líneas de código dentro de nuestra aplicación, para trabajar con una imagen
existen varios comandos, estos dependen de la finalidad de la imagen, en
nuestro caso vamos a colocar una imagen en un botón y/o en un label o etiqueta.
Esto se hace con el comando Icon, este nos permite crear un objeto de tipo
icono, que lo podemos agregar ya sea a un label o a un botón.

 Icon: comando para crear un objeto tipo icono

 icoImagenlabel: nombre del objeto
  ImagenIcon: librería para el manejo de imágenes.
 getClass (): “El método getClass () se encuentra definido en Object como
un método final, dicho método devuelve una representación en tiempo de
ejecución de la clase del objeto sobre el cual podemos acceder a una serie
de características del objeto, por ejemplo: el nombre de la clase”. 1
 getResource (): esta instrucción nos devuelve la URL del archivo en forma
de ruta donde está ubicado el recurso que estamos utilizando.
 “/Image/LogoPoli.png”: nombre y ruta del recurso que vamos a convertir
en icono para ser colocado en los JLabel o los JButton.

4. Con este código listo ya podemos corregir el error antes enunciado de la

siguiente manera:

De esta forma le asignamos un objeto tipo icono a un objeto tipo JLabel, en este
caso al objeto lblImagen, que dentro de nuestra aplicación será una decoración
para el formulario de inicio y contendrá en él, el logo de institucional de la
universidad

5. Para agregar un icono a un Jbutton lo que tenemos que tener presente primero
es que se llama exactamente igual que hicimos para el JLabel, y debemos agregar
el elemento en la siguiente línea de código:

btnAceptar: nuestro botón.

1
Texto extraído de la página web https://mundosica.com/el-metodo-getclass-explicacion-y-uso-practico-construyendo-
librerias-en-java-i/
 JButton (“Aceptar”, icoBtnAceptar), acá tenemos dos partes en esta instrucción
una parte la que está en comillas será el nombre que visualizaremos en el botón
cuando ejecutemos la aplicación y la segunda es el nombre del icono o imagen
que le colocaremos al botón para adornarlo. En ciertas ocasiones no es necesario
colocar el nombre al botón ya que el icono es lo suficientemente especifico de
la función para la cual se utilizó el botón.

6. Como vemos en la imagen, los botones ya aparecen en nuestra aplicación, pero

se ve una imagen y se ve un texto, parte de él, esto se debe a que por defecto el
lenguaje Java nos coloca los elementos uno después del otro alineados de
izquierda a derecha, pero esto se puede ajustar con la ayuda de unas
propiedades propias de los botones y son las de alineación de elementos y de
alineación de textos.

Para la alineación de los iconos y los textos dentro de los botones los comandos
son los siguientes:
Como se puede observar para el ajuste de los elementos dentro de los botones
se requiere de tres comandos ellos son:
 setHorizontalTextPosition.
 setVerticalAlignment.
 setVerticalTextPosition.
Estos tres comandos nos permiten el ajuste del texto y a alineación en dos ejes
vertical y horizontal, las alineaciones que tenemos disponibles son:
 TOP
 BOTTOM
 LEFT
 RIGHT
 CENTER
Básicamente tenemos estas 5 opciones para la alineación de los elementos
dentro de los botones, cabe anotar que esta alineación de texto y de imágenes
se pueden aplicar a otros elementos pertenecientes a las librerías Swing y awt,
que son las que nos permiten colocar elementos gráficos al formulario.
El resultado que obtenemos luego de incluir estas propiedades a nuestros
botones es la siguiente:

Como podemos ver nuestra ventana va cogiendo forma, todo esto gracias a las
propiedades únicas de cada elemento que nos permiten cambiar los aspectos
físicos de cada una de ellas. Para esta ventana lo único que nos queda faltando
 es colocar los campos de texto JtextField y JPassword, que serán los elementos
donde los usuarios de la aplicación podrán escribir textos. Para colocar los
campos de textos tenemos los siguientes comandos:

1.

2.

3.

4.
5.
6.

1. Creamos los objetos.

2. Propiedades del texto, cambio del color del campo de texto.
3. Propiedad de la fuente, tipo de fuente, estilo y tamaño.
4. Propiedad de color de fondo.
5. Adicionamos los objetos al panel, escritorio o al JFrame.
6. Ubicamos y damos tamaño a los objetos.
Cuando hemos terminado de digitar estos comandos el resultado final es el siguiente:

Ya tenemos terminada nuestra ventana en su parte visual, como vemos tenemos

en ella un escritorio de color gris oscuro, un panel de color negro, dos JLabel de
color rojo, dos JtextField de color gris claro y color de letra blanco, dos botones
con un icono y un texto y por ultimo un JLabel con una imagen dentro de ella.

Como hemos visto hasta el momento esto son los pasos iniciales para crear una
ventana utilizando comandos básicos en Netbeans, pero hasta el momento solo
es visual, si tratamos de presionar alguno de los botones ellos no van a funcionar,
ya que para que esto suceda debemos agregar unos métodos y funciones que
nos permitirán ejecutar acciones con los botones, como sus nombres lo indican
por ejemplo el botón cancelar le debemos agregar una instrucción que nos
permita cancelar la ejecución de la ventana y salir de la aplicación, y el botón
aceptar le vamos agregar una instrucción que me permitirá evaluar que el texto
que escribamos en los campos de texto sea igual a una que tengamos
almacenada ya sea en una archivo de texto o bien en una base de datos o los
tengamos definidos estáticamente dentro de nuestras líneas de código.

Para nuestra ejecución del programa los datos para la verificación de contraseña
estarán almacenados en un archivo de texto plano o un .txt, llamando
Usuario.txt
PARTE 3.

PROGRAMACIÓN DE EVENTOS PARA LOS BOTONES

En esta parte del manual veremos cómo programar los eventos que nos llevaran
a que nuestros botones ejecuten acciones que indiquemos, desde ejecutar un
cierre o salida del sistema, operaciones matemáticas o llamados a funciones o
métodos complejos.

Para poder empezar con esta parte de la aplicación primero debemos crear un
nuevo java.class, este en articular nos permitirá tener métodos y funciones con
las cuales vamos a negociar datos de nuestra clase, la clase usuario, una de las
funciones que tendremos es la función validar usuario esta función tiene como
objetivo recibir dos valores un usuario y un password, verificar si estos valores
coinciden con los valores almacenados y retornar una respuesta de verdadero
(true) cuando son encontrados o de falso(false), cuando no se encuentran o
alguno de los dos está errado.

Para comenzar a crear el java.class haremos lo siguiente, nuevamente iremos al

panel de proyectos, allí nos pararemos en el JavaPackage que tenemos aun vacío
que es el de persistencia, ya previamente habíamos enunciado que este paquete
hace parte del controlador ósea la parte donde se harán las transacciones de los
datos y la información. Este nuevo archivo tendrá como nombre DAOS, que
viene de las siglas DAO (Data Access Object) u objeto de acceso de datos, que
como lo digimos es la capa encargada de la persistencia de los datos o la
negociación de ellos.
Como vemos así nos queda la nueva clase creada en el sistema.

Para empezar a crear el DAOS, debemos tener presente que es lo que vamos a
trabajar, si van a ser datos almacenados temporalmente en arreglos, si los datos
vienen de un archivo de texto o los datos están almacenado en una base de
datos. Para nuestra aplicación los datos están almacenados en un archivo de
texto plano.
Lo primero que haremos será crear un arreglo que será el que me permitirá
manipular los datos que tenemos almacenados en el archivo, acá tendremos que
hacer un paréntesis en la explicación del DAOS, ya que para que esto nos
funcione debemos crear un segundo Java.class dentro de la carpeta persistencia,
este archivo tendrá la estructura de los datos de la clase usuario, me explico es
aquel que tiene los métodos y las funciones con los que transportaremos los
datos de un lado a otro (métodos Get y Set), tendremos un método llamado
ToString con el cual crearemos un patrón para el almacenaje de los datos dentro
del archivo de texto. Igual que como hicimos con las clases anteriores agregamos
un java.class que se llamara Entidad Usuario(EntUsuario).
ENTIDAD

Dentro de este archivo tendremos las variables, estas variables son las que me
van a almacenar los datos dentro de la entidad, para nuestra aplicación vamos a
usar las siguientes:
 String Usuario.
 String Password.
 String Nombre.
 String Cedula.
 String Email.

Estas variables las tenemos que declarar como privadas que sea solo la clase
entidad la encargada de su administración, cabe resaltar que para este ejemplo
las variables son del mismo tipo, todas son de tipo String o cadena, pero también
pueden ser de otros tipos de datos, según sea nuestra aplicación o formulario
que estemos creando, también parte de los requisitos y requerimientos que nos
establezca el cliente de la aplicación.

Una vez creadas las variables de entorno de la entidad procedemos a crear los
elementos con los cuales vamos a manejar esas variables. Para ello necesitamos
los constructores ellos nos permitirán ver los métodos y las funciones de la clase
entidad desde otras clases el primer constructor es un constructor que no tiene
ninguna función o método dentro de este constructor vacío es el que nos
permite invocar los otros métodos y funciones. Y tenemos el constructor con
variables que es el encargado de recibir los valores de los archivos y
estructurarlos para poder manipularlos en otras clases. Para crear los
constructores tenemos dos métodos uno es escribir las líneas de código con las
instrucciones del constructor y la segunda y recomendada es dejar que Netbeans
nos de una mano con estas líneas de código. Ello lo hacemos ubicándonos dentro
de la clase con el puntero del mouse y presionando el clic derecho

Una vez que realizamos esta acción se nos despliega una ventana como podemos
ver en la imagen anterior, es acá donde nos encontramos con una opción de este
menú secundario y es la opción de Insert Code, cuando presionamos con el
mouse con el clic izquierdo se nos despliega esta pequeña ventana

Ahí encontraremos unas opciones que necesitaremos para este Java.class que
estamos trabajando. La primera de la lista que tenemos es Constructor… ahí
presionamos y se nos despliega la siguiente ventana

Si declaramos bien las variables en esta ventana podrás ver que nos aparecen
todas las que declaramos con su respectivo tipo. Para el primer constructor
vamos a dejar en blanco cada uno de los check list o check box de la ventana y
presionamos en el botón Generate y lo que sucede es que Netbeans
nos genera un código que se ve de la siguiente manera:
Este primer constructor como lo mencionamos antes nótese que no posee nada
dentro de su estructura solo se abren y se cierran las llaves sin ningún otro código
o instrucción dentro de él.
El segundo constructor se crea de la misma manera, pero a cambio del primero
esta vez sí seleccionamos todos los check box de la ventana y generamos el
código.

Quedando así:

Ya tenemos nuestros dos constructores, pero aun no terminamos con nuestro

Java.class, la entidad tiene unos métodos y funciones que su tarea básicamente
es la de captura y envió de información estos métodos son los métodos Get y
Set, que ya habíamos previamente mencionado, acá veremos que significan cada
uno de ellos.

1. Método Get: es un método que permite obtener un valor de una posición

dada.
2. Método Set: es un método que permite cambiar un valor de una posición
dada.
son estos los métodos que nos van a permitir mover los datos de la entidad
usuario, para esto debemos insertar los códigos del get y set como hicimos con
los constructores, una vez que presionamos el clic derecho se nos despliega la
ventana donde seleccionamos Insert Code, y luego de esto en la ventana que se
nos despliega seleccionamos getters and setters

Cuando presionamos en este menú se nos despliega una ventana donde

seleccionaremos los getters y setters que vamos a utilizar.
Cuando hacemos esto se nos genera un código como el siguiente:

Ya estamos un paso más cerca de terminar la entidad, lo último que nos queda
es agregar un método que nos va permitir crear una plantilla para guardar y leer
los datos en el archivo, este método es el método ToString, para agregarlo
tenemos que proceder de igual manera como venimos haciendo los anteriores
métodos y el constructor.

En este caso en particular Netbeans de una vez nos ofrece ya los campos
seleccionados para la creación del ToString solo hace falta que presionemos el
botón Generate y listo, Netbeans nos crea una plantilla.
Esta plantilla que nos genera tiene información extra que vamos a depurar para
que nos quede un código de la siguiente manera:
 Antes:
  Después:

Como pueden ver ya tenemos terminado la entidad ahora proseguimos con la

creación de los métodos y funciones del DAOS.

DAOS

1. Debemos crear un arreglo que va contener la entidad, este arreglo es de tipo

java.class entidad, es en este arreglo donde vamos a tener los datos que
extraemos de los archivos para poder manipularlos según sea la necesidad,
para este arreglo necesitamos definir un tamaño proporcional al tamaño del
archivo y de la cantidad de datos que se van a almacenar.

Luego ahora si creamos el arreglo de tipo prívate, con el fin de proteger los datos
que no sean vistos o manipulados por otro java.class, quedando así:

Debemos crear un contador ya que este arreglo debemos recorrerlo y también

debemos saber cuántos datos tenemos en el arreglo así:

2. Proseguimos con la creación del constructor que será el método con el cual
llamaremos al DAOS desde los demás java.class de nuestra aplicación para
poder hacer uso de los distintos métodos quedando así:
 Se puede observar que te dentro del constructor tenemos un método que es
el cargarUsuario que es el método que nos permite abrir el archivo y
almacenarlo temporalmente para manipular los datos del mismo.

3. Creamos el método CargarUsuario, este método como se mencionó en el

constructor nos va permitir cargar el archivo, el archivo se encuentra
normalmente en una ubicación dentro de la carpeta del proyecto, este
archivo es de extensión txt o archivo de texto plano, este método se debe
crear para cada entidad que creemos en nuestra aplicación, empecemos con
este método:
a. Primero creamos los objetos para la manipulación de los archivos, para
leer los archivos y para crear un almacenamiento temporal llamado
buffer así:

Como estamos trabajando con un archivo de texto que está en el

sistema, se nos puede presentar algunos errores para ello debemos
utilizar una estructura propia del lenguaje java, que es el try / catch,
esta estructura nos permite controlar los posibles errores que se
presenten al momento de la ejecución del método o función en el
bloque try se colocaran las instrucciones que se deben realizar a pesar
de la excepción y en el catch colocamos las acciones que debemos
tener en caso de que suceda la excepción.
b. Con el bloque try/catch establecido empezamos a llamar los objetos de
los archivos y creamos las variables donde traeremos los datos desde
el archivo para luego ser llevados al arreglo, también creamos unas
variables que nos permitirán controlar la transferencia de los datos de
esta manera:
c. Continuamos con la creación de un ciclo mientras, que nos va a
permitir extraer todos y cada uno de los datos almacenados dentro del
archivo; acá es importante recordar que los datos dentro del archivo
están organizados según el modelo que establecimos en el ToString de
la entidad, para este ciclo utilizaremos una variable de control y una
propiedad de la misma, la variable es línea, y ella la igualamos al objeto
br, y a su propiedad readLine esto lo evaluamos y verificamos que sea
diferente de null así:

d. Dentro del mientras ya procedemos a sacar línea a línea los datos del
archivo a la variables esto lo debemos hacer para cada uno de los datos
esto lo tenemos que hacer en 4 pasos, el primero es pos, es acá donde
establecemos el final de la línea que vamos a leer esto lo hacemos con
el carácter | pipe,
Luego leemos la línea, esta línea es un subString o sub línea de la línea
completa y lo llevamos a una variable temporal que llamamos aux

Con los datos en el aux los llevamos a la variable

por ultimo debemos avanzar a la subString siguiente
 Finalmente, esto lo debemos repetir para cada una de las variables que
hayas declarado y para cada uno de los elementos que tenemos dentro
de la entidad y el archivo.
e. Con el paso anterior completo pasamos a cargar los datos en el arreglo,
contar el dato obtenido y finalizar el ciclo

Para poder hacer esto como vemos creamos un objeto tipo entidad
que tiene la estructura de los datos que obtuvimos con la lectura de los
subString y los llevamos al arreglo que creamos al principio del DAOS,
y por ultimo contamos cuantos llevamos con el contador en este caso
el contador de usuarios siempre que ejecutemos el ciclo las veces que
sean necesarias al contador por cada ves que pasemos se le adiciona
más 1.
f. Ya para finalizar este método tenemos el catch el manejo de las
excepciones, y tenemos un elemento adicional que es la acción final o
el finally en esta parte tenemos una acción que es intentar cerrar el
archivo que abrimos previamente, ya que los archivos abiertos pueden
causar fallos o sufrir daños a su estructura

Lo último que debemos hacer es verificar que no nos quede faltando

ninguna llave de cierre porque se puede presentar fallo en la ejecución
del método.
Como vemos hasta el momento ya tenemos creado un par de métodos dentro de
nuestro java.class DAOS, con estos cargamos el archivo y creamos el arreglo, aun nos
faltan unos métodos más que nos ayudaran con nuestra aplicación.
4. Función validarUsuario: este método me permite validar con los datos
almacenado en el archivo con los datos que se van a ingresar desde la ventana
de inicio. Esta función es llamada desde el botón aceptar en la ventana inicio,
que le entrega dos valores, un usuario y una clave o password que de verifican
y devuelven un true si los datos concuerdan con los almacenados y un false
en caso de que no se encuentren o uno de los dos valores de la combinación
no concuerde

Ahora tres métodos utilitarios antes de crear los métodos y funciones del
CRUD.
5. getNumeroUsuarios: retorna un contador de usuarios.
getUsuario: retorna un arreglo.
posicionUsuario: retorna la posición dentro del arreglo de un usuario o valor
especifico o me retorna un -1 si el valor no es encontrado
6. Función nuevoUsuario: esta función me permite crear un nuevo dato dentro
del archivo siempre y cuando no se haya alcanzado el número máximo de
elementos dentro del arreglo

7. Función modificarUsuario: esta me permite cambiar uno o varios valores

dentro de dato del arreglo,

Esta función recibe la posición del dato en el arreglo, y un arreglo de datos,

que van a ser modificados en la estructura del archivo.
8. Función eliminarUsuario: esta recibe un parámetro con el cual se va a buscar
eliminar el registro deseado del arreglo de datos y del archivo.
9. Método grabaUsuarios: este método me permite hacer que los datos que
tenemos en el arreglo y en el buffer temporal se graben en el archivo de texto
plano, este método lo podemos llamar ya sea cuando cerremos la ventana, o
cuando cerremos la aplicación, con el fin de que los cambios realizados y los
elementos ingresados nuevos se guarden en nuestro archivo.

Ya con este último método terminamos la creación del DAOS, para el usuario,
si tenemos más ventanas de datos que necesite de manejo de datos o tenga
un CRUD, los debemos hacer acá en el DAOS.
PARTE 4.

INVOCACIÓN DE MÉTODOS DENTRO DE LOS BOTONES

Parte de nuestro trabajo de programación es hacer que los distintos elementos

funcionen, en este momento es el caso de los botones, los botones son elementos
utilizados para efectuar acciones al ser presionado o accionado, estos elementos
tienen eventos que nos permiten ejecutar códigos de acciones.
Lo primero que debemos hacer es invocar el evento del botón, este evento es el
ActionListener este evento en particular lo que hace es escuchar una acción que se
produce al presionar el botón con el puntero del mouse en él, para invocar el evento
se hace de la siguiente manera:

Como vemos en esta imagen el evento es sencillo, dentro del evento que se le adiciona
al botón con la instrucción addActionListerner, crea un nuevo objeto de tipo
ActionListener, este objeto es una función pública que no retorna valores y que ejecuta
una función, llamada validarUsuarioActionPerformed, con el cual se ejecutara un
código el cual capturara los datos escritos en los campos de texto y enviara estos
valores al método validarUsuario, para realizar esto debemos invocar el método que
está en el DAOS, esta acción la hacemos hacemos primero creando un objeto de tipo
java.class DAOS que se va llamar mis Datos, con esto podemos llamar todos los
métodos y funciones que tenemos dentro del DAOS
Ya con la función lista podemos crear la función validarUsuario, este es el que nos va a
permitir como ya lo enunciamos anteriormente validar que los datos ingresados en los
campos de texto sean los mismos que tengamos almacenados en el archivo de texto
plano esta la creamos de la siguiente manera:

Esta función tiene los siguientes elementos:

1. Un condicional donde se llama la función validarUsuario, a la cual se le entregan
los datos de los campos de texto mediante las instrucciones getText y
getPassword, estas son las encargadas de capturar los datos escritos en los
campos de texto.
2. La condicional evalúa si no se cumplen, ósea que los datos ingresados no
concuerden con las duplas de datos almacenados en el archivo, eso quiere decir
que tanto el usuario y el password sean los mismos que estén almacenado y que
el password sea el que corresponda al usuario, si esto se cumple, que la función
me retorna un false, se despliega una ventana con un mensaje informando que
los datos no concuerdan con los datos almacenados, haciendo un return como
punto de control de que si no retorna un true la función no se puede proseguir.
 3. Si la función retorna un true el condicional se deja de ejecutar, y da paso a que
podamos invocar la ventana y enviamos los valores y el objeto DAOS a la
siguiente ventana para poder utilizar los métodos del DAOS.

Cuando ya se ha creado este código, lo único que nos falta es llevarlo a funcionamiento,
pero antes de que podamos ejecutar la aplicación con éxito debemos agregar un código
más a nuestra aplicación y es en el java.class que invoca el método main, es acá donde
debemos agregar un objeto de tipo java.class DAOS

Ahora si ejecutamos la aplicación, pero sin antes olvidarnos que debemos crear en la
carpeta del proyecto el archivo de texto plano donde tendremos los datos del usuario
que nos van a ayudar a ejecutar nuestra aplicación.

Como vemos los datos almacenado en el archivo cumplen con la estructura que
establecimos en el java.class entidad, en el método ToString con esto aseguramos que
la captura de los datos y la inserción de nuevos datos se haga de acuerdo al parámetro
que fue establecido.