La depuración o debug permite ejecutar un programa de forma interactiva, paso a paso, y examinar los valores de las variables. Esto proporciona información para comprobar el funcionamiento de un programa o descubrir la causa de un error que las trazas no explican suficientemente.
El depurador permite establecer puntos de ruptura, continuar la ejecución línea a línea o hasta el siguiente punto de ruptura e inspeccionar los valores de las variables. Los entornos integrados de desarrollo o IDE de Java, como IntelliJ IDEA y Eclipse, ofrecen soporte para hacer depuración.
Qué es la depuración de un programa
La depuración o debug es una forma de ejecución de un programa con la que el programador puede observar de forma interactiva la ejecución línea a línea del código fuente con el objetivo de eliminar algún error.
El depurador o debugger es una aplicación que permite añadir puntos de ruptura o breakpoints donde el depurador para la ejecución, inspeccionar los valores de las variables, continuar la ejecución hasta la siguiente línea o hasta el siguiente punto de ruptura, continuar la ejecución entrando en una función o sin entrar en la función.
Pocos programas están libres de errores, y algunos errores se producen cuando se cumplen determinadas condiciones en los datos que maneja una aplicación. En ocasiones descubrir la causa de un error es suficiente si la aplicación emite trazas, pero en los errores más complicados o con poca información se requiere depurar el programa.
La depuración se emplea durante el desarrollo o para reproducir y descubrir en el entorno de desarrollo local un error que se está produciendo en producción. Por la utilidad de la depuración, todos los lenguajes ofrecen alguna posibilidad de hacer depuración.
Errores de compilación y errores lógicos
Durante el proceso de desarrollo de software se pueden producir dos tipos de errores: errores de compilación o errores lógicos. Cuando se desarrolla una aplicación en un IDE, si al escribir una sentencia olvidamos un punto y coma, hacemos referencia a una variable inexistente o utilizamos una sentencia incorrecta, se produce un error de codificación.
Cuando ocurre un error de codificación, el entorno proporciona información sobre dónde se produce y cómo poder solucionarlo. Los errores lógicos, comúnmente llamados bugs, no evitan que el programa se compile con éxito, ya que no hay errores sintácticos ni se utilizan variables no declaradas.
Para solucionar este tipo de problemas, los entornos de desarrollo incorporan una herramienta conocida como depurador. El depurador permite supervisar la ejecución de los programas para localizar y eliminar los errores lógicos.
Un programa debe compilarse con éxito para poder utilizarlo en el depurador. El proceso de depuración se lleva a cabo añadiendo puntos de interrupción y comprobaciones en el código y ejecutándolo en el depurador.
Ejemplo inicial: depurar una clase contador en Eclipse
Para poder comprobar algunas de las funciones de depuración que ofrece Eclipse, se puede crear un proyecto en Java con una clase de inicio y una clase encargada de realizar una cuenta.
Clase Test
La clase Test crea un objeto de tipo Contador, ejecuta el método contar y muestra el resultado obtenido.
El código de la clase es el siguiente:
public class Test {
public static void main(String[] args) {
Contador contador = new Contador();
contador.contar();
System.out.println("Cuenta: " + contador.getResultado());
}
}
Clase Contador
La clase Contador mantiene el resultado en un atributo privado, ofrece un método para consultarlo y suma progresivamente los valores del uno al cien.
El código de la clase es el siguiente:
public class Contador {
private int resultado = 0;
public int getResultado() {
return resultado;
}
public void contar() {
for(int i=0; i < 100 ; i++) {
resultado = resultado + i + 1;
}
}
}
Este ejemplo permite observar la creación de objetos, la llamada a métodos, la ejecución de un bucle, la modificación del estado de un objeto y la consulta de variables durante la ejecución.
Iniciar la depuración en Eclipse
Existen varias alternativas para lanzar la ejecución de un programa en modo debug. Una de ellas consiste en pulsar con el botón derecho del ratón sobre la clase de inicio del proyecto, que implementa el método main, y seleccionar en el menú contextual «Depurar como => Aplicación Java».
En modo depuración, Eclipse ofrece la posibilidad de trabajar con la perspectiva de depuración, que incluye vistas para visualizar y cambiar variables, consultar los puntos de parada establecidos y examinar la pila de llamadas, entre otras funciones.
Qué permite hacer un depurador
El depurador permite añadir puntos de ruptura en cualquiera de las líneas del código fuente del programa para que la ejecución se detenga cuando llegue a ese punto.
Una vez detenida la ejecución, el depurador permite examinar los valores de las variables disponibles en el ámbito de detención. También permite continuar entrando al código de una función, saltar a la siguiente línea de código o continuar la ejecución hasta el siguiente punto de ruptura.
Los puntos de ruptura se pueden habilitar o deshabilitar, por lo que no es necesario eliminarlos para que dejen de tener efecto.
Puntos de ruptura de línea
Un punto de ruptura de línea suspende la ejecución al llegar a una línea de código concreta. Es el tipo de punto de ruptura más habitual para analizar el flujo de un método, comprobar los valores de las variables y localizar la instrucción que produce un resultado inesperado.
Puntos de ruptura de método
Un punto de ruptura de método suspende la ejecución al entrar o salir de un método. Resulta útil cuando se necesita comprobar cuándo se invoca una operación y desde qué parte del programa se realiza la llamada.
Puntos de observación de variable
Un punto de ruptura de variable suspende la ejecución al leer o escribir una variable. Puede ayudar a localizar el punto exacto en el que un atributo adquiere un valor incorrecto.
Puntos de ruptura de excepción
Un punto de ruptura de excepción suspende la ejecución cuando se lanza una excepción. En este caso no depende de una referencia de código concreta.
Es posible añadir un punto de ruptura implícito para que el programa se detenga antes de lanzar cualquier excepción o una excepción específica. Esto resulta útil cuando el programa termina con un error y la traza no permite localizar con rapidez el origen del problema.
Configurar la máquina virtual Java para hacer debug
Para depurar un programa Java es necesario configurar la máquina virtual Java o JVM en modo debug. Esta configuración se realiza añadiendo determinados argumentos al comando que inicia la aplicación.
Estos argumentos indican a la máquina virtual que acepte conexiones de red para realizar la depuración desde un IDE de forma remota o desde la máquina local.
- -agentlib:jdwp: habilita el protocolo de depuración JDWP en la máquina virtual.
- transport=dt_socket: utiliza una conexión de red para las conexiones de depuración.
- server=y: hace que la máquina virtual escuche conexiones de los depuradores.
- server=n: hace que el proceso intente conectarse a un depurador en vez de esperar conexiones.
- suspend=n: permite que la aplicación se inicie y ejecute con normalidad hasta que un depurador se conecte.
- suspend=y: impide que la aplicación comience hasta que un depurador se conecte.
- address=5005: indica el puerto en el que la máquina virtual acepta conexiones.
Depuración con el comando java
Si la aplicación se inicia con el comando java, hay que añadir los argumentos de depuración a la orden de ejecución.
$ java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 -classpath "target/classes:libraries/*" io.github.picodotdev.blogbitix.java8.helloworld.Main
Depuración con Gradle
Durante el desarrollo, si se emplea Gradle como herramienta de construcción, también es posible arrancar la máquina virtual de la aplicación en modo depuración a la espera de la conexión del depurador.
El siguiente comando inicia la depuración en el puerto 5005:
$ ./gradlew run --debug-jvm
Listening for transport dt_socket at address: 5005
También se pueden especificar los mismos parámetros de la máquina virtual que al ejecutar directamente la aplicación Java mediante la variable de entorno GRADLE_OPTS.
$ GRADLE_OPTS="-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005" ./gradlew run
Listening for transport dt_socket at address: 5005
La configuración del debug también se puede especificar en el archivo de construcción del proyecto.
run {
debugOptions {
enabled = true
server = true
suspend = true
port = 5005
}
}
Después se puede iniciar la aplicación con el siguiente comando:
$ ./gradlew run
Listening for transport dt_socket at address: 5005
Depurar una aplicación Java con IntelliJ IDEA
Una vez arrancada la máquina virtual en modo depuración, hay que configurar IntelliJ IDEA para que se conecte a la máquina virtual mediante una configuración de inicio de la aplicación o uniendo el IDE a un proceso local de la máquina virtual en modo depuración desde el menú Run > Attach to Process.
Añadir puntos de ruptura en IntelliJ IDEA
Añadir un punto de ruptura se hace desde el espacio vertical del editor del código fuente al inicio de cada línea. De forma alternativa, la combinación de teclas Ctrl+F8 añade un punto de ruptura en la línea de edición actual.
También se puede establecer un punto de ruptura haciendo clic con el botón izquierdo en el panel lateral izquierdo o haciendo clic en la ubicación del código y presionando Ctrl+F8.
Los puntos de ruptura pueden ser de línea, de método, de variable o de excepción.
- De línea: suspende la ejecución al llegar a esa línea de código.
- De método: suspende la ejecución al entrar o salir del método.
- De variable: suspende la ejecución al leer o escribir en la variable.
- De excepción: suspende la ejecución cuando se lanza una excepción.
Si una declaración tiene una expresión lambda, IntelliJ IDEA permite elegir si el punto de ruptura se coloca en toda la declaración o específicamente en la expresión lambda.
Los puntos de ruptura se pueden eliminar siguiendo los mismos pasos utilizados para agregarlos. También se pueden desactivar o silenciar sin eliminarlos.
Para consultar la lista de puntos de ruptura se puede acceder a la sección Debug y localizar el icono correspondiente, o utilizar la combinación Ctrl+Shift+F8.
Controles de ejecución en IntelliJ IDEA
| Acción | Atajo | Función |
|---|---|---|
| Step over | F8 | Continúa sin entrar en la función. |
| Step into | F7 | Entra en la función y ejecuta el código paso a paso. |
| Step out | Shift+F8 | Sale de la función actual. |
| Hasta la posición del cursor | Alt+F9 | Continúa hasta llegar a la posición del cursor. |
| Continuar | F9 | Continúa la ejecución hasta el siguiente punto de ruptura. |
Cuando el programa se detiene en un punto de ruptura, los valores de las variables del contexto donde se ha detenido la ejecución se pueden inspeccionar. En ese contexto se puede consultar, por ejemplo, el valor del array que contiene los argumentos del programa.
Depurar código Java con Eclipse
Eclipse ofrece un depurador para aplicaciones Java. Permite iniciar una aplicación en modo depuración, conectarse a una máquina virtual externa configurada con soporte para depuración, establecer puntos de ruptura con la combinación Ctrl+Shift+B, continuar la ejecución cuando se ha suspendido e inspeccionar los valores de las variables.
Los puntos de ruptura se crean con la combinación Ctrl+Shift+B o haciendo clic con el botón derecho desde el espacio vertical del editor del código fuente al inicio de cada línea.
Controles de ejecución en Eclipse
| Acción | Atajo | Función |
|---|---|---|
| Step over | F6 | Continúa sin entrar en la función. |
| Step into | F5 | Entra en la función. |
| Step out | F7 | Sale de la función actual. |
| Hasta la posición del cursor | Ctrl+R | Continúa hasta la posición del cursor. |
Ejemplo práctico de depuración paso a paso
Para depurar un programa es recomendable establecer un punto de ruptura en una línea que permita observar el inicio de una operación relevante. Una vez detenido el programa, se pueden examinar las variables y avanzar por el código con las opciones de ejecución paso a paso.
Durante la depuración se puede observar la línea que se ejecutará a continuación, consultar los valores que toman las variables y comprobar cómo cambia el estado de los objetos después de cada instrucción.
Flujo de trabajo con el ejemplo Contador
- Crear las clases Test y Contador.
- Compilar el proyecto.
- Establecer un punto de ruptura dentro del método contar.
- Iniciar la clase Test en modo depuración.
- Observar el valor inicial de resultado y el valor de i.
- Avanzar línea a línea dentro del bucle.
- Comprobar cómo cambia resultado después de cada iteración.
- Continuar la ejecución hasta que el método termine.
- Verificar el valor mostrado por la instrucción System.out.println.
En cada iteración del bucle, la instrucción resultado = resultado + i + 1 modifica el estado del objeto. La inspección de las variables permite comprobar si el valor de i coincide con la iteración esperada y si resultado se actualiza correctamente.
Ejemplo de localización de una excepción
Un proyecto de ejemplo sobre la producción de miel permite observar cómo la depuración ayuda a encontrar un error que provoca una excepción y otro que produce un resultado incorrecto sin detener la aplicación.
El proyecto contiene las clases Bee, una abeja obrera ordinaria; BeeQueen, la abeja reina; BeeHive, la colmena; HoneyPlant, una planta de miel de la que se recoge néctar; y Main, donde se encuentra el método public static void main().
El comportamiento esperado es que la cantidad de miel recolectada, representada mediante un valor double, sea igual a la mitad del néctar recogido.
Si se ejecuta el método main(), el programa no calcula correctamente la cantidad de miel y además lanza una excepción. La investigación comienza observando la pila de llamadas.
En la pila de seguimiento se puede comprobar que la excepción se lanzó en HoneyPlant.java:20. Al ejecutar el método main() en modo depuración, el programa se detiene justo antes de lanzar la excepción.
En la sección Debug se pueden consultar las variables disponibles. En este caso, el valor de nectar es 1.0 y el valor de nectarCapacity es -1.0.
La excepción parece tener sentido porque una planta de miel no puede tener una cantidad negativa de néctar. Sin embargo, el problema está en que el programa comprueba la variable incorrecta.
En las líneas correspondientes a la comprobación se verifica si el suministro de néctar está agotado:
if (nectar == 0) {
return 0;
}
El programa comprueba el valor del parámetro nectar, que representa la cantidad de néctar que se desea sacar de la flor, en lugar de comprobar la cantidad de néctar disponible almacenada en nectarCapacity.
La corrección consiste en comprobar la variable que representa la capacidad disponible:
if (nectarCapacity == 0) {
return 0;
}
Después de corregir esta condición, el programa deja de lanzar la excepción y se ejecuta hasta el final.
Ejemplo de resultado incorrecto sin excepción
Tras corregir el primer error, la aplicación muestra la respuesta «33.0 honey was produced by 7 bees from 2 honey plants».
El resultado sigue siendo incorrecto. Según la documentación del proyecto, dos unidades de néctar producen una unidad de miel. Si las dos plantas tienen 30 y 40 unidades de néctar, el resultado esperado antes de otras operaciones es de 35 unidades de miel.
Para analizar el problema se puede establecer un punto de ruptura en el método Main.main(), en la línea donde se llama a beeHive.populateHoney(), y ejecutar el método en modo depuración.
El programa se detiene antes de ejecutar la línea seleccionada. En la sección Debug se muestra la información disponible sobre la aplicación en ejecución. El panel Variables contiene las variables y objetos disponibles en ese punto, mientras que el panel Frames muestra los pasos por los que está pasando la aplicación.
Para continuar la ejecución se puede pulsar F9 o el icono verde correspondiente. Para detener el programa se puede pulsar el cuadrado rojo. Para reiniciar la aplicación en modo depuración se puede utilizar la flecha de reinicio.
Para entrar en el método beeHive.populateHoney() se utiliza F7. Una vez dentro del método, F8 permite recorrerlo sin entrar en las llamadas internas.
Seguimiento de las operaciones
- La API Stream se utiliza para recolectar néctar de todas las abejas.
- La miel recién creada se agrega a la miel existente.
- Se asignan dos unidades de miel a la reina.
- Estas dos unidades se eliminan de la cantidad total de miel.
- La reina come esta miel.
La depuración muestra que las dos unidades que faltaban no desaparecieron por un error de cálculo: fueron consumidas por la abeja reina.
La documentación inicial no describía esta operación. Después de revisar el comportamiento esperado, la documentación debe indicar que dos unidades de néctar producen una unidad de miel y que la abeja reina consume dos unidades de miel cada vez que la colmena se repone.
Depurar webapp (Java) en IntelliJ
Ventanas de información durante la depuración
Durante el proceso de debug se utilizan varias ventanas situadas bajo la ventana de código. Estas vistas permiten analizar el programa mientras se ejecuta, consultar el contexto actual y examinar la evolución de las variables.
Variables
El panel Variables muestra las variables y los objetos disponibles en el punto donde se ha detenido la ejecución. Es especialmente útil para comprobar argumentos, atributos, valores de retorno y resultados intermedios.
Frames o pila de llamadas
El panel Frames muestra los pasos por los que está pasando la aplicación. Permite consultar los marcos anteriores y examinar los datos locales asociados a cada llamada.
Consola
La ventana de consola muestra la salida del programa y puede activarse cuando se ejecutan instrucciones que escriben información o solicitan datos. Durante una ejecución paso a paso es posible alternar entre el editor, las ventanas del depurador y la consola.
Depuración en NetBeans
NetBeans es un entorno de desarrollo completo y profesional. Contiene funcionalidades para distintos tipos de aplicaciones y facilita la programación, la prueba y la depuración de las aplicaciones que se desarrollan.
El depurador permite supervisar la ejecución de los programas para localizar y eliminar los errores lógicos. Un programa debe compilarse con éxito para poder utilizarlo en el depurador.
NetBeans dispone de modo de depuración y modo de lanzamiento. En el modo de depuración se incluyen más facilidades para analizar y corregir errores.
| Modo | Características |
|---|---|
| Debug | Se incluyen más facilidades para la depuración de errores. |
| Release | Modo de lanzamiento. |
Creación de puntos de interrupción en NetBeans
El proceso de depuración se lleva a cabo añadiendo puntos de interrupción y comprobaciones en el código y ejecutándolo en el depurador.
Una vez añadido algún punto de interrupción, se debe ejecutar el proyecto en modo depuración. Los puntos de ruptura se pueden colocar en las líneas que se quieran pulsando sobre el margen izquierdo, junto al número de línea.
Durante la depuración se puede hacer que el programa se ejecute paso a paso y observar los valores que toman las variables.
Ejemplo de ejecución paso a paso en NetBeans
Para practicar se puede crear un proyecto Java y abrir el archivo principal en el editor. Después de colocar el código, se genera el ejecutable y se inicia la ejecución del programa.
La siguiente línea que se va a ejecutar aparece señalada mediante una flecha verde a la izquierda, junto al número de línea. Debajo del editor aparece un panel con varias fichas de información.
Si se pulsa F8 para ejecutar la siguiente instrucción, la flecha pasa a apuntar a la primera instrucción ejecutable. Las declaraciones se pasan por alto, ya que no figuran como instrucciones en el código objeto.
Si se pulsa F7, la ejecución puede pasar al código de una biblioteca utilizada por el programa. Cuando se confía en las bibliotecas del sistema, no es necesario analizar la ejecución de sus códigos.
En esos casos se puede continuar la ejecución hasta la siguiente línea, continuar hasta el siguiente punto de ruptura o finalizar la sesión si se ha entrado accidentalmente en código externo.
Durante la ejecución paso a paso se pueden observar los valores que van tomando las variables y comprobar cómo evoluciona el programa hasta su finalización.
Controles principales del depurador de NetBeans
| Acción | Atajo | Función |
|---|---|---|
| Step over expression | Shift F8 | Permite continuar con cada llamada a método en una expresión y ver los parámetros de entrada y los valores de salida resultantes de cada llamada. |
| Step Into | F7 | Ejecuta una línea de código entrando en las llamadas a funciones. |
| Step Out | Ctrl + F7 | Sale de la ejecución de la función actual. |
| Continue | F5 | La ejecución del programa continúa hasta el siguiente breakpoint. |
| Finish Debugger | Mayúsculas + F5 | Termina la depuración del programa. |
| Continuar ejecución | F8 | Ejecuta hasta la siguiente línea, ejecutando de golpe las llamadas a funciones o los operadores. |
Configuración del depurador de Java en NetBeans
El depurador de Java se puede personalizar eligiendo Herramientas > Opciones y haciendo clic en la ficha Depurador de Java.
Buenas prácticas para depurar código Java
El código debe estar indentado correctamente. Cada vez que hay una apertura con llave, debe tener un cierre de llave correspondiente.
Java distingue mayúsculas de minúsculas. Una variable de nombre edad es diferente de otra de nombre Edad.
Se deben respetar las reglas de nomenclatura de clases, variables, constantes y métodos. Todas las sentencias en Java deben acabar en punto y coma.
Un programa debe compilarse con éxito para poder utilizarlo en el depurador. Una vez añadido algún punto de interrupción, se debe ejecutar en modo depuración.
Convenciones de nomenclatura
Antes de escribir código, lo mejor es especificar un conjunto de convenciones de nomenclatura para cada proyecto Java. Esto incluye normas sobre cómo nombrar clases e interfaces, métodos, variables y constantes.
Un identificador en Java debe explicarse por sí mismo, establecer distinciones significativas y ser pronunciable.
- Los nombres de clase e interfaz deben ser sustantivos y comenzar con una letra mayúscula.
- Los nombres de las variables deben ser sustantivos y comenzar con una letra minúscula.
- Los nombres de los métodos deben ser verbos y comenzar con una letra minúscula.
- Los nombres de las constantes deben tener todas las letras mayúsculas y separar las palabras mediante guiones bajos.
Organizar los miembros de cada clase
Una buena práctica consiste en organizar las variables de una clase en función de sus ámbitos, desde el más restrictivo al menos restrictivo.
Las variables se pueden ordenar según la visibilidad de los modificadores de acceso: privado, predeterminado de paquete, protegido y público. Cada grupo debe estar separado por una línea en blanco.
Mantener los campos privados
Una buena práctica en Java es minimizar la accesibilidad de los campos de cada clase y utilizar el modificador de acceso más bajo posible para protegerlos.
Esta práctica ayuda a cumplir la ocultación o encapsulación de información en el diseño de software.
Usar nombres que expresen intención
Un buen nombre debe indicar claramente qué representa o qué hace una variable, un método o una clase, sin necesidad de comentarios.
Por ejemplo, int edad; expresa mejor la intención que int x;. Del mismo modo, calcularMedia() comunica mejor la función de un método que un nombre genérico como f().
Crear funciones pequeñas y especializadas
Una función debe tener una única responsabilidad y ser fácil de entender de un vistazo.
Una función que valida datos, calcula resultados y guarda información puede dividirse en varias funciones especializadas. El paso de una versión grande a varias funciones pequeñas mejora la estructura sin cambiar el comportamiento.
Este proceso se conoce como refactorización. Una técnica habitual es la extracción de métodos, que divide una función grande en varias funciones más pequeñas y especializadas.
Si el nombre de una función contiene «y», por ejemplo calcularYGuardar, probablemente hace más de una cosa. Si se necesitan comentarios dentro de una función o resulta difícil explicarla en una sola frase, probablemente debería dividirse.
Evitar comentarios innecesarios
El código debe ser lo suficientemente claro como para no necesitar comentarios que expliquen qué hace.
Esto no significa que los comentarios sean malos. Son útiles para explicar decisiones de diseño, documentar APIs y aclarar aspectos no evidentes.
Si un comentario explica qué hace el código, probablemente el código puede mejorar. Si un comentario explica por qué se hace algo, suele ser útil.
Evitar la duplicación de código
El principio DRY establece que cada pieza de lógica debe tener una única representación en el código.
Cuando el mismo cálculo aparece copiado en varios sitios, cualquier corrección futura obliga a localizar y modificar todas las copias. Si se pasa por alto alguna, el programa queda en un estado inconsistente.
Centralizar un cálculo en un único método reduce errores y facilita el mantenimiento. Cuando se repiten varios bloques casi idénticos, un bucle puede simplificar el código.
Si se repite un mismo cálculo o una misma fórmula, probablemente se está violando DRY. Si un cambio obliga a modificar varios sitios, existe duplicación.
Evitar números mágicos
Los valores constantes deben tener un nombre significativo que explique qué representan y aparecer en el código a través de la constante que los representa, no codificados directamente como números mágicos.
Si aparece un número suelto en el código, probablemente debería convertirse en una constante. Si no se sabe qué significa un valor sin leer más código, necesita un nombre.
Las constantes hacen que el código sea más claro y más fácil de mantener. En Java, muchas constantes habituales ya están definidas en la biblioteca estándar; por ejemplo, el número π está disponible como Math.PI.
Usar guiones bajos en literales numéricos
Esta función se puede utilizar desde la versión 7 de Java. Permite escribir literales numéricos extensos de forma más legible.
Evitar listas largas de parámetros
Cuando una función tiene muchos parámetros, suele ser difícil de entender y utilizar correctamente.
Como regla general, uno o dos parámetros son normales, tres empiezan a ser sospechosos y cuatro o más probablemente indican un problema de diseño.
Si varios parámetros están relacionados, probablemente deberían formar una clase. Agrupar los datos en un objeto que representa un concepto del dominio hace que el código sea más claro y fácil de manejar.
Cuando es necesario crear objetos con muchos parámetros, se pueden utilizar técnicas como el patrón Builder.
Preferir objetos inmutables
Un objeto inmutable es aquel cuyo estado no puede cambiar después de crearse.
Si los campos son accesibles directamente desde fuera de la clase, cualquier parte del programa puede modificar el estado del objeto en cualquier momento, incluso asignando valores inválidos.
Para evitarlo, los campos pueden ser privados y declararse como final. El objeto se crea de una vez con todos sus datos y su estado no cambia.
La inmutabilidad evita errores difíciles de detectar, facilita el razonamiento sobre el código y hace que el código sea más seguro en entornos concurrentes.
Manejar correctamente los errores
Los errores no deben ignorarse: deben detectarse y tratarse de forma adecuada.
Es recomendable validar los datos lo antes posible, preferiblemente en el constructor, y utilizar tipos de excepción específicos como IllegalArgumentException.
Lanzar una excepción permite detectar un problema antes de que se propague, evitar que el objeto quede en un estado incorrecto y hacer visible el error en lugar de ocultarlo.
Los bloques de captura vacíos deben evitarse porque pueden producir fallos silenciosos y hacer que la depuración del código sea mucho más complicada.
Escribir código fácil de leer
La solución más simple y clara suele ser la mejor.
Si una expresión es difícil de leer, se puede dividir en variables intermedias con nombres significativos. Es preferible la claridad frente al código compacto.
Escribir menos código no siempre significa escribir mejor código. En ocasiones, añadir unas pocas líneas mejora mucho la legibilidad.
Usar enumeraciones y evitar interfaces de constantes
En general, es una mala idea crear una interfaz única para declarar constantes sin emplear métodos. El propósito de las interfaces es la herencia y el polimorfismo, no las declaraciones estáticas.
En un proyecto complejo se puede utilizar una clase dedicada a definir las constantes de la aplicación o emplear enumeraciones cuando el conjunto de valores represente una categoría cerrada.
Evitar la redundancia
En la inicialización es innecesario utilizar variables miembro con valores cero, falso y nulo. Si se conocen los valores de inicialización predeterminados de las variables miembro, se evita una inicialización explícita innecesaria.
Secuencia recomendada de trabajo
- Abrir el IDE.
- Crear o abrir el proyecto.
- Escribir o modificar el código fuente.
- Comprobar la indentación del código.
- Verificar que cada apertura con llave tenga un cierre correspondiente.
- Compilar el proyecto.
- Subsanar los errores de codificación indicados por el entorno.
- Ejecutar la clase compilada desde la consola o mediante la opción de ejecución del proyecto.
- Añadir puntos de interrupción junto al número de línea.
- Ejecutar el proyecto en modo depuración.
- Avanzar por el código utilizando los controles adecuados al nivel de detalle necesario.
- Observar la línea actual, las ventanas del depurador y los valores de las variables.
- Finalizar la sesión de depuración cuando termine el análisis.
Esta secuencia permite separar los errores de compilación de los errores lógicos, ejecutar el programa en condiciones controladas y analizar de forma progresiva el punto en el que el comportamiento deja de ser el esperado.
tags: #ejemplos #practicos #de #depuracion #de #codigo
Publicaciones populares:
- Evans: análisis del filtro de agua de 5 etapas con ultrafiltración
- Guía para calcular la energía en procesos de desalinización por ósmosis inversa
- Cómo escoger el filtro de piscina: criterios y recomendaciones
- Tratamiento en la depuradora de aguas residuales de Maceió: tecnología y eficacia
- Guía para limpiar filtros blister del aire acondicionado con seguridad