Algunos materiales para el SCJA

Pues aunque no deberian ir necesariamente en este blog vamos a poner algunos materiales que bien podrian servir para medio guiarte en las obscuras profundidades del SCJA:

1. El site oficial del exámen.
   
2. Una guía rápida del UML que deberías conocer.
3. Preguntas de prueba generadas por personas que ya tomaron la certificación.
4. Un site con algunos recursos interesantes.
5. Preguntas de ejemplo desde Alemania. Clic en la izquierda para entrar a cada sección.
6. Mas mocks Cafe4Java.
7. Mock de JavaGuru.
8. Todo junto en JavaRanch.

De vez en cuando voy a poner algunos tópicos sobre esos detalles del SCJA, pero no prometo en realidad nada y no olviden que el detalle es que estudien.

Algo de JTables pa' variar

Bueno, los JTables pueden llegar a se un poco enigmaticos, y hacer que las cosas pasen con ellos a veces resulta un poco díficil, pero con un poco de práctica podemos hacer un buen de cosas con el. Para empezar vamos a ver una manera sencilla de crear un mapeo entre una clase POJO (Plan Old Java Object, Objeto Java Sencillo y Jodido), y lo utilizamos para mostrarlo desde una base de datos a un JTable. Es algo sencillo en realidad. Pero para lograrlo necesitamos una nuevla clase del conjunto Swing, esta clase se llama TableModel y es una interfaz que permite decirle a un JTable que presentar en una tabla. Vamos por ejemplo.

//AbstractTableModel implementa TableModel y la mayoría de sus métodos
class TModelo extends AbstractTableModel {
   private ArrayList lista;

   //Cargamos los datos a una lista de POJO's
   public TModelo(ResultSet rs) {
       try {
           rs.first();
           do {
               POJO pojo = new POJO();
               pojo.campo1 = rs.getString(1);
               pojo.campo2 = rs.getInteger(2);
               pojo.campo3 = rs.getString(3);

               lista.add(pojo);
           } while(rs.next());
       } catch(Exception e) { ; }
   }

   //Indicar cuantas filas va a tener la tabla
   public int getRowCount() { return lista.size(); }
   //Indicar cuantas columnas va a tener la tabla. El numero de campos en este caso
   public int getColumnCount() { return 3; }
   //Objeto en cada celda
   public Object getValueAt(int fila, int columna) {
       try {
           POJO pojo = (POJO) lista.get(fila);
           if(columna == 0)
               return pojo.campo1;
           if(columna == 1)
               return new Integer(pojo.campo2);
           if(columna == 2)
               return pojo.campo3;
       } catch(Exception e) {
           //Regresamos un valor vacio por si las moscas
           return "";
       }
   }
   //nombre de las columnas
   public String getColumnName(int col) {
       if(columna == 0) return "Campo 1";
       if(columna == 1) return "Campo 2";
       if(columna == 2) return "Campo 3";
   }
   //Indicamos si determinada celda es editable
   public boolean isCellEditable(int f, int c) {
       return false;
   }
}

//Una clase POJO muy sencilla
//Esto no deberia hacerse, deberiamos usar geters y seters
class POJO {
   public String campo1;
   public int campo2;
   public String campo3;
}

Una vez que tenemos un TableModel podemos crear una Tabla con los datos que tiene el modelo mismo.

JTable tabla = new JTable(new TModelo(rs));

JFrame fra = new JFrame();
//Si se agrega la tabla de manera directa entonces no se muestran los encabezados
fra.add(new JScrollPane(tabla));

Ahora, un TableModel puede servir para hacer muchas cosas, por ejemplo, podemos filtrar los datos de uno de ellos por medio de otro, a esto se le conoce como Decorator.

class FilterModel extends AbstractModel {
    private TableModel original;
    private ArrayList pasan = new ArrayList();

    public FilterModel(TableModel tm) {
        original = tm;
    }

    //Implementamos un filtro sencillo para un solo campo sobre el modelo anterior
    public void filtra(String valor) {
        //Quitamos todo
        pasan.clear();

        //Filtramos cada valor y ponemos los que coinciden con el valor
        for(int i = 0; i < original.getRowCount(); i++)
            if(("" + original.getValueAt(i, 1)).indexOf(valor) != -1)
                pasan.add(new Integer(i));
    }

    public String getColumnName(int c) { return original.getColumnName(c); }
    public int getColumnCount() { return original.getColumnCount(); }
    public int getRowCount() { return pasan.size(); }
    public Object getValueAt(int f, int c) {
        int real = ((Integer) pasan.get(f)).intValue();
        return original.getValueAt(real, c);
    }
}

Una forma sencilla de hacer las cosas.

Chaito sres...

Haciendo Frames Internos

En Java lo más parecido que hay a un formulario MDI son los Frames Internos, estos son miniventanas que se pegan a una ventana marcada como JDesktopPane como contenedor principal, y deben agregarse a estos.

Vamos a ver como funcionan de manera general estas cosas raras:

JFrame padre = new JFrame("Varios Frames internos");

JDesktopPane jdp = new JDesktopPane();

padre.setContentPane(jdp);

//Crea un Frame interno que no puede cambiar su tamaño, puede cerrarse, no puede 
//maximizarse y puede minimizarse. Los parametros son aleatorios y en ese orden.
JInternalFrame jif = new JInternalFrame("Titulo", false, true, false, true);
jif.pack();
jif.setVisible();

//Después ponemos el elemento en el frame
jdp.add(jif);

Ahora, algunas veces puedes querer que un InternalFrame no pueda cerrarse o dejarse mientras estemos usandolo. Esto en realidad no se puede hacer de manera sencilla; pero usando listeners podemos equilibrar las cosas. Vamos a ver como crear un JInternalFrame que funciona de cierta manera como una ventan modal:

JInternalFrame jif = new JInternalFrame();
jif.addInternalFrameListener(new InternalFrameAdapter() {
    public void internalFrameIconified(InternalFrameEvent e) {
        ((JInternalFrame) e.getSource()).setVisible(true);
    }

    public void internalFrameDeactivated(InternalFrameEvent e) {
        ((JInternalFrame) e.getSource()).setVisible(true);
    }
});

Esa es una forma rápida de hacer que las cosas funcionen de la manera que no deberían hacerlo. Si lo que estan buscando es una forma de mostrar dialogos Internos no hay más que reemplazar los métodos showXXXXDialog de JOptionPane por showInternalXXXXDialog.

Principios de Diseño Orientado a Objetos

Para realizar modelos orientados a objetos no esta de mas conocer algunos principios para poder verificar la fortaleza de los mismos. Ya hay una serie de principios que se recomiendan para un diseño orientado a objetos. Entre estos podemos encontrar los siguientes:

Responsabilidad Única

Cada clase debe ser responsable de realizar solo una actividad del sistema

Clase Abierta y Cerrada

Una clase debe ser abierta a la extensión y cerrada a la modificación

Principio de Substitución de Liskov

Cada clase que hereda de otra puede usarse como su padre sin necesidad de conocer las diferencias entre ellas

Principio de Inversión de Dependencia

Los modulos de nivel superior no deben depender sino de las abstracciones. Los detalles deben depender a su vez de las abstracciones, no al contrario

Principio de Segregación de Interfaces

La implementación de las abstracciones (que contradictorio) debe estar en la medida de lo posible en interfaces y no en clases

Principio de Equivalencia de Reuso y Distribución

Solo los componentes que se distribuyen de manera final pueden ser reutilizados, el elemento mas importante es entonces el paquete.

Principio de Cierre Común

Los componentes que comparten funciones entre ellos o que dependen uno del otro deberían ser colocados juntos

Principio de Reuso Común

Si se reutiliza una clase de un paquete entonces se reutilizan todas

Principio de Dependencías Aciclicas

Los paquetes y sus dependencias no deben formar ciclos entre si

Principio de Dependencías Estables

Los paquetes menos estables han de depender de los paquetes mas estables

Principio de Abstracción Estable

Los paquetes deben ser más abstractos mientras mas estables son

Los 5 primeros principios son los que no deberían olvidarse mientras se escriben clases, aunque todos los principios son importantes.

Herramientas para Java

Generalmente el manejo de aplicaciones Java es simplemente considerado plano, sin embargo, los desarrollos Java estan plagados de opciones de trabajo que permiten simplificar el desarrollo, distribución, y mantenimiento de las aplicaciones; existen multiples herramientas que pueden hacer más sencillo el trabajo de Java en entornos de trabajo, vamos a revisar algunas de ellas.

• Eclipse: Es un IDE que permite desarrollar aplicaciones Java de una manera intuitiva. Es completamente gratuito y puede extenderse de manera casi ilimitada con plugins para realizar diferentes tareas además de las que contiene originalmente. En lo personal me encanta su soporte para integrar muchas de las demás herramientas que aquí se mencionan. Pueden encontrar diversas versiones del IDE, opción personal TFTP y Callipso


• BlueJ: Cuando no requerimos de todo el poder y las gracias que nos ofrece Eclipse, BlueJ es una buena opción, ofrece poco soporte para herramientas avanzadas, pero nos permite desarrollar aplicaciones sencillas, depurarlas de una manera intuitiva y verlas como dibujos. Cualquier cosa seria no cabe en BlueJ pero es ligero y fácil de usar para cuestiones didacticas


• Ant: Es una herramienta que permite automatizar muchas de las tareas latosas y repetitivas que se realizan en Java, probablemente no entiendan que hacer con Ant y les parezca una forma fastidiosa de escribir XML pero cuando hablemos de Deploy y estrategías de pruebas automatizadas.


• JUnit: Es una librería realizada completamente en Java que nos permite automatizar las pruebas y condiciones que deben ejecutarse en cada elemento del programa de manera separada o bien de manera integrada, es una forma de saber que las cosas trabajan antes de ponerlas en producción.


• HttpUnit: Es algo que pegas con el anterior para probar interfaces Web


• JavaDoc: Parte de la suite Java del SDK que permite generar documentación parecida a la oficial de la API sobre los elementos de los programas que nosotros desarrollemos

Si bien no es indispensable dominar todas estas tecnologías para utilizar Java te pueden hacer la vida bastante fácil.