3. Nivel Avanzado

¡DOMINANDO JAVA - NIVEL AVANZADO!

En esta sección del curso, te adentrarás en las complejidades de Java que te llevarán a dominar temas vitales en el desarrollo de software. Como lo es el manejo de excepciones. Posteriormente con Entrada/Salida (E/S) aprenderás a realizar un correcto flujo de datos. Así mismo obtendrás conocimientos sobre los fundamentos de la programación gráfica en Java para crear interfaces de usuario atractivas y funcionales. Y, por último, te guiaremos a través de los principios esenciales de las buenas prácticas de programación, ayudándote a escribir código limpio, legible y fácil de mantener.

10. Manejo de excepciones:

En el desarrollo de software, el manejo de excepciones es una habilidad fundamental para asegurar la estabilidad y confiabilidad de tus programas. En Java, puedes utilizar bloques try-catch para capturar y controlar excepciones específicas que podrían ocurrir durante la ejecución de tu código. Además, la posibilidad de lanzar tus propias excepciones te permite manejar situaciones personalizadas de manera eficaz. Es importante entender los distintos tipos de excepciones en Java, que se dividen en dos categorías principales: excepciones comprobadas y no comprobadas Al comprender la jerarquía de excepciones en Java, podrás escribir un código más sólido y resistente a fallos.

Ejemplos más comunes de excepciones:

• Tratar de convertir a entero un String que no contiene valores numéricos.
• Tratar de dividir por cero.
• Abrir un archivo de texto inexistente o que se encuentra bloqueado por otra aplicación.
• Conectar con un servidor de bases de datos que no se encuentra activo.
• Acceder a subíndices de vectores y matrices fuera de rango.

• Try-catch y lanzamiento de excepciones:

El bloque try-catch se utiliza para ejecutar un fragmento de código en el que existe la posibilidad de que se produzca una excepción. Los bloques try y catch son dos bloques de código separados – el bloque catch se ejecuta cuando el bloque try no se ejecuta normalmente

También hay un bloque finally que puede utilizar para ejecutar algún código independientemente de que se produzca o no una excepción. El código de este bloque se ejecutará en todos los casos.

• Tipos de excepciones en Java:

Comprobadas: Este tipo de excepciones son capturadas por el compilador en tiempo de compilación. Algunas de las excepciones comprobadas en java incluyen IOException y SQLException.

Por ejemplo: Una IOException puede ocurrir en java si hay un problema con el proceso de entrada/salida. Suele producirse cuando se intenta acceder a un archivo y a su contenido, pero el archivo no existe o hay un problema con la lectura de su contenido.

No comprobadas: El compilador no es consciente de estas excepciones en tiempo de compilación porque se hacen evidentes en tiempo de ejecución. Se verifican cuando se ejecuta el código. Las excepciones no verificadas incluyen la ArrayIndexOutOfBoundsException y la IllegalStateException.

Por ejemplo: Un array es una estructura de datos que almacena valores del mismo tipo de datos y cada valor tiene un índice que empieza en 0 y llega hasta (n-1) donde n es el número total de valores presentes en el array. Puede acceder a un elemento especificando el índice con el nombre de la variable que hace referencia al array:

Ahora bien, si intenta acceder a un elemento con un índice menor que 0 o mayor que (n-1), se producirá una excepción porque no hay ningún elemento en ese índice concreto. Este tipo de excepción se conoce como ArrayIndexOutOfBoundsException y se produce en tiempo de ejecución.

11. Entrada/salida (E/S):

La entrada y salida de datos, también conocida como E/S, es una parte esencial del desarrollo de aplicaciones Java. A través de los siguientes aspectos, podrás comprender cómo manejar la E/S en Java de manera efectiva:

• Lectura y escritura de datos desde/hacia consola.

La entrada o lectura de datos en Java es uno de los conceptos más importantes y fundamentales al momento de interactuar con el usuario de nuestro programa. La entrada de datos en Java, a diferencia de otros lenguajes es un poco complicada (no demasiado) y existen diferentes formas de hacerlo, unas más complejas que otras. En esta sección veremos dos maneras sencillas de leer datos para nuestro programa en Java, veremos entonces dos formas de leer datos del usuario por teclado. La primera usando las clases BufferedReader y InputStreamReader ambas de la librería java.io y la segunda con la clase Scanner de la librería java.util.

Comencemos entonces nuestros ejemplos para la lectura por teclado en Java usando la clase BufferedReader y InputStreamReader.

Lectura de datos por teclado con BufferedReader y InputStreamReader

La entrada de datos con estas dos clases se puede hacer un menos de tres líneas según lo que necesitemos hacer, veremos cómo leer números y texto y las particularidades de ambos casos al usar estas clases.

Como pudimos ver en el código anterior, ha sido bastante sencillo obtener la entrada del usuario y almacenar ese valor en una variable. El único "problema" es que BufferedReader únicamente posee el método readLine() para leer la entrada y este siempre retorna String, de modo que para obtener un número debemos leer primero como String y luego enviarle dicho String al método parseInt() de la clase Integer. Hay que ser muy cuidadosos con Integer.parseInt() pues si el usuario no ingreso un número sino letras, se disparará una excepción que debemos controlar (más adelante veremos esto con detalle).

Lectura de entrada por teclado usando la clase Scanner

La clase Scanner de la librería java.util es también muy sencilla para obtener datos de entrada del usuario, a diferencia de BufferedReader, Scanner si posee un método para la lectura de números y para la lectura de texto que nos ayudarán a facilitar un poco las cosas, veamos:

Con este código hemos podido realizar la lectura de datos del usuario muy fácil, pues ya no nos tuvimos que preocupar por el tipo de dato, solo debemos usar el método adecuado según sea entero, String, float, etc.

Salida de datos. Impresión de mensajes por pantalla en Java. Uso de print y println

La primera pregunta que surge al ver los métodos útiles para salida de datos en Java es en qué se diferencian (print() vs println()), básicamente ambos son útiles para mostrar texto por pantalla y la única diferencia es que println() muestra el texto y luego deja un salto de línea (como si presionara enter) mientras que print() no lo hace, veamos un ejemplo para conocer bien la diferencia:

Muy bien, si ejecutamos este código, vamos a ver que el primer ciclo imprime los números del 10 al 1 dejando una línea entre cada número, mientras que el segundo imprime todos los números continuos sin dejar ningún espacio entre ellos.

Ahora bien, a veces es necesario imprimir en pantalla mensajes más complicados y necesitamos hacer uso de variables para ello y componer mensajes, así que veamos un ejemplo de otras formas de imprimir datos en Java.

Concatenando y mostrando variables por pantalla

En el anterior código vimos que podemos incluir nuestros propios mensajes unidos con valores de variables y que los podemos unir (concatenar) con el operador + (como si estuviéramos sumando texto). Pero hay un detalle importante, hay que ser cuidadosos al momento de concatenar números y operaciones numéricas (especialmente la suma) pues podríamos tener errores. Si nos fijamos en el penúltimo println() quisimos poner hora + 2 sin embargo Java entendió que queríamos unir (concatenar) el valor de hora con un dos, dándonos como resultado un 122 en vez del 14 que esperábamos, para solucionar esto, debemos poner la operación matemática entre paréntesis, para que Java comprenda que queremos que primero realice esa operación de suma y luego lo concatene, obteniendo así un 12 + 2 = 14 como esperábamos.

12. Introducción a la programación gráfica:

Java Swing, una poderosa biblioteca gráfica, te permite crear interfaces de usuario dinámicas y atractivas para tus aplicaciones Java. Con Java Swing, puedes crear fácilmente interfaces de usuario simples y funcionales que satisfagan las necesidades de tus usuarios. A través de la creación de componentes básicos como ventanas, botones, campos de texto y etiquetas, podrás diseñar interfaces de usuario intuitivas y fáciles de navegar.

• Creación de interfaces de usuario simples con Java Swing.

Componentes:

En la programación orientada a objetos los componentes son Clases/Objetos que implementan la interfaz gráfica de usuario. Los componentes básicos proporcionados por la biblioteca Java Swing son:

• JButton
• JCheckBoxName
• JLabelGenericName
• JTextAreaName
• JTextFieldName
• JPasswordField
• JRadioButtonName
• JOptionPane

Etiqueta (JLabel)

Estos componentes pueden ser usado para mostrar textos simples, imágenes con textos. También pueden ser usados para mostrar los resultados de un proceso. Los métodos más usados son:

• setText() - Permite colocar un valor de texto, puede ser usado para mostrar un resultado en este componente.
• setFont() - Permite definir el tipo y el estilo de la fuente (negrita y/o cursiva) y el tamaño de la fuente.
• setIcon() - Permite que un ícono o una imagen sea usada y mostrada en la pantalla.

Cajas de Texto (JTextField, JPasswordField y JTextArea)

Estos componentes son usados para que el usuario introduzca un valor textural y capturarlo. JTextField permite introducir una línea de texto, JPasswordField permite introducir un valor, pero lo muestra camuflado para no poder ver el valor introducido y JTextArea permite introducir varias líneas de texto. Los métodos más usados son:

• setText() - Permite colocar un valor de texto, puede ser usado para mostrar un resultado en este componente.
• getText() - Permite recuperar el valor de una caja de texto.
• setFont() - Permite definir el tipo y el estilo de la fuente (negrita y/o cursiva) y el tamaño de la fuente.
• setEnabled() - Permite que la escritura sea deshabilitada y puede ser usado para mostrar un resultado como en un JLabel.

Botones (JRadioButton, JCheckBox y JButton)

Estos componentes permiten varias formas gráficas con las cuales el usuario puede interactuar, el JRadioButton permite elegir una opción dentro de un grupo de elecciones, en cuanto al JCheckBox permite seleccionar más de una de estas opciones. Finalmente, los JButton son usados para ejecutar un evento cuando son presionados.

Listas Desplegables (JComboBox)

Parecido al JRadioButton, permite seleccionar una opción de un grupo de alternativas, pero sin ocupar espacio en la pantalla.

Cajas de Diálogo (JOptionPane)

Este permite mostrar una caja con un mensaje, un icono y botones. Un código de ejemplo sería:

El segundo y tercer parámetro indican el mensaje y el título, estas cajas pueden ser usadas para mostrar mensajes de confirmación, errores, avisos entre otras posibilidades.

Jerarquía de Componentes

Ahora que ya vimos sobre los componentes, podemos hablar sobre la jerarquía existente entre ellos dentro de la biblioteca Swing. Este rango es utilizado en la funcionalidad de estos elementos para la comprensión de una aplicación Swing y es comúnmente visualizada como un árbol de componentes.

Este árbol trabaja con tres tipos de elementos en una aplicación:

Contenedor de nivel superior: Es un elemento que generalmente se usa como base, es decir, proporcionar un lugar para usar otros elementos. Ejemplos de este tipo serían: JFrame, JDialog y JApplet.

Componente de nivel intermedio: Es un elemento que se usa solo para manejar la ubicación de los elementos de botones y etiquetas. Ejemplos de este tipo serían: JPanel, JScrollPane y JTabbedPane.

Contenedor Atómico: Es un elemento que no se usa para almacenar otros elementos, es una entidad autosuficiente, que sirve para presentar información al usuario o para recibir información proporcionada por el usuario. Algunos de los ejemplos de este tipo son: JButton, JLabel, JComboBox, JTextField y JTable.

Al utilizar JFrame, este componente acaba creando otros tres componentes, estos de tipo intermedio, se utilizan para configuraciones avanzadas de la interfaz gráfica: Root Pane, Layered Pane y Glass Pane. Este artículo fue diseñado para presentar Swing, por lo que no profundizaremos en estos componentes:

Considerando este diagrama, podemos crear una ventana con Swing como lo demuestra el siguiente ejemplo práctico:

Resultado del código:

13. Principios de buenas prácticas de programación:

El seguimiento de los principios de buenas prácticas de programación es esencial para mantener un código limpio, legible y fácil de mantener. Las convenciones de nomenclatura clara y consistente son fundamentales para asegurar que otros desarrolladores puedan entender tu código de manera efectiva. Además, el uso de comentarios y documentación adecuada te permite explicar la lógica de tu código y sus funcionalidades, facilitando la colaboración y el mantenimiento a largo plazo. Al seguir estas prácticas, podrás desarrollar código robusto y escalable que cumpla con los estándares de calidad de la industria y sea fácil de mantener y extender.

• Convenciones de nomenclatura.

La elección de nombres adecuados para variables, clases y métodos es esencial para garantizar la comprensión clara del código. Al seguir las convenciones de nomenclatura de Java, como CamelCase para nombres de clases y métodos, y lowerCamelCase para variables, podrás mejorar la legibilidad de tu código y facilitar la comprensión tanto para ti como para otros desarrolladores.

Además, asignar nombres descriptivos y significativos a tus variables y métodos ayudará a comunicar su propósito y funcionalidad, lo que resultará en un código más fácil de entender y mantener a lo largo del tiempo.

• Comentarios y documentación.

La documentación clara y concisa es esencial para explicar el propósito y el funcionamiento de tu código a otros desarrolladores. Al agregar comentarios explicativos en tu código, puedes proporcionar detalles adicionales sobre la lógica subyacente, la función de métodos específicos y la razón detrás de ciertas decisiones de diseño. Además, el uso de documentación en el estilo Javadoc para generar documentación legible automáticamente puede ayudar a otros programadores a comprender rápidamente el propósito y el uso de tus clases y métodos. Al seguir estas prácticas, tu código será más transparente y accesible para otros miembros del equipo de desarrollo, lo que facilitará la colaboración y el mantenimiento a largo plazo del proyecto:

Comentarios en Java de una sola línea:

Pueden ser colocados en cualquier parte de nuestro código en Java y comienzan por un doble slash "//", al colocar el doble slash en cualquier línea de código, todo lo que haya de ahí en adelante en dicha línea será tomado como comentario, ten en cuenta que el doble slash solo convierte en comentario al texto que haya justo después de éstos y que pertenezca a su misma línea, las líneas de abajo de este, no se verán afectadas, tal como es de esperarse, el doble slash "//", solo afecta una línea desde el lugar donde se colocan:

Comentarios en Java de múltiples líneas:

Los comentarios multi-línea en Java tal como el nombre lo indica nos permiten comentar varias líneas de nuestro código Java de manera mucho más sencilla en vez de esta añadiendo doble slash "//" a cada línea. Estos comentarios van cerrados entre "/*" y "*/", es decir comienzan donde se ponga "/*" y terminan donde esté el "*/". Estos comentarios funcionan de manera similar a los comentarios de una sola línea, pero deben tener un comienzo y un final. A diferencia de los comentarios de una sola línea, al poner el símbolo "/*" todo el código que haya tanto en la misma línea, como en las líneas posteriores de este se convertirán en comentarios hasta que pongamos el "*/", de manera que, si iniciamos un comentario de múltiples líneas, debemos cerrarlo, tal como sucede con las llaves o los corchetes en Java.

Comentarios de documentación en Java (Javadoc):

Los comentarios de documentación, también conocidos como Javadoc, son de especial utilidad al momento de documentar no sólo el código fuente, sino el proyecto como tal. Por medio de herramientas externas, podremos generar de forma automática la documentación de un proyecto Java, a partir de estos comentarios de documentación o Javadocs.

Estos comentarios van cerrados entre "/**" y "*/", es decir comienzan donde se ponga "/**" y terminan donde esté el "*/". Nótese que los comentarios de documentación, a diferencia de los comentarios de múltiples líneas, inician con "/**" (doble asterisco) en lugar de "/*" (un solo asterisco). Adicionalmente, se recomienda que cada línea que compone el bloque de comentarios inicie con "*".

Estos comentarios además requieren de algunos "componentes" para indicar los componentes del código fuente, tales como parámetros, tipos de retorno, entre otros. Estos "componentes" se normalmente se preceden por un @, por ejemplo, para indicar un parámetro de una función de usa @param, o para indicar detalles sobre el retorno se usa @return.