Netbeans PDF

Netbeans con tendencia a
aplicación web
Héctor Erick Oscátegui Torres Desarrollo del libro

Corrección de estilo
Liz Capcha Villanueva
© Pontificia Universidad Católica del Perú - InfoPUC, 2012.
Avenida Universitaria 1801, Lima 32
Teléfono: (511) 626-2000/ anexo 3763 - 2603
Telefax: (511) 626-2885
Correo electrónico: infopuc@pucp.edu.pe
Página web: http://infopuc.pucp.edu.pe/
Derechos reservados. Prohibida la reproducción de este libro por cualquier

medio, total o parcialmente, sin permiso expreso de los editores.
La información puesta a disposición a través de las referencias bibliográficas

(páginas electrónicas, blogs, videos y audios) y todo material digital externo al
presente libro puede sufrir variaciones en el tiempo. El InfoPUC no asume
ningún tipo de responsabilidad por la disponibilidad de las fuentes, ni por las
modificaciones que la información haya podido sufrir.
Las marcas registradas son propiedad de sus respectivas compañías.
Esta publicación ha sido producida empleando Microsoft Office Word.
Las siguientes marcas son de propiedad exclusiva de la Pontificia Universidad

Católica del Perú y se encuentran registradas ante el INDECOPI, queda prohibida
su utilización en cualquier medio sin previa autorización escrita de la
Universidad.
®
®
®
Netbeans con tendencia a aplicación web
“Netbeans con tendencia a aplicación web”
TABLA DE CONTENIDOS:
ACTITUDES Y
CAPACIDADES ESPECÍFICAS DURACIÓN
VALORES
NOMBRE DEL
CONTENIDOS
CAPÍTULO 1 Comprensión e Indagación y Juicio crítico Creatividad  Se muestra
información experimentación participativo
en el
Capítulo 1:  Comprende lo que  Desarrolla las  Es consciente  Explora las desarrollo
es un IDE. actividades de las ventajas característi de la clase.
Introducción a 1.1 Introducción a Netbeans.
propuestas en la de utilizar un cas de
Netbeans  Entiende la noción
1.2 Instalación de Netbeans clase y en el libro IDE de Netbeans
de proyecto. de texto. desarrollo para buscar  Desarrolla
1.3 Entorno de aplicación avanzado. que su de manera
 Comprende el  Es capaz de crear trabajo sea responsable
1.4 Noción de proyecto proceso de sus propias más rápido las
Netbeans ejecución y estructuras de y eficiente. actividades
depuración de un paquetes de
1.5 Creando nuestra primera propuestas
proyecto. acuerdo a la
aplicación Java con Netbeans en la clase y
lógica de su en el libro
1.6 Compilación y ejecución aplicación de texto.
de un proyecto 6
1.7 Depuración e inspección semanas
de un proyecto
1.8 Creando nuevas clase,
paquetes e interfaces
Ejercicio práctico: Creación de
dos nuevas clases, Usuario y
Utils, y renombrado de
paquetes.
Ejercicio propuesto: Creando
un nuevo proyecto para una
aplicación de conversión
¿Cuánto aprendí?
Preguntas de revisión
3
ACTITUDES Y
VALORES
NOMBRE DEL
CONTENIDOS
CAPÍTULO 2 Comprensión e Indagación y Juicio crítico Creatividad  Muestra
información experimentación actitud
participativa
Capítulo 2:  Comprende el  Desarrolla las  Reconoce  Utiliza la durante el
concepto de bases actividades cuáles son las vista de BD desarrollo de
Manejo de 2.1 Concepto y creación de
de datos. propuestas en ventajas y de la clase.
bases de javadocs
clase y en el libro desventajas Netbeans
datos
2.2 Instalación de MySql de texto. de utilizar para
 Comprende cómo Netbeans realizar
2.3 El administrador de bases  Valora la
interactúa como operacione
de datos de Netbeans tecnología
Netbeans con las administrado s de
como un
Ejemplo práctico: Creando una bases de datos. r de base de diferentes
recurso para 4 semanas
sencilla aplicación que obtenga datos. tipos sobre
mejorar
los registros de una base de una base
trabajos
datos de datos.
académicos.
Ejercicio propuesto: Creando la
tabla de profesores
¿Cuánto aprendí?
4
ACTITUDES Y
VALORES
NOMBRE DEL
CONTENIDOS
CAPÍTULO 3 Comprensión e Indagación y Juicio crítico Creatividad  Muestra
información experimentación actitud
cooperativa
Capítulo 3  Comprende el  Desarrolla las  Comprende  Expande y y
concepto de actividades la estructura amplia los participativa
Aplicaciones 3.1 Concepto de aplicación
aplicación web. propuestas en la básica de conocimiento en la clase.
web con web
clase y en el libro toda s adquiridos
Netbeans 3.2 Concepto de servidor de
de texto. aplicación para crear
aplicaciones
 Comprende el web en Java. aplicaciones
3.3 Habilitando nuestro  Valora la
concepto de más
servidor de aplicaciones en variedad de
servidor web. complejas.
Netbeans. herramienta
3.4 Creando nuestra primera s que ofrece
aplicación web con Netbeans  Comprende la el programa
3.5 Mejorando nuestra integración de para
aplicación añadiéndole Netbeans con el elaborar 6
procesado de datos servidor web buenos semanas
3.6 Ejecutando nuestro tomcat. trabajos.
aplicación modificada
3.7 Ejecutando nuestra
aplicación en modo de  Comprende la  Valora la
inspección (Debug) importancia de los tecnología
3.8 Creando los javadocs de javadocs. como
nuestro proyecto recurso para
Ejercicio propuesto: mejorar la
Modificando aplicación de calidad de
ejemplo vida.
¿Cuánto aprendí?
5
Netbeans con tendencia a aplicación web.

El presente curso tiene por objetivo iniciar en el uso de la herramienta Netbeans
y los conceptos principales para el desarrollo de una aplicación a nivel básico.
Al finalizar, el alumno comprenderá la herramienta Netbeans y sus diferentes

características. Asimismo, el alumno comprenderá los conceptos básicos
necesarios para el desarrollo de una aplicación web usando Netbeans y Java.
También se explicarán los conceptos básicos de toda aplicación web en Java,
que serán base fundamental para el análisis e investigación de futuras
herramientas y marcos de trabajo de desarrollo.
6
CAPÍTULO 1
Introducción a Netbeans
________________________________________________
Bienvenido al curso de Netbeans con

tendencia a aplicación web,
donde aprenderás a utilizar la
herramienta Netbeans para el desarrollo
de aplicaciones web.
Netbeans es uno de los programas más utilizados para el desarrollo de

aplicaciones Java. Con él, puedes crear desde sencillas aplicaciones de
escritorio, pasando por aplicaciones para celulares y finalizando con grandes
y complejas aplicaciones empresariales.
1.1.- Introducción a Netbeans

Netbeans es un entorno de desarrollo integrado (IDE, por su traducción al inglés,
Integrated Development Environment) de código libre, que es muy utilizado para
el desarrollo de aplicaciones en diferentes lenguajes de programación, pero su
uso es más popular para la programación en Java. Se le puede agregar nuevas
funcionalidades mediante la instalación de plugins, de hecho, existen muchos
programas que toman Netbeans como su base y lo personalizan mediante la
instalación de diferentes plugins; de esta forma crean un programa con un fin
totalmente distinto. A continuación, procedamos a instalar Netbeans.
1.2.- Instalación de Netbeans

Para instalar Netbeans, seguiremos los siguientes pasos:
- Nos dirigimos a la página http://netbeans.org/downloads/index.html, como

se muestra a continuación:
7
- Hay diferentes versiones de Netbeans para descargar, cada una

orientada a un uso específico; nosotros vamos a instalar la versión Java
EE que nos permitirá la creación de aplicaciones web entre otras
características avanzadas.
- Procedemos a iniciar la descarga dando clic al botón Download bajo Java
EE, que nos llevará a la siguiente pantalla donde descargaremos el
archivo netbeans-7.1.2-ml-javaee-windows.exe (a la fecha de la escritura
de este curso, la última versión de Netbeans era la 7.1.2).
- Una vez descargado el archivo netbeans-7.1.2-ml-javaee-windows.exe,
hacemos doble clic y empezará el proceso de instalación, se mostrará la
pantalla de bienvenida luego de un proceso de configuración del
instalador:
8
- Procedemos a seleccionar Apache Tomcat 7.0.22 como servidor de

aplicaciones. Damos clic a Next y aparecerá la pantalla de la licencia:
- Seleccionamos la casilla aceptando la licencia, como indica la figura, le

damos clic a Next y aparecerá la pantalla de licencia de JUnit.
9
- El curso no incluirá JUnit; por lo tanto, seleccionamos la opción “Do not

install JUnit” y le damos clic a Next. Luego, aparecerá la pantalla para
seleccionar el directorio de instalación y la ubicación de la JDK. Es
importante notar que es necesario tener instalada la JDK de Java de
Oracle para la instalación de Netbeans, dejemos las opciones por defecto.
- Luego, aparecerá la pantalla para especificar la ubicación del servidor

Tomcat, dejamos la opción por defecto como indica la siguiente figura:
10
- Luego de darle Next a la pantalla anterior, aparecerá otra con el resumen

de las opciones seleccionadas:
- Finalmente, procedemos a hacer clic al botón Install para empezar la

ejecución del proceso de instalación. Una vez completado el proceso de
instalación, aparecerá la siguiente pantalla:
11
- Procedemos a darle clic al botón Finish.
1.3.- Entorno de aplicación
Procedemos a iniciar Netbeans, haciendo doble clic en el ícono Netbeans IDE

7.1.2 en el escritorio. A continuación, tenemos la pantalla de inicio de eclipse con
información de interés tales como Novedades, Tour guiado, Demos y tutoriales,
etcétera. Procedamos a cerrar la página de inicio (pestaña Start Page en la
parte superior izquierda); una vez hecho esto, aparece el entorno de desarrollo
por defecto de Netbeans:
12
Las partes del entorno por defecto son las siguientes:
1. Barra de menú: permite acceder a todas las opciones y características

del programa.
2. Barra de herramientas por defecto: contiene las opciones más
comunes, como Nuevo elemento, Abrir elemento existente, Guardar,
etcétera.
3. Campo de búsqueda: esta es una nueva característica muy útil en
Netbeans, ya que permite hacer búsquedas en diferentes ámbitos del
programa como la ayuda, las opciones de configuración, etcétera. Para
realizar la búsqueda simplemente escribimos en el campo y
automáticamente se desplegarán los resultados.
4. Sección con las ventanas de proyectos, archivos y servicios. estas 3
ventanas son las que son mostradas por defecto; sin embargo, Netbeans
posee muchas otras ventanas para el control de diferentes aspectos del
desarrollo de aplicaciones, que iremos viendo durante el avance del
curso. Un detalle a tener en cuenta es que podemos personalizar la
disposición de las diferentes ventanas a nuestro gusto, simplemente
haciendo clic en el título de la ventana y arrastrándola. Un cuadro de color
rojo indicará la ubicación donde se posicionará la ventana al momento de
soltarla, tal como indica la siguiente figura:
1.4.- Noción de proyecto Netbeans
Netbeans define el desarrollo de aplicaciones bajo el concepto de un proyecto.

Un proyecto no es más que un directorio que contendrá los paquetes, el código,
los archivos auxiliares y los archivos de configuración de una aplicación.
Podemos tener diferentes aplicaciones desarrolladas al mismo tiempo, cada una
en un proyecto independiente. Los proyectos se administran y exploran desde la
13
ventana Projects y su estructura dependerá exclusivamente del tipo de

aplicación que estamos desarrollando. A lo largo del curso, veremos distintas
estructuras de acuerdo al tipo de proyecto que desarrollemos.
1.5.- Creando nuestra primera aplicación Java con Netbeans

Vamos a crear la famosa aplicación Hola Mundo mediante la cual explicaremos
un poco más en detalle las características de un proyecto.
1.5.1- Creando nuestro proyecto
El primer paso para la creación de nuestra aplicación será la creación del

proyecto mismo, para ello realizamos los siguientes pasos:
- En el menú principal nos dirigimos a la opción File y luego a New

Project, entonces se presenta el diálogo para la creación de un nuevo
proyecto, como se muestra a continuación.
- En la sección Categories, escogemos la carpeta Java y en la sección

Projects, elegimos la opción Java Application, luego de eso
presionamos el botón Next y aparecerá la pantalla para seleccionar el
nombre y la ubicación del proyecto:
14
- La pantalla cuenta con las siguientes opciones:
1. Project Name: el nombre del proyecto

2. Project Location: la carpeta donde se guardará el proyecto.
3. Project Folder: campo de solo lectura donde se muestra la
ubicación final de la carpeta del proyecto. Netbeans crea una
carpeta con el nombre del proyecto por cada proyecto creado.
4. Use dedicated folder for storing libraries: marcando esta opción,
podemos indicar que los archivos compilados están en una
ubicación específica. No la marquemos por el momento.
5. Create Main Class: marcando esta opción, creamos un archivo java
por defecto para nuestro proyecto. Podemos observar que se crea
la clase Hola mundo dentro del paquete holamundo. La dejamos
marcada.
6. Set as Main Project: al crear un proyecto, podemos definirlo como
el proyecto principal. Este se mostrará en negrita en la ventana de
proyectos, y es el proyecto que seleccionamos por defecto cuando
ejecutamos las opciones de compilación y ejecución. La dejamos
marcada.
- Finalmente, seleccionamos la opción Finish. Con eso hemos terminado

de crear nuestro proyecto.
15
1.5.2- El entorno de trabajo de Netbeans al detalle
- Luego de terminar de crear nuestro proyecto con nuestra clase principal,

tendremos el IDE que nos muestra la siguiente configuración de pantallas:
Podemos apreciar 4 secciones bien diferenciadas. Vamos a ir viéndolas

una por una.
- Empecemos por la sección de manejo de proyectos en la parte superior

izquierda. Esta consta de las siguientes ventanas o subsecciones:
1. Projects: como su nombre lo

indica, nos da una vista de los
paquetes y librerías del proyecto
así como de las clases. En la
carpeta lógica Source Package
se muestran las diferentes clases
dentro de sus respectivos
paquetes. En la carpeta lógica
Libraries se nos muestra las
librerías utilizadas por las clases de nuestro proyecto, por defecto
se utilizan las clases del JDK de Java, que es lo que se muestra en
la figura como JDK 1.6 (Default).
16
2. Files: nos muestra las carpetas

físicas del proyecto, aquellas que
podemos acceder mediante el
navegador de Windows, por
ejemplo. Además de las carpetas
físicas también nos muestra los
archivos de configuración del
proyecto. Es por ello que en el
punto anterior se usaba el término
“carpetas lógicas”, dado que estas
como tales no existen. Es así como nuestra carpeta lógica Source
Package en realidad es la carpeta física src y podemos apreciar
que los paquetes no son más que subcarpetas dentro de la carpeta
src. No nos ocuparemos de los archivos de configuración o
ejecución tales como manifest.mf y build.xml, ya que escapan al
objetivo del libro.
3. Services: contiene una lista de los

diferentes servicios y procesos que
pueden estar asociados a nuestro
proyecto como, por ejemplo, bases
de datos o servidores. Esto lo
veremos con más detalle en los
capítulos 3 y 4.
- A continuación, en la parte superior derecha, tenemos al editor Java. Esta

es la sección que más se utilizará, dado que es donde se escribe el
código:
17
- Este editor contiene la siguientes partes:
1. Sección de etiquetas: el editor de texto trabaja bajo el concepto de

etiquetas, mediante estas es posible trabajar con múltiples archivos
usando un mismo editor compartido, se irán creando etiquetas por
cada archivo que abramos para edición.
2. Sección de desplazamiento entre archivos: cuando tenemos

demasiados archivos abiertos, las etiquetas sobrepasan el ancho
del editor, de forma que se ocultan las que estén más a la derecha.
Mediante las flechas izquierda y derecha, podemos desplazar la
lista de etiquetas para seleccionar aquellas ocultas y mediante la
flecha abajo se despliega un menú con todos los archivos abiertos,
lo que permite seleccionarlos directamente. El último botón sirve
para maximizar el tamaño del editor.
3. Sección de vistas: acá encontramos dos opciones, una para ver el

código (opción por defecto) y la otra para ver la pantalla de
historial. El historial guarda la relación de cambios hechos al
archivo y los compara contra el archivo original, así también nos
permite deshacer o revertir los cambios hechos.
4. El editor también posee una barra de herramientas que nos

permite, entre otras cosas, comentar, descomentar código,
regresar al punto de edición previo, desplazarnos entre bookmarks,
etcétera. Para saber la utilidad de cada botón basta poner el ratón
sobre cada uno de ellos.
5. Sección de numeración de línea: lo más importante de esta sección

es que haciéndole clic derecho nos permite agregar un bookmark o
un breakpoint. Un bookmark es una etiqueta con una descripción
ubicada en una línea que nos sirve de guía en nuestro código. Un
breakpoint o punto de quiebre es un punto del código donde se
detendrá la ejecución de una aplicación al momento que se hace
debug de la misma. No te preocupes mucho de estos detalles
ahora, los explicaremos después.
6. Barra de posicionamiento: Esta barra nos indica de manera gráfica,

mediante líneas de colores, la ubicación en el código de
bookmarks, advertencias y errores de compilación en nuestro
código. En la parte superior, hay un cuadrado que nos indicará el
estado en general de nuestro archivo. Si está verde, significa que
está todo bien sin errores de ningún tipo. Si está amarillo, quiere
decir que hay advertencias y si está rojo, quiere decir que nuestro
archivo tiene errores.
18
- En la parte inferior izquierda, tenemos el

navegador de clases. Este nos proporciona
una descripción visual de las propiedades y
métodos de una clase. En el ejemplo,
podemos ver el único método main de
nuestra clase HolaMundo. En la parte
inferior, tenemos un conjunto de botones
que nos permiten filtrar y ordenar los
elementos de la clase. Se puede saber la
funcionalidad de cada uno de ellos
colocando el ratón encima de ellos.
- Finalmente, en la parte inferior derecha, tenemos la sección de tareas o

TODO. Un TODO es una sección donde se indica que hay algo por hacer,
en la práctica es un comentario más, pero es separado por el IDE en una
sección de tasks o tareas:
- Como podemos ver en la imagen, la ventana nos muestra la relación de

TODO de todos los proyectos abiertos. Nos presenta su descripción, el
archivo donde se encuentra y la ubicación del archivo, siendo así una
manera rápida y centralizada de poder verificar las tareas pendientes en
nuestro código.
19
1.5.3- Utilización de editor
Empezaremos a utilizar el editor añadiendo un poco de código a nuestro método

main, como se muestra a continuación:
Podemos apreciar en la sección de numeración de líneas el símbolo para indicar

un error en la línea; igualmente, vemos que la clase Date está subrayada de
rojo, lo que indica que ahí existe un error. Al poner el ratón encima nos indicará
el tipo de error, en este caso indica que la clase Date no puede ser encontrada
Tal como indica el cuadro, procedemos a presionar Alt y Enter simultáneamente

para que se nos presente una lista de sugerencias para arreglar el error:
La primera nos sugiere añadir la sentencia import para la clase java.util.Date.

Procedemos a seleccionarla para solucionar el error, tal como se muestra a
continuación:
20
Nuestra clase ya no tiene errores, pero podemos apreciar que la variable ahora
está subrayada y, al colocar el ratón encima, aparece un tooltip con un mensaje
que nos indica que la variable no es usada.
Esta es una característica importante de Netbeans ya que realiza un análisis de

nuestro código y detecta porciones de nuestro código que puede ser mejorado,
como es el caso de esta variable que nunca es usada, es así como Netbeans
nos ayuda mucho para la creación de código no solo sin errores de compilación,
como el caso de la clase Date no encontrada, sino también con sugerencias
para que nuestro código sea limpio y correcto.
Continuemos añadiendo código, vamos a crear otra variable de tipo Date

llamada diaPasado y a continuación vamos a usar un método de ese objeto,
para ello escribimos “diaPasado.” (sin las comillas, finalizando con un punto) y
Netbeans nos mostrará lo siguiente:
21
Esta es otra característica que poseen los entornos de desarrollo avanzados

como Netbeans y es la capacidad de mostrarnos los elementos que posee una
clase, así como el javadoc del elemento seleccionado en ese momento (en el
ejemplo, vemos el javadoc del método after).
Esta es una característica importante que nos permite un ahorro considerable de

tiempo al momento de codificar. Un javadoc es la documentación del código de
una clase y posee información detallada de la misma, más adelante en el curso
vamos a aprender a crear los javadocs de las clases de nuestro proyecto.
Además de la sugerencia de elementos de una clase Netbeans, también nos

puede sugerir clases basándose en el texto que hayamos escrito, procedemos a
escribir la palabra Sys y a continuación presionamos la tecla Ctrl + Espacio, de
modo que obtendremos lo siguiente:
Esta es otra característica importante de Netbeans y es la capacidad de sugerir

nombres de clases basándose en lo que hayamos escrito. La combinación Ctrl +
Espacio también sirve para sugerir métodos o propiedades de una clase
basándose en el texto que hayamos escrito luego del punto. Finalmente,
procedemos a escribir el siguiente código antes de pasar a la siguiente sección
donde veremos cómo ejecutar nuestro código:
22
1.6.- Compilación y ejecución de un proyecto

En Netbeans, la compilación de nuestras clases se hace de manera automática
cada vez que guardamos; por lo tanto, siempre estarán listas para su ejecución o
debug. Sin embargo, si queremos regenerar los archivos jar que contienen
nuestros compilados y volverlos a compilar como un todo, hacemos clic derecho
en el nombre de nuestro proyecto y seleccionamos la opción Clean and Build,
como indica la figura:
Esto se realiza sobre todo en el caso que nuestros archivos .java queden
desincronizados respecto a su versión compilada, lo que da como resultado
errores de compilación inexistentes en el editor. Para proceder a ejecutar
nuestro proyecto, procedemos a seleccionar el mismo, luego damos clic derecho
y elegimos la opción Run:
23
O simplemente le damos clic al botón verde Play en la barra de herramientas:
El botón Play ejecutará el proyecto que este

marcado como principal. Ejecutemos nuestro
proyecto de cualquiera de las dos maneras,
nuestro código solamente escribe en la consola
de salida un conjunto de cadenas que contienen información de los objetos:
Al final también se indica información del proceso de construcción o building de

la aplicación y el tiempo que tomó. Algo interesante de Netbeans es que el
proceso de invocar a la ejecución de cualquier aplicación no cambia
independientemente de la complejidad de la misma, ya que cada tipo de
proyecto trae sus propios archivos de configuración que serán utilizados por el
proceso de ejecución automáticamente.
Si recordamos un poco de java, sabemos que el método main recibe un conjunto

de argumentos en forma de un arreglo de cadenas. ¿Cómo hacemos para pasar
esos argumentos utilizando Netbeans y nuestra configuración de ejecución?
Para ello, hagamos clic derecho en el nombre del proyecto y seleccionemos
24
Aparecerá el siguiente diálogo con las propiedades del proyecto, en este caso,
con las propiedades de ejecución en específico:
Colocamos los argumentos separados por comas en el campo Arguments y le

damos OK. Luego, agregamos la siguiente línea y el siguiente método para
procesar los argumentos:
Y obtenemos la siguiente salida:
25
1.7.- Depuración e inspección de un proyecto

Depurar consiste en analizar la ejecución de un programa paso a paso con la
finalidad de inspeccionar el funcionamiento del código que lo compone.
Netbeans cuenta con un muy completo entorno de depuración que veremos a
continuación. El proceso de depuración se basa en el concepto de breakpoint o
“puntos de quiebre”. Un breakpoint es una línea de código donde la aplicación
en debug se detendrá permitiendo, a partir de ahí, la ejecución paso a paso.
Para agregar un breakpoint, simplemente hacemos clic en la sección de
números de línea y aparecerá un pequeño recuadro rojo a la vez que la línea
seleccionada será resaltada en rojo, tal como muestra la siguiente figura:
Procesamos a ejecutar nuestra aplicación en modo debug. Para ello tenemos 2

opciones: la primera, seleccionar el proyecto, clic derecho y opción Debug,
O la segunda mediante el botón Debug

en la barra de herramientas, el cual
ejecutará en modo debug el proyecto
principal:
Iniciemos el modo debug

con cualquier de las
opciones y obtendremos la
siguiente disposición de
ventanas de Netbeans:
26
Podemos apreciar, en primer lugar, en el editor que la línea donde ubicamos el

breakpoint se encuentra resaltada de color verde; pues bien, ahí vemos nuestro
breakpoint en acción, deteniendo la ejecución del programa en la línea donde
fue ubicado (línea 25). Así, la línea de fondo verde nos indica la siguiente línea a
ser ejecutada. Pasemos a revisar cada una de las nuevas ventanas aparecidas
en el modo de debug.
- Pestaña Debugging: nos indica la línea actual donde se encuentra

detenido el proceso de
debug. En el caso de la
imagen, nuestro proceso
se encuentra detenido en
la línea 25 a la espera de
su ejecución. Vemos un pequeño símbolo de Play, si le damos clic
procedemos a continuar la ejecución del programa hasta encontrar otro
breakpoint; en caso de no haber otro, se ejecutará hasta la finalización del
programa.
- Pestaña Variables: nos muestra los valores actuales de las diferentes

variables a las que se tenga acceso. Se puede desplegar cada variable
para poder ver en detalle su estructura y estado interno.
- Pestaña Breakpoints: nos muestra la lista de los diferentes breakpoints

del proyecto, mediante el check podemos habilitar o deshabilitar el
checkpoint para que sea tomado en cuenta o ignorado durante el debug.
- Barra de herramientas de debug: posee los controles para poder controlar

el flujo del proceso de debug, así como su suspensión o detención,
también cuenta con un indicador del uso de la memoria, útil para saber si
alguna parte de nuestro código está haciendo un uso excesivo de
memoria.
27
A continuación, describiremos los botones más importantes de la barra:
Botón Uso
Detiene la ejecución del programa
en modo debug.
Pausa la ejecución del programa en
modo debug.
Continúa la ejecución del programa
en modo debug hasta llegar a otro
breakpoint o hasta la finalización del
programa.
Ejecuta una línea de código sin
detenerse en invocaciones a otros
métodos que existan en la misma
línea.
Ejecuta una línea de código
deteniéndose en invocaciones a
otros métodos que existan en la
misma línea.
Ingresa al interior del método
seleccionado en la línea.
Sale de la ejecución de un método.
Continúa la ejecución hasta la línea
donde se encuentre el cursor.
Veamos un pequeño ejemplo de ejecución del debug justamente en la línea 25.

Si queremos ver la ejecución del método procesaArgs(args), procedemos a
seleccionar el botón para posicionarnos en el método y, a continuación,
seleccionamos el botón para ingresar a la implementación del método, tal
como se ve en la figura:
28
Veamos la pestaña Variables:
Podemos ver que ya no se aprecian las variables que existían cuando la línea de
ejecución estaba en la línea 25 sino solamente el argumento args del método.
Esto es debido a que en la pestaña Variables, solo se ven las variables que
estén dentro del ámbito del método que se está inspeccionando. Luego,
podemos salir inmediatamente del método procesaArgs ejecutando las líneas
que quedan y volviendo al punto donde se invocó mediante el botón :
Finalmente, ponemos el cursor en la línea 28 y presionamos el botón , y la

línea de ejecución se desplazará hasta esa línea.
1.8.- Creando nuevas clases, paquetes e interfaces

Vamos a ver cómo podemos crear nuevas clases, paquetes e interfaces para
nuestros proyectos. Se ven los 3 conceptos en conjunto dado que el proceso es
muy parecido.
1.8.1- Creando un paquete
Un paquete es una carpeta que puede contener en su interior subpaquetes y, a

la vez, elementos java como clases, interfaces, enums, etcétera, lo que es muy
importante para la organización de nuestro código. La estructura jerárquica de
paquetes junto al nombre de una clase es lo que se denomina el nombre
canónico o completo de una clase. Para crear un paquete, hacemos clic derecho
a Source Package, luego New y, finalmente, Java Package, como indica la
figura:
29
A continuación, aparecerá el diálogo para la creación del nuevo paquete:
Procedemos a ingresar el nombre del paquete y damos clic en Finish. También

se pueden crear paquetes dentro de otros paquetes, basta con empezar todo el
proceso haciendo el clic derecho en el paquete que queremos que contenga
nuestro nuevo paquete.
1.8.2- Creando una clase
Para la creación de una clase Java, es exactamente el mismo proceso inicial

solo que se escoge Java class, luego de eso se presenta la siguiente pantalla:
30
Los campos más importantes son los siguientes:
- Class name: acá especificamos el nombre de la clase.

- Package: acá seleccionamos el paquete donde queremos que esté
nuestra clase.
-
1.8.3- Creando una interface
El proceso de creación de una interface es exactamente la misma, siendo los

campos más importantes el nombre de la interface y el paquete donde se
ubicará. Notar que en la ventana de ingreso de una nueva interfaz el campo de
nombre continúa diciendo “Class Name”.
 Netbeans nace en 1996 como Xelfi un IDE Java, producto de un

proyecto de estudios. Luego, en 1997, Roman Stanek forma una
compañía alrededor del proyecto y se crean versiones comerciales
del IDE hasta el año 1999, que es comprado por Sun Microsystem
quien lo convierte en un proyecto de código abierto.
 Netbeans IDE, al estar desarrollado en Java, puede ejecutarse en
cualquier plataforma que contenga una máquina virtual java válida.
¿A qué se le denomina Netbeans Platform?
________________________________________________________________
________________________________________________________________
________________________________________________________________
31
Ejercicio práctico: creación de dos nuevas clases, Usuario y

Utils, y renombrado de paquetes
Vamos a realizar un sencillo ejercicio donde crearemos una clase Usuario, sus
métodos get y set. Luego, crearemos una clase Utils bajo un nuevo paquete Util,
modificaremos el código de nuestro main para usar estas clases y, finalmente,
renombraremos el nombre del paquete newpackage para ver en acción el
proceso de refactorización automática de Netbeans.
- Primero, procedemos a crear la clase Usuario, con el procedimiento del

punto 1.7.2. La clase tendrá 2 propiedades, identificador y password,
- A continuación, crearemos los métodos get y set de manera automática,

esto lo realizamos haciendo clic derecho en cualquier parte del editor y
seleccionando la opción Insert Code, en el menú contextual aparecerá el
siguiente popup:
- Seleccionamos la opción Getter and Setter y aparecerá la siguiente

pantalla:
32
- Seleccionamos toda la clase y le damos clic a Generate. Ya tenemos

nuestra clase con nuestros métodos get y set creados.
- Procedemos a crear el paquete útil y la clase Utils, como se indicó en los

puntos anteriores. En la clase Utils, vamos a crear un método que reciba
una lista de usuarios y que cree una cadena de texto con la información
proporcionada:
- Ahora, procedemos a cambiar el código de nuestro método main,

ejecutamos nuestro proyecto y obtenemos el siguiente resultado:
33
- Ahora, vamos a mostrar otra de las características avanzadas de

Netbeans, que es la refactorización de elementos, en este caso un
renombramiento del nombre de un paquete. Este cambio va a ser
propagado en todo el código que hace referencia a la clase renombrada;
esto nos ahorra mucho tiempo y a la vez nos protege de errores de
compilación y engorrosas revisiones, que es probable que ocurran cuando
se hace todo el proceso a mano, modificando clase por clase. Vamos a
proceder a renombrar el paquete newpackage con el nuevo nombre “bo”
(abreviación de business object). Para ello, hacemos clic derecho en el
paquete, opción Refactor y, a continuación, opción Rename, aparecerá la
siguiente pantalla:
- Ingresamos el nuevo nombre y le damos clic a Refactor; podemos

apreciar cómo en la clase HolaMundo cambia automáticamente el valor
de la sentencia import:
Ejercicio propuesto: creando un nuevo proyecto para una

aplicación de conversión
Se debe crear un nuevo proyecto llamado “ConversorApp”, debe contener 2

paquetes, útil y base. Bajo “útil” se debe crear la clase Utils, que contendrá
funciones de conversión de temperaturas de Farenheit a Celcius y viceversa.
Bajo “base”, se debe definir la clase principal del proyecto, el cual contendrá el
método main. Este debe recibir 2 argumentos: el primero, el valor de la
temperatura; y el segundo, el tipo de escala de temperatura a la que se quiere
convertir.
34
¿Cuánto aprendí?
Ejercicios de definición
Completa las definiciones de los siguientes términos:
1. Javadoc: _______________________________
_______________________________
_______________________________
2. TODO: _______________________________
_______________________________
_______________________________
3. Breakpoint: _______________________________
_______________________________
_______________________________
4. Debug: _______________________________
_______________________________
_______________________________
5. Paquete: _______________________________
_______________________________
_______________________________
35
Resuelve las siguientes preguntas:
1. ¿Cuáles son las partes, por defecto, del entorno de desarrollo de Netbeans?
_______________________________________________________________
_______________________________________________________________
2. ¿Qué es un proyecto?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. ¿Qué muestra la pestaña Projects?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
4. ¿Para qué sirve el navegador de clases?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
36
CAPÍTULO 2
Manejo de bases de datos
________________________________________________
En este capítulo vamos a ver el concepto

de bases de datos y cómo podemos
acceder a ellas mediante Netbeans.
La base de datos es un concepto muy importante para el desarrollo de

aplicaciones.
2.1.- Introducción a bases de datos
Una base de datos es un repositorio donde se guarda información de todo tipo

separada por tablas. Una tabla es la representación de un concepto de la vida
real, como por ejemplo un profesor, así la información de profesores se
almacenan en una tabla “Profesor”. Un profesor puede tener características que
lo describen, como nombres, apellido paterno, apellido materno, dirección,
etcétera. Cada una de estas propiedades o características se representa con
una columna de tabla. No te preocupes si no comprendes en este momento
estos conceptos, los explicaremos más adelante. Vamos a trabajar con la base
de datos MySql debido a que es una de las bases de datos más populares
actualmente y además es libre de descargar e instalar, en el siguiente punto
explicaremos el proceso de instalación de MySql
2.2.- Instalación de MySql

Para instalar MySql, seguiremos los siguientes pasos:
- Nos dirigimos a la página http://www.mysql.com/downloads/mysql/, como

se muestra a continuación:
37
- Hay diferentes versiones de instalador de MySql para descargar, nosotros

vamos a descargar la versión Windows (x86, 32-bit), MSI Installer.
- Procedemos a iniciar la descarga dando clic al botón Download al botón
correspondiente, aparecerá la siguiente pantalla, solicitando un usuario
con dominio mysql.com.
- No es necesario tener una cuenta en el dominio MySql.com, por lo tanto

simplemente hacemos clic al enlace en la parte inferior que dice “No
thanks, just start my download!”
38
- Una vez hecho esto empezará la descarga del archivo mysql-5.5.25.a-

win32.msi. A la fecha de la creación del curso la última versión de MySql
era la 5.5.25.
- Una vez descargado procedemos a ejecutar el instalador, el cual muestra

la siguiente pantalla.
- Damos clic a Next y aparecerá la pantalla de la licencia:
39
- Seleccionamos la casilla aceptando la licencia como indica la figura, le

damos clic a Next y aparecerá la siguiente pantalla, solicitando el tipo de
instalación a ejecutar:
- Seleccionamos la instalación típica y aparecerá una pantalla para

confirmar e iniciar el proceso de instalación, para ello hacemos clic en el
botón Install. Cuando termine el proceso de instalación aparecerán 2
pantallas de tipo informativas, simplemente le damos clic a Next y a
continuación aparecerá la pantalla final.
40
Es muy importante dejar marcada la opción Launch the MySql Instance

Configuration Wizard, ya que nos permitirá realizar la configuración del
servidor MySql que acabamos de instalar de una manera fácil y dirigida,
sin necesidad de modificar directamente los archivos de configuración de
MySql. Una vez hecho clic en Finish, aparecerá la pantalla de bienvenida
del Configuration Wizard, simplemente hacemos clic en el botón Next. Y a
continuación aparecerá la pantalla para escoger el tipo de configuración a
realizar:
Seleccionamos Detailed Configuration, luego aparecerán las pantallas

para seleccionar el tipo de servidor y el tipo de base de datos.
Seleccionamos Developer Machine para la primera y Multifunctional
Database para la segunda. A continuación aparecerá la opción para
indicar la ubicación donde se guardará el espacio de nombres de las
tablas:
41
Dejamos las opciones por defecto y hacemos clic a Next. A continuación

aparecerán 2 pantallas más, la primera para definir el número de
conexiones aceptadas por el servidor y la segunda para definir las
opciones de red. Dejamos las opciones por defecto en ambas y luego de
eso llegamos a la pantalla donde seleccionamos el juego de caracteres
por defecto soportado por el servidor:
Seleccionamos Best Support For Multilingualism, dado que vamos a

trabajar con idioma español. Luego de eso aparecerá la siguiente
pantalla:
42
Acá configuramos MySql para que se instale e inicialice como un servicio

de Windows, esto es una ventaja ya que así el servidor se iniciará
automáticamente cada vez que iniciemos Windows. Hacemos clic a Next
y pasamos a la siguiente pantalla:
Aquí procederemos a establecer el password del usuario root de MySql, el

usuario root es el usuario principal de la base de datos, con acceso a
todos los objetos y operaciones sobre la base de datos, en pocas
palabras, es el usuario administrador de MySql. Procedemos a ingresar y
confirmar un password y hacemos clic en Next. Finalmente llegamos a la
pantalla de confirmación para iniciar el proceso de configuración;
simplemente damos clic en el botón Execute. Si todo sale bien,
deberemos tener la siguiente pantalla con todos los pasos concluidos
satisfactoriamente:
43
Con esto, hemos terminado nuestra instalación y configuración de MySql.

Para la administración de MySql usaremos el propio Netbeans ya que
cuenta con una ventana para la administración de bases de datos.
¿Qué otras bases de datos existen aparte de MySql tanto de código libre como
licenciadas (pagadas)?
________________________________________________________________
________________________________________________________________
2.3.- El administrador de bases de datos de Netbeans
La instalación por defecto de Netbeans trae un conjunto de herramientas muy

útiles para la tarea de desarrollo de aplicaciones, entre ellas un administrador de
bases de datos. Vamos a crear una sencilla base de datos a modo de ejercicio
para proceder a explicar los pasos necesarios para la creación de una. A
continuación una breve explicación de nuestra base.
Vamos a crear una base de datos para un colegio, donde procederemos a

guardar información de alumnos y profesores. Los alumnos contarán con la
siguiente información: nombres, apellido paterno, apellido materno, DNI, fecha
de nacimiento, dirección y sección. Los profesores contarán con la siguiente
información: nombres, apellido paterno, apellido materno, DNI, fecha de
nacimiento, dirección, especialidad, estado civil.
Ya explicada la base de datos que crearemos, empecemos a utilizar el

administrador de bases de datos yendo a la ventana de servicios, como vimos
en el capítulo pasado:
Lo primero que debemos hacer para poder

acceder a una base de datos es crear una
conexión, la que será utilizada por el
administrador para realizar las diferentes
operaciones contra la base de datos.
44
2.3.1- Conexión de Netbeans a una base de datos
Para crear una conexión realizamos los siguientes pasos:
- Vamos a la pestaña Services luego damos clic derecho sobre Databases

y seleccionamos la opción New Connection, aparecerá el siguiente
diálogo:
En esta pantalla debemos seleccionar el driver específico para la base de

datos que estamos utilizando. En el combo Driver, seleccionamos
MySQL (Connector/J driver). Seguro te estarás preguntando qué es un
driver, pues es simplemente un conjunto de clases java que se encargan
de comunicarse con una base de datos. Los drivers son específicos para
cada base de datos. Una vez seleccionado el driver, hacemos clic en
Next y se presentará la siguiente pantalla:
45
En esta pantalla proporcionamos la información básica que requiere el

driver para comunicarse con la base de datos. Dejamos todas las
opciones marcadas por defecto, simplemente agregamos el password del
usuario root (el mismo que escribiste cuando configuraste el servidor de
mysql en el punto anterior), dejamos marcada la opción Remember
password para que Netbeans no esté solicitando el password para cada
operación que queramos hacer en la base de datos. Luego probamos
nuestra conexión con el botón Test Connection, si todo sale bien deberá
aparecer el mensaje: “Connection Suceeded”. Damos clic en Next y
aparecerá la pantalla de selección de esquema.
Un esquema no es nada más que el nombre de una base de datos en

específico. Como nuestro servidor ha sido recién creado no contiene
ningún esquema, simplemente damos clic en Finish y ya tenemos
nuestra conexión a MySql creada, como se ve a continuación:
Se puede volver a revisar o modificar las propiedades de la conexión

haciendo clic derecho en el nombre de la conexión (resaltado en la
imagen anterior), opción Properties, aparecerá la siguiente pantalla con
la información de la conexión:
46
2.3.2- Creación de una nueva base de datos
Para la creación de una nueva base de datos hacemos clic derecho en la

conexión y elegimos la opción Create Database, aparecerá el siguiente diálogo:
Escribimos el nombre de la base de datos y presionamos OK, llamemos a

nuestra base de datos “colegio_bd”. Una vez creada la base de datos se
agregará a nuestra lista de bases de datos disponibles:
Podemos apreciar que la base

de datos no contiene ninguna
tabla dado que la acabamos de
crear, procedamos entonces a
crear la tabla alumno.
47
2.3.3- Creación de tabla
Para la creación de una nueva tabla hacemos clic derecho a la carpeta Tables y
seleccionamos la opción Create Table, aparecerá el siguiente diálogo:
Empecemos poniéndole el nombre “Alumno” a nuestra tabla en el campo Table

Name. A continuación agregaremos un conjunto de columnas, una columna
representa una propiedad del elemento que queremos guardar en la tabla; en
este caso una propiedad o característica de un alumno. Empecemos añadiendo
el campo para el nombre de los alumnos, para ello hacemos clic en la columna
Add Column, se mostrará el diálogo siguiente:
48
Los campos que nos muestra son los siguientes:
- Name: nombre de la columna, debe tener un nombre representativo.

- Type: el tipo de datos, un tipo de datos no es nada más que la forma
como se representará el valor de la columna, los tipos de datos
principales son numéricos, cadena de texto, booleano y fecha.
- Size, Scale: size sirve para indicar la longitud de ciertos datos como
VARCHAR, scale sirve para indicar la precisión en datos numéricos
(número de decimales).
- Default: indican el valor por defecto de la columna en caso no se haya
especificado al momento de insertar un fila a la tabla.
- Constraints: indican ciertas restricciones o características particulares de
la columna, explicaremos cada uno de ellos.
o Primary key: quiere decir que esa columna es el identificador de la
tabla, es decir su valor es único en toda la tabla (no se puede
repetir). Para el caso de un alumno podría ser su código de
alumno.
o Unique: indica que un valor es único en toda la tabla.
o Null: indica que esa columna puede estar vacía.
o Index: indica que la columna tiene un índice asociado. El concepto
de índice va más allá del alcance del curso.
Procedamos a crear la columna “código”, para ello insertamos la información

como indica la figura a continuación:
Estamos indicando que su tipo de dato es

INT (número entero), no tiene valor por
defecto, y es Primary key (al marcar
primary key se marcan los demás campos
automáticamente, dado que una llave
primaria es única y debe tener un índice
asociado), damos clic a OK. La siguiente
tabla indicará la relación de columnas
adicionales que contendrá la tabla
“Alumno”, así como las características de
cada uno, agrégalas para continuar con el
ejercicio.
Name Type Size Default Constraints

Nombres VARCHAR 30
ApellidoPaterno VARCHAR 20
ApellidoMaterno VARCHAR 20
DNI VARCHAR 8 Unique
FechaNacimiento DATE
Direccion VARCHAR 100 Null
Seccion VARCHAR 5
49
Luego de ingresar todas las columnas tenemos la pantalla de creación de tabla

de la siguiente manera:
Si queremos modificar las características de una columna, simplemente, la

seleccionamos y presionamos el botón Edit; si queremos borrar esa columna,
presionamos el botón Remove. Una vez que hemos verificado que nuestras
columnas están correctas procedemos a presionar OK y ya tenemos nuestra
tabla Alumno creada.
En la imagen podemos apreciar la

nueva tabla Alumno y sus columnas.
Si queremos ver las características
de la tabla y de sus columnas,
hacemos clic derecho sobre ellas y
seleccionamos la opción Properties.
A continuación vamos a explicar
cómo poder ver e ingresar
información de manera visual.
50
2.3.4- Obteniendo e insertando información en nuestra tabla.
Hagamos clic derecho en el nombre de la tabla y seleccionemos la opción View

Data, que nos muestra las siguientes secciones:
1. Sección de comandos SQL: permite la escritura y ejecución de

sentencias SQL, en la imagen se ha ejecutado una sentencia select que
sirve para obtener información de la base de datos, más adelante
veremos una breve explicación de SQL.
2. Sección de resultados: nos muestra los resultados de la ejecución de las
sentencias escritos en la sección de comandos. En este caso se está
mostrando toda la data contenida en la tabla Alumno y se muestra vacío
dado que la tabla no contiene data aún.
3. Sección de mensajes: en esta sección se muestra el resultado de la
ejecución de la sentencia, así como el detalle de los errores ocurridos
durante la ejecución en caso de existir. La imagen nos indica que la
sentencia se ejecutó exitosamente en 0.003 segundos.
Vamos ahora a insertar información en nuestra tabla alumno usando la sección

de resultados que también sirve para este fin. Para ellos demos clic al ícono
en la parte superior izquierda de la sección de resultados. Se mostrará la
siguiente pantalla:
51
Como su título indica, la pantalla sirve para insertar registros en una tabla
específica, en este caso la tabla Alumno. Podemos apreciar la lista de columnas
de la tabla y una primera fila donde podremos ingresar información. Procedamos
a ingresar 2 registros o filas como indica la figura. Para ello presionamos el
botón Add Row e ingresamos los datos en las columnas correspondientes. Una
vez finalizado deberá quedar de la siguiente manera:
Si queremos ver la sentencia SQL que se ejecutará para insertar los registros
que hemos ingresado, presionamos el botón Show SQL. También podemos
eliminar algún registro insertado, simplemente seleccionándolo y presionando el
botón Remove. Finalmente presionamos el botón OK y ya tenemos 2 registros
insertados en nuestra tabla Alumno. Esto se puede ver ahora en la sección de
resultados:
52
2.3.5- Breve introducción a SQL
SQL (Structured Query Language) o lenguaje de consulta estructurado es el

lenguaje utilizado para realizar sentencias sobre una base de datos (no
solamente de consulta a pesar del nombre). Las 4 sentencias básicas son:
- SELECT: permite la obtención de un conjunto de registros de una o más

tablas filtrados por un conjunto de condiciones.
- INSERT: permite la inserción de registros a una tabla.
- UPDATE: permite la actualización de un conjunto de registros de una
tabla.
- DELETE: permite la eliminación de un conjunto de registros de una tabla.
A continuación se explicará de manera muy breve la sintaxis de estos cuatro

comandos:
Sentencia SELECT
Su sintaxis es la siguiente:
SELECT lista de columnas de tablas o asterisco (*)

FROM lista de tablas
WHERE condiciones
Para obtener todos los registros de la tabla Alumno ejecutamos el siguiente

comando:
SELECT * FROM alumno;
Sentencia INSERT
INSERT (lista de columnas de la tabla) VALUES (valores para cada columna de

manera correspondiente)
Por ejemplo, para insertar un registro en la tabla Alumno ejecutamos el siguiente

comando:
INSERT INTO colegio_bd.alumno (codigo, `Nombres`, `ApellidoPaterno`,

`ApellidoMaterno`, `DNI`, `FechaNacimiento`, `Direccion`, `Seccion`)
VALUES (3, 'Carlos', 'Guerra', 'Garcia', '651984', '2004-10-06', 'Las Begonias
555 San Isidro', '2 B');
53
Sentencia UPDATE
UPDATE nombre de la tabla

SET columna1=nuevoValor1, columna2=nuevoValor2, columnaN=nuevoValorN
WHERE condición
Por ejemplo, para modificar nuestra primera fila insertada y cambiarle el nombre
de Eduardo a Francisco, el comando sería el siguiente:
UPDATE alumno
SET nombres = ‘Francisco’
WHERE codigo = 1;
Sentencia DELETE
DELETE
FROM nombre de la tabla
WHERE condición.
Por ejemplo, para eliminar el registro de la tabla alumno con código igual a 1
ejecutamos la siguiente sentencia:
DELETE
FROM alumno
WHERE codigo = 1;
Si no se pone la sección WHERE del comando, ¡este terminará borrando todos

los registros de la tabla!
Podrás notar que las sentencias terminan en punto y coma, esto es un

requerimiento del SQL.
2.3.6- Ejecución de comandos desde Netbeans
Para la ejecución de comandos necesitamos abrir una pestaña de ejecución de

comandos, para ellos hacemos clic derecho en el nombre de una tabla y
seleccionamos Execute command. Una vez hecho esto, procedamos a escribir
nuestras sentencias, veamos como ejemplo la ejecución del comando SELECT
del punto anterior. Una vez escrito, ejecutamos el comando haciendo clic al
botón en la barra de herramientas en la parte superior derecha de la
pestaña de ejecución de comandos. Aquí el resultado:
54
Vamos a ejecutar el comando UPDATE del punto

anterior, para ellos escribimos el comando en sección
de comandos:
Y una vez ejecutado obtenemos lo siguiente en la sección de mensajes:
Volvemos a ejecutar la sentencia SELECT y vemos cómo cambió el nombre del

alumno:
 Si bien estamos haciendo el curso con MySql, el administrador de

bases de datos de Netbeans funciona con muchas más bases de
datos.
¿Cómo se utiliza la sección WHERE de la sentencia SELECT? Provee un

ejemplo creando una consulta sobre la tabla Alumno utilizando WHERE.
________________________________________________________________
________________________________________________________________
55
Ejercicio propuesto: creando la tabla de profesores
Ya hemos creado la tabla Alumno, ahora deberás crear la tabla Profesor usando
los conceptos explicados en el capítulo. La tabla deberá contener los siguientes
campos: nombres, apellido paterno, apellido materno, DNI, fecha de nacimiento,
dirección, especialidad, estado civil.
¿Cuánto aprendí?
1. MySql: _______________________________
_______________________________
_______________________________
2. Driver: _______________________________
_______________________________
_______________________________
3. SELECT: _______________________________
_______________________________
_______________________________
4. DELETE: _______________________________
_______________________________
_______________________________
56
1. ¿Qué es el administrador de bases de datos de Netbeans?
_______________________________________________________________
_______________________________________________________________
2. ¿Cuáles son los tipos de datos vistos en el capítulo?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. ¿Qué es primary key?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
4. ¿Cómo se realiza la ejecución de comandos SQL desde la pestaña de

ejecución de comandos?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
57
Anotaciones
 ________________________________________________
 ________________________________________________
 ________________________________________________
 ________________________________________________
 ________________________________________________
 ________________________________________________
58
CAPÍTULO 3
Aplicaciones web con Netbeans
________________________________________________
En este capítulo vamos a explicar los

conceptos básicos para la creación de
una aplicación web, asimismo vamos a
crear nuestra primera aplicación web.
Una aplicación web permite que sus usuarios puedan comunicarse e

interactuar con esta desde cualquier parte del mundo, tan solo necesitan un
navegador y una conexión a Internet.
3.1.- Concepto de aplicación web

Una aplicación web es un conjunto de servicios que proveen una funcionalidad a
través de una interfaz gráfica de usuario y puede ser accedida desde un
navegador con conexión a Internet, un ejemplo puede ser la aplicación de
operaciones en línea de un banco, como la que se muestra a continuación:
59
Te podrás estar preguntando entonces cuál es la diferencia entre una página

web, un sitio y una aplicación web. Un sitio web es un conjunto de páginas web
que en su conjunto forman la presentación de una persona, empresa u
organización, puede contener, o no, una aplicación web. Una aplicación web
utiliza también páginas web para mostrar la información a los usuarios. Como
ejemplo veamos el sitio web de la universidad:
Podemos apreciar gran cantidad de elementos web como enlaces, texto,

contenido multimedia, imágenes, etcétera. En este caso estamos viendo la
página web de inicio del sitio web de la PUCP, es una página meramente
informativa. Pero si damos clic al enlace de Intranet y correo y luego de
seleccionar la opción de Campus Virtual llegaremos a la siguiente pantalla:
60
Lo que apreciamos ahí es la página de autenticación de la aplicación web de

intranet de la PUCP, como toda aplicación web presenta una página inicial de
logueo para poder ser accedida, ya que es una aplicación y debemos usar un
usuario y password de la misma manera que accedemos, por ejemplo, a
nuestras computadoras de casa.
3.2.- Concepto de servidor de aplicaciones
Ya sabemos qué es una aplicación web, ahora la siguiente pregunta que

podemos tener en mente es ¿dónde son guardadas o dónde se ejecutan esas
aplicaciones web? Así como los programas que usamos todos los días se
guardan y ejecutan en nuestro computador, las aplicaciones web se guardan y
ejecutan junto con todo el sitio en un servidor de aplicaciones. Se puede usar el
concepto de servidor de aplicaciones para nombrar al programa que ejecuta
nuestra aplicación web como también al equipo físico donde corre el servidor,
así un equipo físico puede ejecutar más de un servidor de aplicaciones.
3.3.- Habilitando nuestro servidor de aplicaciones en Netbeans
En el curso usaremos el servidor de aplicaciones Tomcat dado que es uno de los

más utilizados en el mundo real, además su configuración y uso es bastante
sencillo y más aun usándolo junto con Netbeans. No es necesario descargar ni
instalar nada adicional dado que al momento de la instalación de Netbeans
seleccionamos el servidor Apache Tomcat como parte de la instalación, por lo
que solo tenemos que poner en ejecución nuestro servidor. Pero ¿dónde
podemos encontrar nuestro servidor? Pues para ello revisemos nuevamente
nuestra sección de servicios, como se muestra a continuación:
61
Acá podemos apreciar que tenemos instalado el servidor de aplicaciones

Apache Tomcat 7.0.22.0. Si deseamos ver las propiedades de configuración,
damos clic derecho al nombre del servidor y seleccionamos la opción
Properties. No ahondaremos en detalles de configuración dado que con la
configuración por defecto que se establece al momento de la instalación es
suficiente. Para iniciar nuestro servidor hacemos clic derecho opción Start.
Apreciaremos que en la pestaña Output se escribe los mensajes de información
del Tomcat al momento de la inicialización:
Es en esta pantalla de salida donde se imprimirán los mensajes de salida que

podamos generar nosotros en nuestra aplicación o se imprimirán los errores que
puedan ocurrir en nuestra aplicación. Otro detalle a notar es que el ícono del
Tomcat cambia de esto a esto . Para
detener nuestro servidor nuevamente clic derecho en el nombre del servidor y a
continuación la opción Stop.
¿Qué otros servidores de aplicaciones para Java existen? Nombra algunos

ejemplos.
________________________________________________________________
________________________________________________________________
62
3.4.- Creando nuestra primera aplicación web con Netbeans
Los pasos para crear una aplicación web no varían mucho de los necesarios
para crear una aplicación Java sencilla, tal como vimos en el capítulo 1. La
aplicación que crearemos presentará un pequeño formulario que nos pedirá
nuestro nombre, apellidos y edad y nos mostrará una pantalla de bienvenida con
la información que le proporcionemos. Pasemos a revisar los pasos para crear
nuestra aplicación web:
- Vayamos a File, opción New Project. Se presentará la pantalla de nuevo

proyecto
- En Categories seleccionamos Java Web y en Projects seleccionamos

Web Application, se nos presentará la siguiente pantalla:
63
- Ponemos “Bienvenida” como nombre de proyecto y dejamos marcada la

opción de establecerlo como proyecto principal. Hacemos clic a Next para
pasar a la página de servidor y configuración, como se muestra a
continuación:
- En esta pantalla seleccionamos el servidor en el que se ejecutará nuestra

aplicación, en nuestro caso es el servidor Apache Tomcat que ya tenemos
configurado, luego seleccionamos también la version de JEE que
usaremos, también dejaremos la opción por defecto (Java EE 6 Web) que
viene integrada con Netbeans y finalmente el Context Path o ruta de
contexto, que es la dirección con la que podremos invocar a nuestra
aplicación web, por defecto tiene el mismo nombre del proyecto,
dejémoslo así. Finalmente hacemos clic en Finish y ya tenemos nuestro
proyecto web listo, con el archivo “index.jsp” que se muestra en la
pestaña de edición:
64
- Procedamos a ejecutar nuestra aplicación web simplemente haciendo clic

derecho al nombre de nuestro proyecto y luego opción Run, o también
presionando el botón Play de la barra de herramientas, ya que nuestro
proyecto es el proyecto principal. Con esta simple acción Netbeans
procederá a compilar el proyecto, instalarlo en nuestro servidor de
aplicaciones, inicializarlo y abrir una pestaña en nuestro navegador que
tengamos configurado por defecto para mostrarnos el contenido de
“index.jsp”, tal como se muestra a continuación:
- Como podemos ver, el contenido de nuestro “index.jsp” es muy parecido

al contenido de una página html y de hecho es el mismo. Un archivo jsp
permite la combinación de código HTML con contenido generado por la
aplicación web para la creación de páginas web dinámicas. Nuestra
aplicación web actualmente es meramente informativa, ya que podríamos
reemplazar ese sencillo texto por contenido web tal como imágenes,
enlaces, videos, etcétera, para la creación de una página más llamativa.
Pero el objetivo de una página web es proveer de un servicio, solicitando
información al usuario y devolviendo información de acuerdo a eso. Así
que vamos a crear una sencilla página de formulario, donde ingresaremos
nuestros nombres, apellidos y edad y la aplicación nos responderá con un
saludo, el cual cambiará de acuerdo a la información que le
proporcionemos.
3.5.- Mejorando nuestra aplicación añadiéndole procesado de

datos
Empecemos creando la página jsp con el formulario donde ingresaremos la

información:
- Vamos a la carpeta WEB-INF dentro de Web Pages en nuestro proyecto,

hacemos clic derecho opción New y a continuación en Folder:
65
- Pongámosle “JSP” como nombre y hagamos clic en Finish.
- A continuación hagamos clic derecho sobre la carpeta jsp y escojamos

New y a continuación JSP, se presentará la siguiente pantalla:
- Le ponemos “ingreso” como nombre, podemos apreciar también que se

muestra la información del proyecto así como nos permite seleccionar o
modificar la ubicación y la carpeta donde se guardará el archivo. Dejemos
las opciones por defecto. Hacemos clic en Finish.
- Copiemos el siguiente código dentro de la etiqueta body de nuestro JSP

recién creado:
-
66
- Las etiquetas form e input sirven para definir nuestro formulario y un

campo de texto donde ingresar información respectivamente. El input con
tipo submit nos permite crear un botón que se encargará de enviar la
información a un destino que nosotros definiremos. Ese destino lo
definimos precisamente en el atributo action de la etiqueta form. En este
caso estamos enviando la información a un elemento que es ubicado
mediante la ruta “formularioServlet”. El método indica la manera cómo
será enviada la información, básicamente hay 2 maneras: mediante un
GET, enviándose la información como parte de la dirección de la página,
o mediante un POST, donde la información se envía como parte de la
información interna del request. Ya explicaremos más adelante lo que es
un request.
- Habíamos indicado que la información es enviada a cierto elemento que

se encargará de leerla y procesarla. Los elementos encargados de esta
tarea son los llamados “servlets” que no son más que simples clases Java
encargados de recibir un request, procesar la información y devolver un
response cuyo contenido será mostrado por el navegador de Internet. Por
lo tanto pasemos a la creación de un “servlet”, que se encargará de
procesar la información enviada desde nuestro JSP.
- Para mantener el orden, creamos un paquete java donde guardar

nuestros “servlets”. Para ello hacemos clic derecho en la carpeta Source
Packages, opción New y a continuación Java Package; en la pantalla
que aparece procedemos a ingresar el nombre del paquete dejando las
demás opciones sin modificar.
- Hacemos clic derecho sobre la carpeta “servlet”, a continuación New y

finalmente seleccionamos la opción Servlet, aparecerá la siguiente
pantalla
67
- Llamémoslo “formularioServlet” y seleccionemos Next, tendremos lo

siguiente:
- Acá podemos apreciar 3 características de los “servlets”:
o Class Name: el nombre de la clase Java donde estará el código de

nuestro “servlet”.
o Servlet Name: el nombre interno del “servlet” mediante el cual
podrá ser reconocido e invocado por otras partes internas de la
aplicación (no desde el navegador web).
o URL pattern: esta es la ruta o dirección asociada a este “servlet” y
es precisamente la que pusimos en nuestro jsp en el atributo action
de la etiqueta form. Esa es la manera como se puede invocar al
“servlet” desde el navegador web. En el ejemplo, para mantener el
orden tiene el mismo nombre que el nombre interno y que el
nombre de la clase, pero en realidad puede ser cualquier cadena
de caracteres que deseemos. Una vez hecho esto seleccionamos
Finish y ya tenemos nuestro “servlet” creado.
- Pasemos ahora a analizar el código que hemos creado para nuestro

“servlet”, a continuación el código:
68
- Línea 20: ahí indicamos que el nombre interno del “servlet” será
“formularioServlet” y la url con la que podrá ser ubicado por el navegador
será “formularioServlet”, tal como definimos al momento de crearlo.
- Línea 21: definimos la clase “servlet” que hereda de HttpServlet; todo

“servlet” que procesa peticiones HTTP deberá heredar de HttpServlet y
sobrescribir el método processRequest.
- Línea 33: aquí sobrescribimos el método processRequest que recibe

como parámetros el request y el response. El request es un objeto de tipo
HttpServletRequest, cuya función principal es traer los valores enviados
desde la pantalla en la forma de parámetros. El response es un objeto de
tipo HttpServletResponse, cuya función es llevar la respuesta del servidor
hacia el navegador web para que este lo traduzca en contenido entendible
por las personas.
- Lineas 38 a la 41: estamos concatenando un conjunto de resultados; lo

más importante acá es ver cómo el “servlet” accede a los valores
enviados desde la página. Los valores viajan en el objeto request y
pueden ser accedidos con el método request.getParameter (“cadena”), es
importante notar que el valor que se pasa como cadena de texto tiene que
coincidir con el nombre del campo de texto en la página jsp.
- Línea 43: guardamos el resultado procesado como un atributo del objeto

request para poder ser leído desde otro jsp.
69
- Línea 45 hasta el 47: con el método request.getRequestDispatcher,

obtenemos una referencia al elemento al que vamos a redireccionar el
resultado del “servlet”. Debemos utilizar la ruta completa desde la carpeta
base de la aplicación en este caso “WEB-INF/jsp/resultado.jsp” Y luego
con el método forward procedemos a redirigir el objeto request y response
hacia el jsp para generar el resultado final.
 Los “servlets” son la base del desarrollo de aplicaciones web en

Java, actualmente existen muchos frameworks que proponen otros
tipos de clases para el procesamiento de información, pero al final
todos ellos son compilados y convertidos en “servlets”.
Ahora procedemos a crear el jsp resultado.jsp, a continuación su contenido:
Como podemos ver es código HTML con una etiqueta especial en la línea 15, en
ella estamos usando lo que se denomina un scriptlet. Un scriptlet es código Java
incrustado dentro de código HTML, en este caso es un scriptlet de asignación
mediante el que estamos obteniendo el atributo del objeto request cuyo nombre
es “textoResultado”. Así de esa manera obtenemos la cadena que generamos
con el “servlet”.
Ahora crearemos un “servlet” que se encargará de dirigir a la página de ingreso

de datos desde la página de inicio. Para ello crearemos el “servlet” inicio.java, a
continuación su código:
70
Y finalmente el código de la página inicio.jsp para poder invocar a la página de

ingreso de datos:
Podemos observar que en el atributo href de la etiqueta de enlace (línea 16)

contiene una referencia “inicio”, que es la dirección por defecto que se define al
momento de crear el “servlet”.
3.6.- Ejecutando nuestra aplicación modificada
Ya hemos visto cómo es el proceso de ejecución de una aplicación Java Web,

pues procedamos a ejecutarla nuevamente para ver los cambios que hemos
realizado. El proceso para la ejecución es dar clic al botón Play en nuestra barra
de herramientas si es que nuestra aplicación es la aplicación por defecto o hacer
clic derecho al nombre del proyecto, opción Run.
Una vez ejecutado se nos

presenta la pantalla de inicio
ahora mostrando el link hacia la
página de ingreso de datos.
Hacemos clic en el enlace “Ingreso de datos” y aparece la siguiente pantalla:
71
Procedemos a ingresar los datos y obtenemos la siguiente pantalla:
Es importante notar cómo en ambos casos desde el browser solo se está

utilizando la dirección definida al momento de crear el “servlet” (inicio o
formularioServlet) sin que el cliente tenga que saber nada respecto de la
implementación interna ni los paquetes ni carpetas donde se encuentran tanto
los “servlets” como los jsps utilizados para crear la vista del usuario. Esto es
muy importante desde el punto de vista de la seguridad ya que esconde a los
usuarios la implementación interna de la aplicación.
Da ejemplos de 5 frameworks para el desarrollo de aplicaciones web en Java.
________________________________________________________________
________________________________________________________________
3.7.- Ejecutando nuestra aplicación web en modo de inspección

(debug)
En el primer capítulo vimos cómo podíamos ejecutar nuestras aplicaciones en el
modo de inspección para poder ver en detalle su ejecución y el valor de sus
variables en un momento determinado en el tiempo. Ya sabemos que para
ejecutar el modo de inspección hacemos clic derecho al nombre del proyecto y a
continuación la opción Debug, previamente hemos definido algún breakpoint
donde se pueda detener la ejecución del programa. Definamos nuestros
breakpoint en la línea 38 de nuestra clase formularioServlet, tal como indica la
figura:
72
Ahora procedamos a ejecutar nuestra aplicación en modo de inspección (debug)

y procedamos a llenar los datos y enviarlos. La ejecución de nuestro programa
se detendrá en la línea donde colocamos el breakpoint, como se aprecia en la
siguiente figura:
También podemos apreciar que nuestro navegador se encuentra esperando la

respuesta del servidor debido a que se ha quedado en el estado Conectando:
Procedemos a ejecutar la sentencia de la línea 38 para poder obtener la cadena

final en la variable “resultado” y obtenemos lo siguiente en el inspector de
variables:
Es justamente ese valor el que es enviado e impreso en el JSP.
73
3.8.- Creando los javadocs de nuestro proyecto

Todo proyecto o conjunto de clases necesita de una documentación que
especifique las características de cada clase que lo compone. Esto es de vital
importancia sobre todo para que desarrolladores externos que deseen usar
nuestras clases puedan hacer un uso eficaz y eficiente de nuestras clases. Los
javadocs son la documentación de las clases java y pueden ser generados
rápido y fácilmente gracias a Netbeans.
Para la creación de nuestros javadocs simplemente hacemos clic derecho en el

nombre de nuestro proyecto y seleccionamos la opción Generate Javadoc, se
ejecutará la herramienta javadoc que viene integrada con el JDK de java y
recorrerá por todas las clases de nuestro proyecto, devolviéndonos una salida
como la siguiente:
Aquí podemos ver la relación de clases que han sido analizadas para la creación
del javadoc:
Y a continuación podemos ver la dirección donde ha sido creado el javadoc.

Como puedes ver no es nada más que un conjunto de páginas web:
74
Las cuales, finalmente, son abiertas en el navegador de Internet:
En la parte izquierda podrás ver la relación de todas las clases de nuestro

proyecto, en nuestro caso solo tenemos 2 clases correspondientes a nuestros 2
“servlets”. En la parte derecha se puede ver el resumen de cada clase y un link
para ver el detalle de cada una, veamos el detalle de la clase formularioServlet:
75
Sus partes son las siguientes:
1. Detalle de la jerarquía completa de la clase, así como la relación de

interfaces que implementa
2. Detalle del código conteniendo la declaración de la clase
3. Resumen de sus constructores y de sus métodos
Y finalmente el detalle de cada uno de sus métodos:
 Un JSP, a pesar de parecerse mucho a una página HTML, en el

fondo, pasa por un proceso de transformación donde es convertido
en un “servlet” y finalmente compilado como un “servlet” más.
76
Javadocs trabaja mediante la utilización de un conjunto de palabras especiales

tales como @param o @throws, da otros ejemplos de palabras especiales de
Javadocs.
________________________________________________________________
________________________________________________________________
Ejercicio propuesto: modificando nuestra aplicación de ejemplo
Vamos a modificar la aplicación desarrollada a lo largo del capítulo de la

siguiente manera:
- Crear un segundo enlace en la página de inicio que llame a una pequeña

aplicación que se encargue de convertir dólares a soles.
- La página deberá contener un título y un campo donde poner la cantidad

en dólares. Asimismo deberá contener 2 botones, uno para enviar la
información para ser convertida y otro para regresar a la pantalla de inicio.
- Crear otra página donde se mostrará el resultado de la operación o el

mensaje de error en caso que el usuario no haya ingresado los datos o
haya ingresado letras en vez de números.
- Modificar nuestra página de ingreso de datos agregando DNI, Dirección,

Estado civil y Profesión. Se deben hacer las siguientes validaciones:
o DNI no debe contener más de 8 dígitos y solo debe contener

números.
o Dirección no debe contener más de 50 caracteres.
- Se debe modificar resultados resultado.jsp para poder mostrar el

resultado del ingreso de datos o los mensajes de error producto de las
validaciones.
- Asimismo resultado.jsp debe tener un botón para regresar a la pantalla de

inicio.
77
¿Cuánto aprendí?
1. Context Path: _______________________________
_______________________________
_______________________________
2. Servlet: _______________________________
_______________________________
_______________________________
3. JSP: _______________________________
_______________________________
_______________________________
4. Scriptlet: _______________________________
_______________________________
_______________________________
78
1. ¿Cómo dirigimos el flujo de la aplicación hacia un JSP desde un “servlet”?
_______________________________________________________________
_______________________________________________________________
2. ¿Qué es un servidor de aplicaciones?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
3. ¿Qué es un sitio web, una página web y una aplicación web, en qué se
diferencian?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
4. ¿Cuáles son las partes de un documento de javadocs generado?
_______________________________________________________________
_______________________________________________________________
_______________________________________________________________
79

Netbeans PDF

Cargado por

Información del documentohacer clic para expandir la información del documento

Información del documentohacer clic para expandir la información del documento

Copyright:

Formatos disponibles

Netbeans PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Netbeans PDF

Cargado por

Copyright:

Formatos disponibles

Netbeans con tendencia a

Héctor Erick Oscátegui Torres Desarrollo del libro

Derechos reservados. Prohibida la reproducción de este libro por cualquier

La información puesta a disposición a través de las referencias bibliográficas

Las marcas registradas son propiedad de sus respectivas compañías.

Esta publicación ha sido producida empleando Microsoft Office Word.

Las siguientes marcas son de propiedad exclusiva de la Pontificia Universidad

“Netbeans con tendencia a aplicación web”

Netbeans con tendencia a aplicación web.

Al finalizar, el alumno comprenderá la herramienta Netbeans y sus diferentes

Bienvenido al curso de Netbeans con

Netbeans es uno de los programas más utilizados para el desarrollo de

1.1.- Introducción a Netbeans

1.2.- Instalación de Netbeans

- Nos dirigimos a la página http://netbeans.org/downloads/index.html, como

- Hay diferentes versiones de Netbeans para descargar, cada una

- Procedemos a seleccionar Apache Tomcat 7.0.22 como servidor de

- Seleccionamos la casilla aceptando la licencia, como indica la figura, le

- El curso no incluirá JUnit; por lo tanto, seleccionamos la opción “Do not

- Luego, aparecerá la pantalla para especificar la ubicación del servidor

- Luego de darle Next a la pantalla anterior, aparecerá otra con el resumen

- Finalmente, procedemos a hacer clic al botón Install para empezar la

- Procedemos a darle clic al botón Finish.

1.3.- Entorno de aplicación

Procedemos a iniciar Netbeans, haciendo doble clic en el ícono Netbeans IDE

Las partes del entorno por defecto son las siguientes:

1. Barra de menú: permite acceder a todas las opciones y características

1.4.- Noción de proyecto Netbeans

Netbeans define el desarrollo de aplicaciones bajo el concepto de un proyecto.

ventana Projects y su estructura dependerá exclusivamente del tipo de

1.5.- Creando nuestra primera aplicación Java con Netbeans

1.5.1- Creando nuestro proyecto

El primer paso para la creación de nuestra aplicación será la creación del

- En el menú principal nos dirigimos a la opción File y luego a New

- En la sección Categories, escogemos la carpeta Java y en la sección

- La pantalla cuenta con las siguientes opciones:

1. Project Name: el nombre del proyecto

- Finalmente, seleccionamos la opción Finish. Con eso hemos terminado

1.5.2- El entorno de trabajo de Netbeans al detalle

- Luego de terminar de crear nuestro proyecto con nuestra clase principal,

Podemos apreciar 4 secciones bien diferenciadas. Vamos a ir viéndolas

- Empecemos por la sección de manejo de proyectos en la parte superior

1. Projects: como su nombre lo

2. Files: nos muestra las carpetas

3. Services: contiene una lista de los

- A continuación, en la parte superior derecha, tenemos al editor Java. Esta

- Este editor contiene la siguientes partes:

1. Sección de etiquetas: el editor de texto trabaja bajo el concepto de

2. Sección de desplazamiento entre archivos: cuando tenemos

3. Sección de vistas: acá encontramos dos opciones, una para ver el

4. El editor también posee una barra de herramientas que nos

5. Sección de numeración de línea: lo más importante de esta sección

6. Barra de posicionamiento: Esta barra nos indica de manera gráfica,

- En la parte inferior izquierda, tenemos el

- Finalmente, en la parte inferior derecha, tenemos la sección de tareas o

- Como podemos ver en la imagen, la ventana nos muestra la relación de

1.5.3- Utilización de editor