TECNOLÓGICO NACIONAL DE MÉXICO

INSTITUTO TECNOLÓGICO SUPERIOR DEL

OCCIDENTE DEL ESTADO DE HIDALGO.
ING. EN SISTEMAS COMPUTACIONALES

4º ”A”

TÓPICOS AVANZADOS DE PROGRAMACIÓN.

UNIDAD 2

EVIDENCIA:
REPORTE DE PRÁCTICA:
CREAR UN COMPONENTE Y LIBRERÍA.

PRESENTA:
• 17011086 – AVENDAÑO SERRANO ALFREDO

DOCENTE:
MTRA. ALINE PÉREZ MARTÍNEZ

Portada
MIXQUIAHUALA DE JUAREZ, HIDALGO A 15 DE MARZO DE 2019.

1
Contenido
Portada .................................................................................................................... 1
Ilustraciones: ........................................................................................................... 2
Introducción: ............................................................................................................ 3
Desarrollo: ............................................................................................................... 3
1.- Realizar proyecto: ........................................................................................... 3
2.- Crear componente: ......................................................................................... 7
3.- Creación de librería: ...................................................................................... 13
Conclusión:............................................................................................................ 17
Bibliografía ............................................................................................................ 17

Ilustraciones:
Ilustración 1 - Ventana de NetBeans ejecutada. ..................................................... 3
Ilustración 2 - Pestaña para crear un nuevo proyecto en NetBeans. ...................... 4
Ilustración 3 - Opción para crear la Biblioteca de Clases de Java........................... 4
Ilustración 4 - Datos para la creación de nuestro proyecto. .................................... 4
Ilustración 5 - Proyecto exitosamente creado.......................................................... 5
Ilustración 6 - Creación del paquete con un JPanel. ............................................... 5
Ilustración 7 - Paleta con objetos que se utilizaran para crear la interfaz de la
calculadora. ............................................................................................................. 5
Ilustración 8 - Aspecto de una calculadora básica. ................................................. 6
Ilustración 9 - Pestaña para crear la extensión .JAR de nuestro proyecto. ............. 7
Ilustración 10 - Tiempo de espera para la creación de la extensión JAR ................ 7
Ilustración 11 - Creación del JFrame dentro del paquete del mismo proyecto. ....... 8
Ilustración 12 - Ventana para importar componente. ............................................... 8
Ilustración 13 - Creación de una nueva categoría. .................................................. 9
Ilustración 14 - Añadimos el archivo JAR desde su raíz. ...................................... 10
Ilustración 15 - Añadimos los componentes disponibles. ...................................... 10
Ilustración 16 - Selección de la nueva categoría creada. ...................................... 11
Ilustración 17 - Creación de la nueva categoría y del nuevo componente. ........... 11
Ilustración 18 - Arrastre de componente a un JFrame. ......................................... 12
Ilustración 19 - Funcionalidad del componente. .................................................... 13
Ilustración 20 - Creación de Java Main Class. ...................................................... 14
Ilustración 21 - Pasos para importar la librería ...................................................... 14
Ilustración 22 - Importar librería desde la raíz. ...................................................... 15
Ilustración 23 - Creación del objeto e instancia de la librería. ............................... 15
Ilustración 24 - Librería ejecutada desde código. .................................................. 16
Ilustración 25 - Funcionalidad de la librería ........................................................... 16

2
Introducción:
En esta práctica observaremos como podemos crear un componente en la paleta
de objetos del IDE de NetBeans de Java, para así solo arrástralo y usarlo cuando
sea necesario, crearemos desde el proyecto codificado hasta así exportarlo para
que así mismo se pueda crear una librería la cual utilizaremos el mismo archivo
extendido que se creó para crear el componente.

Desarrollo:
1.- Realizar proyecto:
1. Iniciando con nuestro proyecto para crear un componente y la librería, vamos
a iniciar abriendo NetBeans (Ilustración 1).

Ilustración 1 - Ventana de NetBeans ejecutada.

2. El siguiente paso que haremos, es crear un nuevo proyecto, pero no un

proyecto al cual estamos acostumbrados, al momento de darle clic en la
pestaña amarilla que se encuentra en la parte superior izquierda de nuestra
ventana de NetBeans (Ilustración 2), daremos clic en la opción que dice “Java
Class Library” (Biblioteca de Clases de Java), y daremos clic en el botón
“Next” (Siguiente). (Ilustración 3).

3
 Ilustración 2 - Pestaña para crear un nuevo proyecto en NetBeans.

Ilustración 3 - Opción para crear la Biblioteca de Clases de Java.

3. Una vez elegida la “Java Class Library” procedemos a darle un nombre a

nuestro proyecto, en este caso le daremos el nombre de “Calculadora”, en
seguida tenemos la opción de guárdalo en la ruta de nuestra elección, y
finalmente daremos clic en el botón “Finalizar” (ilustración 4).

Ilustración 4 - Datos para la creación de nuestro proyecto.

4
4. Una vez creado nuestro proyecto “Calculadora” (Ilustración 5), procedemos
a crear un nuevo paquete dentro del proyecto, en este caso al paquete lo
llamaremos “Base” y dentro de ese paquete procedemos a crear un “JPanel”
que tendrá el nombre de “calculadoraBasica” (Ilustración 6); este “JPanel” lo
utilizaremos para darle interfaz a nuestra calculadora.

Ilustración 5 - Proyecto exitosamente creado.

Ilustración 6 - Creación del paquete con un JPanel.

5. Una vez llegado hasta este punto, procedemos a abrir nuestro JPanel
haciendo doble clic sobre JPanel y procedemos a añadir los componentes
necesarios de nuestra Paleta (Ilustración 7) a utilizar en nuestra calculadora

Ilustración 7 - Paleta con objetos que se utilizaran para crear la interfaz de la calculadora.

5
En este caso haremos la utilización de:

1 JTextField: que hará el rol de la pantalla de resultados.

19 botones: repartidos en las siguientes funciones:
• 10 de los botones serán utilizados para los números existentes en una
calculadora básica (0, 1, 2, 3, 4, 5, 6, 7, 8 y 9).
• 1 botón tendrá la función AC que limpiará la pantalla.
• 1 botón tendrá la función de -/+ (convertir el numero a positivo o negativo).
• 1 botón tendrá la función DEL que borrará digito por digito.
• 4 botones tendrán la función de las operaciones básicas (+, -, * y /)
• 1 botón tendrá la función = que arrojará los resultados.
• 1 botón tendrá la función de punto decimal. (Ilustración 8).

Ilustración 8 - Aspecto de una calculadora básica.

6. Al tener nuestra interfaz de nuestra calculadora, procedemos a crear el .JAR

de nuestro proyecto; cabe destacar que él .JAR (Java Archive) es un tipo de
archivo que permite ejecutar aplicaciones y herramientas escritas en el
lenguaje Java. (Programación, 2005).

6
 Los archivos con esta extensión (.JAR) solo puede ser ejecutado en ciertas
aplicaciones, es posible que sea archivos de datos en lugar de los
documentos. (ReviverSoft, 2019).

Para proceder a crear el .JAR de nuestro proyecto, simplemente nos

dirigimos a la parte superior central de nuestro proyecto, damos clic en la
pestaña con figura de un martillo con un cepillo (Ilustración 9), y esperamos
unos cuantos instantes en lo que se crea nuestra extensión .JAR, el progreso
de la creación lo podemos ver en la parte inferior derecha de nuestra ventana
de NetBeans (Ilustración 10).

Ilustración 9 - Pestaña para crear la extensión .JAR de nuestro proyecto.

Ilustración 10 - Tiempo de espera para la creación de la extensión JAR

2.- Crear componente:

7. Una vez llegado hasta este punto, procedemos a crear nuestro componente.

7
Cabe destacar que los componentes son elementos que permiten brindar
una iteración con el usuario del sistema; cada componente corresponde a
una clase en Java. (Henao, 2013).

Lo primero que tenemos que hacer es importar nuestra extensión JAR, es

muy sencillo y lo haremos de la siguiente manera:

Crearemos un JFrame en el mismo paquete del mismo proyecto, en este

caso le colocaremos el nombre de “Componente” (Ilustración 11).
Una vez creado el JFrame, ahora nos dirigiremos a la parte superior central
de la ventana de NetBeans, buscaremos y daremos clic en “Tools”,
enseguida daremos clic en la opción “Palette” y seleccionaremos
“Swing/AWT Components” (Ilustración 12).

Ilustración 11 - Creación del JFrame dentro del paquete del mismo proyecto.

Ilustración 12 - Ventana para importar componente.

8
8. Nos dirigirá a una nueva ventana llamada “Palette Manager”, donde lo que
haremos en primer lugar será crear una nueva categoría para que ahí
guardemos nuestro componente nuevo, le daremos clic en “New
Category…”, nos mostrará una nueva ventana donde nos pedirá el nombre
de la categoría a crear, en este caso se le colocará “Calculadora” y damos
clic en “OK”. (Ilustración 13).

Ilustración 13 - Creación de una nueva categoría.

9. Una vez creada la nueva categoría, estaremos nuevamente en la ventana

“Palette Manager”, ahora daremos clic “Add from JAR… (Añadir JAR)” e
importaremos el archivo JAR que creamos hace unos pasos; el archivo JAR
suele alojarse en la carpeta del proyecto. (Ilustración 14) y daremos clic en
“Siguiente”.

9
 Ilustración 14 - Añadimos el archivo JAR desde su raíz.

10. Añadimos con un clic a los componentes disponible que aparecerá en la

ventana siguiente y daremos clic en “Siguiente” (Ilustración 15).

Ilustración 15 - Añadimos los componentes disponibles.

11. Seleccionamos la paleta de categoría que creamos hace un momento, en

este caso “Calculadoras” y damos clic en “Finalizar” (Ilustración 16).

10
 Ilustración 16 - Selección de la nueva categoría creada.

12. Observamos que efectivamente, se ha creado una nueva categoría en la

paleta de objetos y dentro de ella el componente nuevo de la calculadora
(Ilustración 17).

Ilustración 17 - Creación de la nueva categoría y del nuevo componente.

13. Ya creado el componente, ahora es solo cuestión de probar si en realidad

funciona nuestro componente, para ello utilizaremos el JFrame que se creó
con anterioridad y simplemente arrastramos el nuevo componente al JFrame
(Ilustración 18).

11
 Ilustración 18 - Arrastre de componente a un JFrame.

14. Efectivamente observamos que el arrastre del componente de un JFrame es

favorable, pero aún queda una prueba más, ejecutaremos el JFrame a donde
fue insertado el componente para ver la funcionalidad del componente con
sus operaciones básicas (Ilustración 19).

12
 Ilustración 19 - Funcionalidad del componente.

15. Hemos comprobado su funcionalidad del componente con las operaciones

básicas y el resultado nos es favorable.

3.- Creación de librería:

16. Para crear la librería de la calculadora, utilizaremos la extensión ya creada,
que es la extensión .JAR.

Cabe destacar que una librería en Java se puede entender como un conjunto
de clases que poseen una serie de métodos y atributos. Lo realmente
interesante de las librerías para Java es que nos facilitan muchas
operaciones.

13
 De una forma mas completa, las librerías nos permiten reutilizar código, es
decir, que podemos hacer uso de los métodos, clases y atributos que
componen la librería evitando así tener que implementar nosotros mismos
esas funcionalidades. (Programar Ya, 2019).

Para iniciar, en nuestro paquete “Base” de nuestro proyecto “Calculadora”

vamos a crear un “Java Main Class…”, en este caso le daremos el nombre
de “inicio” (Ilustración 20).

Ilustración 20 - Creación de Java Main Class.

17. Una vez llegado a este punto, nos dirigiremos a la parte de “Libraries” del
proyecto, le daremos clic derecho y seleccionamos la opción “Add
JAR/Folder…” (Ilustración 21) para importar nuestra librería, regularmente la
librería se aloja en la carpeta del proyecto. (Ilustración 22).

Ilustración 21 - Pasos para importar la librería

14
 .

Ilustración 22 - Importar librería desde la raíz.

18. Ahora nos dirigimos a nuestro “Java Main Class…” creado con anterioridad
y lo que vamos a hacer es crear el objeto de la paquetería e instanciarlo, de
esta manera haremos uso de la librería de nuestra calculadora. (Ilustración
23).

Ilustración 23 - Creación del objeto e instancia de la librería.

15
19. Una vez creado nuestro objeto y la instancia, procedemos a ejecutar el “Java
Main Class” para probar la funcionalidad de la librería. (Ilustración 24).

Ilustración 24 - Librería ejecutada desde código.

20. Comprobaremos la funcionalidad de la librería con las operaciones básicas.

(Ilustración 25).

Ilustración 25 - Funcionalidad de la librería.

16
 21. Podemos observar que el aspecto de la calculadora respecto a la original,
cambia en el tono de colores de los botones, esto lo hace diferente entre el
código fuente y una librería, además hemos comprobado su funcionalidad de
la librería con las operaciones básicas y el resultado nos es favorable.

Conclusión:
Con la realización de los componentes y las librerías, podemos concluir que la
realización de ellos es muy importante para nosotros como programadores, ya que
con ellos hacemos la reutilización de código, con esto evitamos líneas de código
que en algunas ocasiones puede confundirnos con la creación de clases llenas de
código que hasta en algún momento puede generarnos algún error; y con la
creación y utilización de componentes y librerías es una gran ventaja para nosotros.

Bibliografía
Henao, C. (1 de Septiembre de 2013). BlogSpot. Obtenido de Componentes Java Swing:
codejavu.blogspot.com/2013/09/componentes-java-swing.html?m=1

Programación. (2005). Obtenido de Ficheros JAR:

http://gpd.sip.ucm.es/rafa/docencia/programacion/tema1/jar.html

Programar Ya. (2019). Obtenido de Uso de librerias en Java:

https://www.programarya.com/Cursos/Java/Librerias

ReviverSoft. (2019). Obtenido de .JAR Extensión del archivo: https://www.reviversoft.com/es/file-

extensions/jar

17