Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Crear Librería en Netbeans - Tópicos Avanzados de Programación
Crear Librería en Netbeans - Tópicos Avanzados de Programación
4º ”A”
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).
3
Ilustración 2 - Pestaña para crear un nuevo proyecto en NetBeans.
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.
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:
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).
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).
Ilustración 11 - Creación del JFrame dentro del paquete del mismo proyecto.
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).
9
Ilustración 14 - Añadimos el archivo JAR desde su raíz.
10
Ilustración 16 - Selección de la nueva categoría creada.
11
Ilustración 18 - Arrastre de componente a un JFrame.
12
Ilustración 19 - Funcionalidad del componente.
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).
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).
14
.
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).
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).
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
17