Algunos TIPS al programar en JAVA ~ linuxitos

Entiendo que como programadores o desarrolladores, tenemos ya nuestra pila de "Trucos y Tips" a la hora de programar, así como también solucionar o encontrar los "Errores", los catch, que no contemplamos o que simplemente no sabíamos que ocurrián.

Como ya mencioné, cada quien crea sus propios trucos con base a sus experiencias, pero no está de más saber trucos de alguien más:

Les presentaré una serie de trucos y métodos que son los más usuales que siempre se requieren a la hora de programar en JAVA.

1.- Siempre crear el paquete main o principal el cual inicie todo el programa

Desde mi punto de vista, éste es el tip más importante, además, de que es esencial en caso de querer crear el Jar al final. Como sabran, para poder crear un Jar, es necesario que solo exista un main en todo el software, por lo tanto al programar, crear una estructura parecida a la imagen de arriba.

La clase principal donde está el único main de todo el software, yo siempre la coloco en un paquete separado a todas las demás, también separo las clases de las interfaces gráficas, de los recursos, y de las imágenes.

De este modo es mucho más fácil el desarrollo, desde mi punto de vista claro.

Entonces, mi clase principal donde está el único main, lo único que hará es crear y visualizar la primera interfaz Gráfica (JFrame), de todo el software, y de ahí parte todo lo demás.

Ejemplo de mi código en la clase principal donde contiene el main:

[...]
/*
 * Nombre de la clase: Principal
 * Descripción: esta clases es la principal, desde aquí se invocan a las demás
 *  interfaces para que inicie el programa completo.
 */
package gestionbasedatos;

import gestionbasedatos.interfaces.LoginBD;
import gestionbasedatos.interfaces.SplashScreen;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

/**
 *
 * @author m2 <linuxitos@gmail.com>
 */
public class Principal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try{
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        }catch(ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException e){
            System.err.println("Error Look GUI: "+e.getMessage());
        }
        SplashScreen s=new SplashScreen();
        s.setVisible(true);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException ex) {
            Logger.getLogger(Principal.class.getName()).log(Level.SEVERE, null, ex);
        }
        s.dispose();
        SwingUtilities.invokeLater(new Runnable(){
            @Override
            public void run(){
                /*Aquí crean el objeto hacía su aplicación, para hacer visible*/
                LoginBD nuevaSesion = new LoginBD();
                nuevaSesion.setVisible(true);
            }
        });        
    }
    
}
[...]

2.- Agregar javadoc a todos los métodos y clases

Esto no creo que sea solo un tip, sino una oligación de todo desarrollador;

En Java es sencillo, solo basta posicionarse sobre el método, presionar la tecla Alt+Enter y lo agrega automáticamente:

Ejemplo:

[...]
/**
     * Método que devuelve el valor de un campo espéficico que se le indique lo retorna como string
     * si la consulta cuenta con muchas filas, se quedará con el último valor
     * @param rel
     * @param campo
     * @return String
     * @throw SQLException.
    */
    public String obtenerCampo(ResultSet rel, String campo){
       String valCampo =new String();
       try{
            while(rel.next()){ 
                valCampo=rel.getString(campo);
            }
        } catch (SQLException ex) {
            System.out.println("Error: "+ex.getMessage());
        }
        return valCampo;
    }
[...]

Si no quieren, escribir toda la documentación o comentarios en un momento dado, entonces, solo agreguen lo más importante y después la terminan.

Documentar su código no solo los ayudará a ustedes cuando no se acuerden qué hace cada uno de los mil método que tienen en su código, sino que también ayudará a otros en caso de que desarronen en grupos.

También debo decir, que su código se verá más profesional, esto es de cada quien, pero es una excelente prática hacerlo.

3.- Evitar cerrar todo el PROGRAMA al dar CLIC en la opción Cerrar de la Vetana:

Quizas no en todos los programas se requiera inahabilitar esta opción, pero algunos casos es importante preguntar al usuario si realmente desea cerrar o si simplemente no cerrar el programa sino que te regrese a otra ventana.

Para esto, yo utilizo el siguiente código:

//Se inhabilita que al presionar el botón cerar de la ventana salga del programa
setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);
//Se agrega de Listener para que éste detecte cuando se presione el botón 
//cerrar y ejecute otra accion, por ejemplo hacer visible una ventana anterior.
addWindowListener(new java.awt.event.WindowAdapter() {
    @Override
    public void windowClosing(java.awt.event.WindowEvent evt) {
        //Acción a realizar contrario a salirse del programa
    }
});

4.- Crear métodos para reutilización

La idea es la siguiente: Supongamos que en el ejemplo anterior, se requiere regresar a una ventana anterior al presionar el botón cerrar de la ventana, pero también, hay que actualizar la información que se haya capturado en la ventana actual antes de cerrar. Además, tenemos un botón de "Cerrar", entonces, el código que se ejecutará en botón cerrar de la ventana, también se utilizará en el botón cerrar que agregamos nosotros, por ente, para no duplicar el mismo código, crear un método, y solo se invocaría el método en ambas opciones:

Ejemplo:

[...]
//Método creado
private void close(){
    consultas.cargarPacientesTablas(jtableInfoActFisica);
    consultas.actualizarDatosGenerales();
    regAModiExp.setVisible(true);
    this.dispose()
}
[...]

[...]
//Cuando se detecte clic en el botón de cerar ventana quedaría así
setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);
addWindowListener(new java.awt.event.WindowAdapter() {
    @Override
    public void windowClosing(java.awt.event.WindowEvent evt) {
       close();
    }
});
[...]

Y cuando se de clic en el botón cerrar que se agregó en la ventana quedaría aśi:

[...]
private void jbCerarActionPerformed(java.awt.event.ActionEvent evt) {
   close();
}
[...]

Y con eso se dismiyen las líneas de código, y se hace uso de la Reutilización.

5.- Centrar todas las ventanas al iniciar el programa:

Para lograr que las ventanas de todo nuestro Software a desarrollar se centre automáticamente, es necesario agregar lo siguiente:

[...]
initComponents();
setLocationRelativeTo(null); //esto hace que se centre de manera utomática
[...]

Es necesario agregarlo a cada JFrame que se cree. El orden también es necesario, ya que si no lo hacen en ese orden, les lanzará una excepción.

6.- Agregar ícono a nuestro Software

Muchos podrán decir que no es necesario, pero la personalización de un Software es lo que lo hace ser más llamativo, así que, para agregar el ícono yo utilizo el siguiente código:

[...]
initComponents();
/*Tiene que ser después de initiComponents*/
Image icon = Toolkit.getDefaultToolkit().getImage(getClass().getResource("../images/favicon.png"));
setIconImage(icon);
[...]

Obviamente es necesario crear el ícono previamente, guardarlo dentro del proyecto, y agregarlo a cada JFrame que se cree.

7.- Agregar ícono a nuestro Software

Izquierda utilizando el tema default de Java, Derecha adaptado al tema del SO.

Hacer que la interfaz se adapte al estilo de ventanas y botones del sistema en el que se ejectue el software y que no utilice el default de Java.

Para esto, yo agrego el siguiente código al inicio de donde inicia la ejecución del primer JFrame:

[...]
try{
   UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        }catch(ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException e){
    System.err.println("Error Look GUI: "+e.getMessage());
}
[...]

8.- En las excepciones agregar más información

Esto también lo recomiendo, pero es de cada quien de cómo encuentra sus errores en el código, sobre todo por las excepciones:

Lo que yo hago en cada error de una posible Excepción, es mostrar el con System.out.println("");, pero agregando el nombre del método en el que ocurra el error:

Ejemplo:

[...]
     /**
     * Método que realiza la desconexión con la BD.
     * @return boolean
     */
    public boolean desconectar(){
        boolean desconecta=false;
        try {
           conexion.close();
           desconecta=true;
           System.out.println("Clase conexión: desconexión exitosa");
        } catch (SQLException e) {
           System.out.println("Error en método desconectar: " + e.getMessage());
        }
        return desconecta;
    }
[...]

De esta manera me doy cuenta de dónde más o menos está el error.

Bueno, por ahora solo les dejo esos tips, espero y les sean de utilidad. Gracias por visitar.

martes, 24 de mayo de 2016