El Javatar

SwingUtils - Crear JTable Paginado o Lazy y con Filtros (Java Swing)

2018-04-24T19:08:00.001-05:00

En este tutorial, aprenderemos cómo crear de forma rápida un JTable que tenga paginación dinámica, que también permita carga dinámica (lazy), y que además acepte filtros por columna; para esto haremos uso de la librería SwingUtils que posee un componente llamado PaginatedTable, el cual extiende de la clase javax.swing.JPanel y que internamente hace uso de un javax.swing.JTable.

Nativamente, el API de Java Swing no nos permite agregarle de forma rápida un paginador a un JTable, así que si queremos tener esta funcionalidad, deberíamos programarla nosotros mismos. Una forma "sencilla" de hacerlo es implementando un TableRowSorter; sin embargo el problema radica cuando queremos aplicar un filtro, por ejemplo de búsqueda a nuestra tabla, ya que sería un poco complejo el actualizar nuestro paginador.

Por eso, en la librería SwingUtils he creado un componente llamado PaginatedTable el cual está diseñado para trabajar con dos tipos de tablas paginadas. Veamos cuáles son y en qué escenarios usaríamos cada una de ellas:

- Tablas paginadas con carga completa: Son aquellas que usaríamos cuando sabemos que el volumen de datos de nuestra tabla no es muy grande y podríamos cargarlos todos sin afectar de manera radical a la memoria. Con este tipo de carga, obtenemos toda la lista de datos desde el principio, y los resultados de filtros y paginación se devuelven desde esa lista inicial.

- Tablas paginadas con carga dinámica o lazy (perezosa): Son aquellas que usaríamos cuando sabemos que el volumen de datos de nuestra tabla puede llegar a ser muy grande y que cargarlos todos podría causar problemas en la memoria. Con este tipo de carga, vamos obteniendo dinámicamente los datos, es decir, que sólo tenemos en memoria los datos según la paginación y filtros que tengamos aplicados en el momento.

Ahora que sabemos en qué escenarios podemos usar el componente de paginación de tablas de SwingUtils, veamos cómo podríamos usarlo para cada uno de ellos.

Crear una Tabla Paginada o Lazy y con Filtros en Java Swing usando PaginatedTable

Lo primero que debemos hacer es importar la librería SwingUtils a nuestro proyecto. Puedes ver las instrucciones en el siguiente enlace:

==> SwingUtils - Librería de Utilidades para Java Swing

Debido a la facilidad de cambiar de implementación entre tablas paginadas con carga completa y tablas paginadas con carga dinámica, el proceso que se aplica para cada uno es el mismo. La diferencia principal está en la forma en cómo obtenemos los datos para cada uno de los casos.

Así que empezamos creando la clase que usaremos como modelo de datos (bean) para nuestro ejemplo:

public class Persona {

    private String codigo;
    private String nombres;
    private String apellidos;
    private String direccion;
    private String telefono;
    
    public Persona() {
        // Constructor vacío por defecto
    }
    
    public Persona(String codigo, String nombres, String apellidos, String direccion, String telefono) {
        this.codigo = codigo;
        this.nombres = nombres;
        this.apellidos = apellidos;
        this.direccion = direccion;
        this.telefono = telefono;
    }
    
    public String getCodigo() {
        return codigo;
    }
    
    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }
    
    public String getNombres() {
        return nombres;
    }
    
    public void setNombres(String nombres) {
        this.nombres = nombres;
    }
    
    public String getApellidos() {
        return apellidos;
    }
    
    public void setApellidos(String apellidos) {
        this.apellidos = apellidos;
    }
    
    public String getDireccion() {
        return direccion;
    }
    
    public void setDireccion(String direccion) {
        this.direccion = direccion;
    }
    
    public String getTelefono() {
        return telefono;
    }
    
    public void setTelefono(String telefono) {
        this.telefono = telefono;
    }

}

A continuación, creamos la clase que usaremos como TableModel de nuestro JTable, el cual extiende de la clase TableModelGeneric de la librería SwingUtils tal como lo vimos en el tutorial sobre cómo crear un JTable con un Modelo de Datos Genérico en Java Swing:

import com.eljavatar.swingutils.core.modelcomponents.FilterMatchModeEnum;
import com.eljavatar.swingutils.core.modelcomponents.ObjectFilter;
import com.eljavatar.swingutils.core.modelcomponents.TableModelGeneric;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class TableModelGestionPersonas extends TableModelGeneric<Persona> {

    public TableModelGestionPersonas() {
        this(new ArrayList<>());
    }
    
    public TableModelGestionPersonas(List<Persona> listDatos) {
        super(
                new Class[]{String.class, String.class, String.class, String.class, String.class},
                new String[]{"Código", "Nombres", "Apellidos", "Dirección", "Teléfono"},
                Arrays.asList(new ObjectFilter("Código", "codigo", FilterMatchModeEnum.EXACT), new ObjectFilter("Nombres", "nombres", FilterMatchModeEnum.CONTAINS), new ObjectFilter("Apellidos", "apellidos", FilterMatchModeEnum.CONTAINS)),
                listDatos
        );
    }
    
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        switch (columnIndex) {
            case 0:
                return getListElements().get(rowIndex).getCodigo();
            case 1:
                return getListElements().get(rowIndex).getNombres();
            case 2:
                return getListElements().get(rowIndex).getApellidos();
            case 3:
                return getListElements().get(rowIndex).getDireccion();
            case 4:
                return getListElements().get(rowIndex).getTelefono();
            default:
                return null;
        }
    }

}

El código de la vista sería el siguiente:

import com.eljavatar.swingutils.core.annotations.PaginatedTableView;
import com.eljavatar.swingutils.core.componentsutils.JTableUtils;
import com.eljavatar.swingutils.core.componentsutils.SwingComponentsUtils;
import com.eljavatar.swingutils.core.modelcomponents.LazyDataProvider;
import java.awt.Font;
import java.awt.event.MouseAdapter;
import javax.swing.JOptionPane;

public class PersonasView extends javax.swing.JFrame {

    private final PersonasController personasController;
    
    public PersonasView() {
        initComponents();
        this.personasController = new PersonasController(this);
        setModeloTablaPersonas();
        this.personasController.listarPersonas();
    }
    
    private void setModeloTablaPersonas() {
        SwingComponentsUtils.setFontAllComponents(paginatedTablePersonas.getDataTable(), new Font("Arial", Font.PLAIN, 12));
        paginatedTablePersonas.getDataTable().setSize(600, 300);
        JTableUtils.setProperties(paginatedTablePersonas.getDataTable(), new Font("Arial", Font.BOLD, 13), new TableModelGestionPersonas(), new int[]{16, 18, 18, 34, 14});
        
        PaginationDataProvider<Persona> dataProvider = this.personasController.createDataProvider();
        //LazyDataProvider<Persona> dataProvider = this.personasController.createLazyDataProvider();
        
        paginatedTablePersonas.decorateAndSet(dataProvider, new int[]{5, 10, 20, 50, 75, 100}, 10, true, new Font("Arial", Font.PLAIN, 12));
        
        paginatedTablePersonas.getDataTable().addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(java.awt.event.MouseEvent e) {
                int fila = paginatedTablePersonas.getDataTable().rowAtPoint(e.getPoint());
                if (fila > -1) {
                    if (e.getClickCount() == 2) {
                        seleccionarElement(fila);
                    }
                }
            }
        });
    }
    
    private void seleccionarElement(int fila) {
        if (fila >= 0) {
            Persona persona = paginatedTablePersonas.getTableModelGeneric().getListElements().get(fila);
            personasController.setPersona(persona);
            personasController.mostrarPersona();
        } else {
            JOptionPane.showMessageDialog(this, "Debe hacer clic en una fila para poder seleccionar un Elemento", "Mensaje de Error", JOptionPane.ERROR_MESSAGE);
        }
    }
    
    private void initComponents() {
        // Código generado por NetBeans
    }
    
    @PaginatedTableView(name = "listaPersonas")
    private com.eljavatar.swingutils.core.components.PaginatedTable<Persona> paginatedTablePersonas;
    
}

En este código he de recalcar 3 líneas. Las líneas 25 y 26 crean la implementación para cada uno de los tipos de tablas paginadas que expliqué al inicio de este tutorial. Basta sólo con comentar uno y descomentar el otro para cambiar de implementación.

En la línea 28 es donde creamos la paginación con el proveedor que hemos escogido y las otras propiedades que requerimos. Los parámetros que pasamos son los siguientes: El proveedor de datos, un array con los tamaños de página que le daremos al usuario para escoger, el tamaño de página inicial que verá el usuario, una variable que indica si mostraremos un filtro global, y finalmente la fuente de los componentes del paginador.

Ahora veamos el código del controlador:

import com.eljavatar.swingutils.core.annotations.PropertyController;
import com.eljavatar.swingutils.core.beansupdate.AbstractObserverController;
import com.eljavatar.swingutils.core.beansupdate.ObjectUpdate;
import com.eljavatar.swingutils.core.beansupdate.TipoUpdateEnum;
import com.eljavatar.swingutils.core.modelcomponents.LazyDataProvider;
import com.eljavatar.swingutils.core.modelcomponents.PaginationDataProvider;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import javax.swing.JOptionPane;

public class PersonasController extends AbstractObserverController<PersonasController, PersonasView> {

    private final PersonasView personasView;
    private final PersonasDao personasDao;
    private Persona persona;
    
    @PropertyController
    private List<Persona> listaPersonas;

    public PersonasController(PersonasView personasView) {
        this.personasView = personasView;
        this.personasDao = new PersonasDao();
        this.listaPersonas = new ArrayList<>();
        
        super.setListeners(PersonasController.this, this.personasView);
    }
    
    public void mostrarPersona() {
        String mensaje = "Código: " + persona.getCodigo() + "\n"
                + "Nombres: " + persona.getNombres()+ "\n"
                + "Apellidos: " + persona.getApellidos()+ "\n"
                + "Dirección: " + persona.getDireccion()+ "\n"
                + "Teléfono: " + persona.getTelefono();
        JOptionPane.showMessageDialog(personasView, mensaje);
    }
    
    public void listarPersonas() {
        this.listaPersonas = personasDao.generarDatos();
        super.changeData(new ObjectUpdate(TipoUpdateEnum.VIEW, Arrays.asList("listaPersonas")));
    }
    
    public PaginationDataProvider<Persona> createDataProvider() {
        return new PaginationDataProvider(listaPersonas);
    }
    
    public LazyDataProvider<Persona> createLazyDataProvider() {
        return new LazyDataProvider<Persona>() {
            @Override
            public List<Persona> getRows(int first, int last, Map<String, Object> filters) {
                Object[] response = getPersonasDao().getResultado(first, last, filters);
                this.setListData((List<Persona>) response[0]);
                this.setRowCount((int) response[1]);
                return getListData();
            }
        };
    }

    public List<Persona> getListaPersonas() {
        return listaPersonas;
    }

    public void setListaPersonas(List<Persona> listaPersonas) {
        this.listaPersonas = listaPersonas;
    }

    public PersonasDao getPersonasDao() {
        return personasDao;
    }

    public Persona getPersona() {
        return persona;
    }

    public void setPersona(Persona persona) {
        this.persona = persona;
    }
    
}

En este código podemos resaltar 2 métodos. En la línea 44 vemos el método que crea el proveedor de datos para tablas paginadas con carga completa; y en la línea 48 vemos el método que crea el proveedor de datos para tablas paginadas con carga dinámica.

A continuación vemos nuestra clase DAO, la cual simula la capa de servicios de datos, desde donde obtenemos los datos en métodos que usamos desde nuestro controlador para cada uno de los casos:

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class PersonasDao {

    private static List<Persona> listaDatos;

    static {
        listaDatos = new ArrayList<>();
        listaDatos.add(new Persona("US-NZEPSJ", "Armando", "Costa", "684 West Branch Rd. ", "35857229"));
        listaDatos.add(new Persona("US-PXCZSJ", "Emmy", "Spence", "Maineville, OH 45039", "85462552"));
        listaDatos.add(new Persona("US-AHFPZZ", "Edith", "Higgins", "55 Saxton St. ", "52524848"));
        listaDatos.add(new Persona("US-KRSEBV", "Isabelle", "Bonilla", "Joliet, IL 60435", "97957632"));
        listaDatos.add(new Persona("US-BTJUXD", "Elizabeth", "Haley", "74 Depot Street ", "92693956"));
        listaDatos.add(new Persona("US-RKHERS", "Giuliana", "Crawford", "Mobile, AL 36605", "34229289"));
        listaDatos.add(new Persona("US-LTYKWV", "Marilyn", "Osborne", "69 Bedford St. ", "74277594"));
        listaDatos.add(new Persona("US-PHXGVM", "Justin", "Rogers", "Macon, GA 31204", "85363778"));
        listaDatos.add(new Persona("US-XJVRXW", "Joselyn", "Curtis", "55 Princess St. ", "82264893"));
        listaDatos.add(new Persona("US-YRMVQP", "Dillon", "Savage", "Reynoldsburg, OH 43068", "49627366"));
        // Generamos una lista de 200 o más datos
    }

    public List<Persona> generarDatos() {
        return listaDatos.subList(0, 50);
    }

    public Object[] getResultado(int first, int last, Map<String, Object> filters) {
        List<Persona> listaFiltrada = null;
        int rowCount;

        if (filters.containsKey("codigo") && !filters.get("codigo").toString().isEmpty()) {
            listaFiltrada = listaDatos.stream().filter(persona -> persona.getCodigo().matches("(?i)(.*)" + filters.get("codigo").toString().trim() + "(.*)")).collect(Collectors.toList());
        }

        if (filters.containsKey("nombres") && !filters.get("nombres").toString().isEmpty()) {
            listaFiltrada = listaDatos.stream().filter(persona -> persona.getNombres().matches("(?i)(.*)" + filters.get("nombres").toString().trim() + "(.*)")).collect(Collectors.toList());
        }

        if (filters.containsKey("apellidos") && !filters.get("apellidos").toString().isEmpty()) {
            listaFiltrada = listaDatos.stream().filter(persona -> persona.getApellidos().matches("(?i)(.*)" + filters.get("apellidos").toString().trim() + "(.*)")).collect(Collectors.toList());
        }

        if (listaFiltrada == null) {
            if (last > listaDatos.size()) {
                last = listaDatos.size();
            }
            rowCount = listaDatos.size();
            listaFiltrada = listaDatos.subList(first, last);
        } else {
            if (last > listaFiltrada.size()) {
                last = listaFiltrada.size();
            }
            rowCount = listaFiltrada.size();
            listaFiltrada = listaFiltrada.subList(first, last);
        }
        
        return new Object[]{listaFiltrada, rowCount};
    }

}

Finalmente sólo nos resta ejecutar la clase PersonaView para ver el resultado, el cual es el siguiente:

Como podemos apreciar, crear JTable paginados en Java Swing es muy sencillo haciendo uso de la librería SwingUtils. Por otro lado, si tienes dudas sobre cómo usar éste componente, puedes escribirlas en la caja de comentarios.

Algoritmo para Calcular primeros n términos de la sucesión de Fibonacci

2018-04-09T15:23:00.000-05:00

La serie o sucesión de Fibonacci, es una sucesión infinita de números naturales que empieza con los términos 0 y 1, sucedidos consecutivamente por n términos, donde cada uno es la suma de los dos anteriores. Así pues, los primeros 15 términos de la serie de Fibonacci serían:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377...

Esta sucesión fue descrita en Europa por el matemático italiano Leonardo de Pisa alrededor del siglo XIII, quien también era conocido como Fibonacci. Esta sucesión tiene aplicaciones en diversos campos de la computación, las matemáticas y más increíble aún, se correlaciona con la estructura biológica de muchos seres vivos en la naturaleza.

Existen varias formas de hallar el término n de la sucesión de Fibonacci, y a partir de una de estas formas podemos obtener cada uno los anteriores términos de la serie. Así que veamos 2 de estas formas para hallar un término n de la sucesión de Fibonacci.

Primero que nada veamos la definición matemática de la sucesión de Fibonacci:

partiendo de dos primeros valores predeterminados que son:

Así pues, para hallar el sexto término de la sucesión de Fibonacci se calcularía así:

Ahora despejamos y reemplazamos cada término:

Como pudimos ver en el ejemplo, la sucesión de Fibonacci empieza a calcularse como tal a partir del término 2, ya que los primeros valores f₀ y f₁ están predeterminados.

Algoritmo recursivo para calcular el término n de la sucesión de Fibonacci

Tomamos como valor de entrada la variable n

1) Si n es menor que 2, retornamos el valor de n

En el ejemplo vimos que cada término en la serie, es la suma consecutiva de los dos anteriores términos hasta llegar al segundo término. Así pues, el paso 2 sería obtener el valor de dicha suma:

2) Retornamos la suma f_n-2 + f_n-1

En donde cada suma es el resultado de hacer el mismo proceso desde el paso 1. Esto lo conocemos como una forma recursiva. En la siguiente gráfica podemos apreciar de forma detallada este proceso:

Complejidad de la forma recursiva

A pesar de que la forma recursiva para calcular el término n de ls sucesión de Fibonacci requiere de pocos pasos, el costo computacional es elevado, ya que es un algoritmo de orden exponencial, es decir de Oⁿ. En el siguiente artículo podemos apreciar una explicación más detallada de la complejidad de los algoritmos: La complejidad de los algoritmos.

¿Y a qué se debe este nivel de complejidad?

Como podemos apreciar en la imagen, se debe a la repetición de las operaciones, la cual va creciendo exponencialmente según el término que se desea hallar. Así pues, f₆ se llama una vez, f₅ se llama una vez, f₄ 2 veces, f₃ 3 veces, f₂ 5 veces, f₁ 8 veces y f₀ 5 veces. Así pues, entre mayor sea el término a hallar, más rápido crecerán la cantidad de operaciones.

Algoritmo iterativo para calcular el término n de la sucesión de Fibonacci

Tomamos como valor de entrada la variable n

1) Declaramos tres variables de tipo entero: a, b y c. Inicializamos a con el valor 0, y b con el valor 1.

2) Iniciamos un ciclo for, el cual inicia en 0 y finaliza cuando la variable de control sea menor que n. Dentro del ciclo realizamos las siguientes acciones:

- A la variable c, le asignamos el total de la suma de a + b.

- A la variable a le asignamos el valor de b.

- A la variable b le asignamos el valor de c.

3) Al finalizar el ciclo, retornamos la variable a, la cual ha de tener el valor de f_n.

Complejidad de la forma iterativa

Como podemos apreciar, la forma iterativa realiza n repeticiones donde n es el término a hallar, y en cada repetición se realizan las respectivas sumas y asignaciones de variables; por lo tanto, decimos que la forma iterativa tiene una complejidad de O(n).

Existen muchas otras formas de calcular el término n de la sucesión de Fibonacci, sin embargo, estas dos son las que estaré representando en diversos lenguajes de programación en próximas entradas.

¿Cómo Sincronizar un ArrayList en Java?

2018-01-12T13:58:00.001-05:00

ArrayList es una Colección muy útil en Java, e incluso es una de la más usadas, aunque no es una colección sincronizada. ¿Qué significa esto? Significa que no se puede compartir una instancia de un ArrayList entre varios hilos (threads) no sólo para operaciones de lectura, sino tampoco para agregar o actualizar elementos.

Entonces, ¿Cómo podemos sincronizar un ArrayList en Java? Eso es lo que trataremos de explicar y con ejemplos en este tutorial, pero primero veamos la razón del por qué los ArrayList no están sincronizados por defecto en el API de Java. Los multi-procesos o multi-threading son una de las principales fortalezas de Java, e incluso casi todos los programas desarrollados en Java tienen más de un hilo; entonces ¿por qué Java no nos facilita de forma nativa el uso de ArrayList para dicho entorno?

La respuesta está en el rendimiento; hay un costo de rendimiento asociado con la sincronización y hacer que un ArrayList esté sincronizado haría que fuese más lento. Por lo tanto, los ArrayList quedaron nativamente en el API de Java como colecciones no sincronizadas para mantenerlos rápidos; sin embargo, el API de Java también nos proporciona formas fáciles de sincronizar un ArrayList en caso de que lo necesitemos, y esto es lo que vamos a aprender en este tutorial.

La clase Collections del API de Java tiene varios métodos para crear List, Set y Map sincronizados, y para este tutorial utilizaremos el método Collections.synchronizedList() para sincronizar un ArrayList. Este método acepta una lista que puede ser cualquier implementación de la interface List, como por ejemplo, ArrayList y LinkedList, y lo que nos devuelve es una lista sincronizada thread-safe (segura para subprocesos) respaldada por la lista especificada.

Lista Sincronizada e Iteración en Java

Uno de los principales desafíos a los que nos enfrentamos cuando queremos compartir un ArrayList entre múltiples hilos es el lidiar con situaciones en las que un hilo intenta acceder a un elemento que otro hilo ha eliminado. Si se utilizan métodos como get(index) o remove(index) para obtener o eliminar elementos, también es posible que otro hilo también esté intentando eliminar dichos elementos, aunque de forma no fiable, a menos de que se realice una verificación manual de la lista antes de usar los métodos get(index) y remove(index), lo cual significa que no se puede llamar a estos métodos de forma fiable sin antes verificar el tamaño de la lista, para lo cual también debe proporcionarse una sincronización adicional entre la llamada de los métodos size() y remove(int index).

Para garantizar el acceso en serie, es fundamental que todo el acceso a la lista de respaldo se realice a través de la lista devuelta y es imperativo que el usuario realice una sincronización manual en la lista devuelta al iterar sobre ella como se muestra en el siguiente código de ejemplo:

List list = Collections.synchronizedList(new ArrayList());

...
synchronized(list) {
    Iterator itr = list.iterator(); // El iterador debe estar en un bloque sincronizado
    while (itr.hasNext()) {
        Object obj = itr.next();
    }
}

Como se sugiere en la documentación de Java, no seguir este consejo puede dar como resultado un comportamiento no determinista, es decir, que no podemos saber de antemano cuál será el resultado cuando llamemos a los métodos get(index) y remove(index). Además, la lista será serializable si la ArrayList proporcionado es serializable.

Código para Sincronizar un ArrayList en Java

A continuación veremos un ejemplo completo para sincronizar un ArrayList en Java. Lo que haremos será crear una lista de String y añadiremos algunos elementos en ella. Luego, pasaremos dicha lista al método Collections.synchronizedList(), el cual nos devolverá una versión thread-safe (segura para subprocesos) de la lista.

Con esto, ya podríamos compartir esta lista de forma segura entre varios threads, pero debemos tener cuidado al recuperar o eliminar elementos del ArrayList. Así que para tener acceso seguro, debemos de usar un Iterator de forma sincronizada para obtener y eliminar elementos de la lista, tal como lo veremos en este ejemplo:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;


/**
 * How to synchronize ArrayList in Java
 * 
 * @author Andrés Mauricio (http://www.eljavatar.com)
 */

public class ArrayListSincronizadoDemo {

    public static void main(String args[]) {
       
       // Creamos una lista, la cual no está sincronizada
       List<String> marcasCelulares = new ArrayList<String>();
       
       marcasCelulares.add("SAMSUNG");
       marcasCelulares.add("IPHONE");
       marcasCelulares.add("HUAWEI");
       marcasCelulares.add("MOTOROLA");
       marcasCelulares.add("HTC");
       
       // Sincronizamos la lista
       marcasCelulares = Collections.synchronizedList(marcasCelulares);
       
       // Mientras iteramos sobre la lista sincronizada, se debe
       // sincronizar el iterador y las operaciones para evitar
       // comportamientos no deterministas
       
       synchronized(marcasCelulares) {
           Iterator<String> itr = marcasCelulares.iterator();
           
           while (itr.hasNext()) {
               System.out.println(itr.next());
           }
       }
       
    }

}

Salida de nuestro programa:

SAMSUNG
IPHONE
HUAWEI
MOTOROLA
HTC

Como hemos visto, es muy fácil sincronizar un ArrayList en Java gracias al método Collections.synchronizedList(), sin embargo, debemos ser un poco cuidadosos al recuperar y eliminar objetos de la Lista. Por cierto, existen otras dos opciones para conseguir una lista de elementos sincronizada, las cuales son Vector y CopyOnWriteArrayList.

Vector es una clase muy antigua, pero fue adaptada para implementar la interface List a partir de Java 1.4 y, lo que es más importante, está sincronizada, por lo cual no es necesario sincronizarla de nuevo. Por cierto, debes tener en cuenta que al usar la clase Vector, asegúrate de usarlo mediante la interface List y no mediante el uso de métodos heredados; de lo contrario, en caso de que desees cambiar de implementación después, no podrás hacerlo.

Por otro lado, CopyOnWriteArrayList es parte de las clases de colecciones concurrentes de Java y es mucho más escalable que Vector y ArrayList. Si una lista va a ser usada principalmente para leer registros, y sólo de vez en cuando va ser usada para realizar en ella operaciones de escritura, esta podría ser la elección más idónea.

¿Qué es un CopyOnWriteArrayList en Java?

2017-11-27T17:13:00.002-05:00

CopyOnWriteArrayList es una clase para trabajar colecciones concurrentes presentada en el API de concurrencia de Java a partir de la versión 5 junto con la otra muy popular clase ConcurrentHashMap. CopyOnWriteArrayList implementa la interface List, tal como lo hacen las clases ArrayList, Vector y LinkedList, con la diferencia de que CopyOnWriteArrayList es una colección thread-safety y logra la seguridad de subprocesos de una manera ligeramente diferente que la clase Vector u otra clase de colecciones thread-safe.

Como su nombre lo indica, CopyOnWriteArrayList crea una copia del ArrayList subyacente con cada operación de escritura, por ejemplo, agregar, eliminar o cuando se modifican valores. Es por esta razón que CopyOnWriteArrayList solo es adecuado cuando trabajemos con una lista que se lea con frecuencia pero se modifique raramente.

Normalmente, CopyOnWriteArrayList puede llegar a ser ineficiente porque implica costosas copias del Array con cada operación de escritura, pero es muy eficiente si lo que necesitamos es una lista donde las iteraciones superan las mutaciones, es decir, cuando las operaciones de escritura se dan con poca frecuencia.

El iterador de CopyOnWriteArrayList es fail-safe (a prueba de fallas) y no lanza excepciones de tipo ConcurrentModificationException, incluso si la lista se modifica una vez que comienza la iteración, ya que el Iterador actúa sobre una copia separada del ArrayList. En consecuencia, todas las actualizaciones realizadas fuera de un CopyOnWriteArrayList no están disponibles para su Iterator, es decir, que no podremos ver los cambios que realice otro hilo sobre la colección de datos.

Así pues, en este tutorial de Java Collections no sólo veremos qué es un CopyOnWriteArrayList, también expondré la diferencia entre ArrayList y CopyOnWriteArrayList y un ejemplo sencillo de un programa Java con el que aprenderemos cómo usar un CopyOnWriteArrayList en Java.

Diferencia entre CopyOnWriteArrayList y ArrayList en Java

Ya hemos visto lo que es un CopyOnWriteArrayList en Java y cómo éste logra la seguridad del thread al crear una copia separada de la colección para cada operación de escritura.

Ahora veamos algunas diferencias entre ArrayList y CopyOnWriteArrayList en Java, las cuales son ambas implementaciones de la interface List:

1) La principal diferencia entre CopyOnWriteArrayList y ArrayList en Java es que CopyOnWriteArrayList es una colección segura para subprocesos (thread-safe), mientras que ArrayList no es seguro para subprocesos y no puede ser usado en un entorno de múltiples hilos.

2) La segunda diferencia entre ArrayList y CopyOnWriteArrayList es que el Iterador de un ArrayList es fail-fast y lanzará una excepción de tipo ConcurrentModificationException una vez que detecta cualquier modificación en la Lista mientras está iterando; por el contrario, el Iterador de un CopyOnWriteArrayList es fail-safe y no lanza excepciones de tipo ConcurrentModificationException.

3) La tercera diferencia entre CopyOnWriteArrayList y ArrayList es que el iterador del primero no soporta la operación para eliminar elementos, mientras que el iterador del segundo si soporta el método remove().

Ejemplo de CopyOnWriteArrayList en Java

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 *
 * Programa para demostrar como usar CopyOnWriteArrayList en Java,
 * y como usar el Iterador de CopyOnWriteArrayList
 *
 * @author Andrés M. Barragán (eljavatar)
 */
public class EjemploCopyOnWriteArrayList {

    public static void main(String args[]) {
     
        CopyOnWriteArrayList<String> listThreadSafe = new CopyOnWriteArrayList<>();
        listThreadSafe.add("Asia");
        listThreadSafe.add("Africa");
        listThreadSafe.add("America");
        listThreadSafe.add("Europa");
        listThreadSafe.add("Oceania");
     
        // Las operaciones add y remove no están soportadas por el Iterador de CopyOnWriteArrayList
        Iterator<String> failSafeIterator = listThreadSafe.iterator();
        while (failSafeIterator.hasNext()) {
            System.out.printf("Lectura del CopyOnWriteArrayList : %s %n", failSafeIterator.next());
            failSafeIterator.remove(); // Esta línea lanzará una excepción. (Comentar para ejecutar completo)
        }
    }
}

La salida de este código (comentando la línea donde se usa el método remove()) sería la siguiente:

Lectura del CopyOnWriteArrayList : Asia 
Lectura del CopyOnWriteArrayList : Africa 
Lectura del CopyOnWriteArrayList : America 
Lectura del CopyOnWriteArrayList : Europa 
Lectura del CopyOnWriteArrayList : Oceania

Si lo ejecutamos sin comentar la línea donde se usa el método remove(), el resultado será el siguiente:

Lectura del CopyOnWriteArrayList : Asia 

Exception in thread "main" java.lang.UnsupportedOperationException
 at java.util.concurrent.CopyOnWriteArrayList$COWIterator.remove(CopyOnWriteArrayList.java:1176)
 at EjemploCopyOnWriteArrayList.main(EjemploCopyOnWriteArrayList.java:26)
Command exited with non-zero status 1

Esto es todo acerca de lo que es un CopyOnWriteArrayList en Java y su diferencia respecto a un ArrayList. En resumen, podemos concluir que deberíamos usar CopyOnWriteArrayList si nuestro objetivo es principalmente iterar sobre la lista sin modificarla.

SwingUtils - Sincronizar datos de un JTable con el Controlador (Java Swing)

2017-11-16T15:51:00.000-05:00

En un artículo anterior estuve explicando cómo crear un JTable en Java usando un Modelo de Datos genérico que nos provee la librería SwingUtils. Ahora veremos cómo sincronizar los datos de un JTable con un objeto de nuestro modelo de datos declarado en el controlador.

Como estuvimos viendo, un JTable nos permite trabajar con tipos de datos genéricos y dicho dato genérico es heredado por su modelo de datos, lo cual quiere decir que podemos trabajar incluso con tipos de datos de clases creadas por nosotros mismos.

Lo primero que debemos hacer es descargarnos la librería SwingUtils. Para hacerlo puedes revisar las instrucciones en el siguiente artículo:

==> SwingUtils - Librería de Utilidades para Java Swing

Anotaciones para usar en el Controlador

Las anotaciones que podemos usar en el Controlador según sean nuestras necesidades son las siguientes:

- ModelBean

- PropertyController

Para saber como usar estas anotaciones puedes revisar esta misma sección de "Anotaciones para usar en el Controlador" en el siguiente artículo:

==> SwingUtils - Sincronizar datos de un JTextField con el Controlador (Java Swing)

El modelo de datos que usaremos para nuestro JTable será el siguiente:

public class Pais {
    
    private Integer id;
    private String codigo;
    private String nombre;
 
    public Pais(Integer id, String codigo, String nombre) {
        this.id = id;
        this.codigo = codigo;
        this.nombre = nombre;
    }
 
    public Pais() {
    }
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getCodigo() {
        return codigo;
    }
 
    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    @Override
    public int hashCode() {
        int hash = 7;
        hash = 13 * hash + Objects.hashCode(this.id);
        hash = 13 * hash + Objects.hashCode(this.codigo);
        return hash;
    }
 
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Pais other = (Pais) obj;
        if (!Objects.equals(this.codigo, other.codigo)) {
            return false;
        }
        if (!Objects.equals(this.id, other.id)) {
            return false;
        }
        return true;
    }
     
}

El modelo de datos que usaremos para sincronizarlo con la vista será el siguiente:

public class MiModelo {
 
    private List<Pais> listaPaises;;
 
    public List<Pais> getListaPaises() {
        return listaPaises;
    }

    public void setListaPaises(List<Pais> listaPaises) {
        this.listaPaises = listaPaises;
    }
     
}

Recuerda que los Getter y Setter de los atributos son requeridos para asignar y obtener el valor de los atributos.

Anotaciones para usar en un JTable de Java Swing

La librería SwingUtils en su actual versión, permite asignar la siguiente anotación a un componente Java Swing de tipo JTable:

- TableView

Como ya he mencionado, el tipo de dato del API de Java a usar en el modelo de datos puede ser de cualquier tipo, ya que los JTable nos permiten trabajar con tipos de datos genéricos. Así pues, la forma de usar esta anotación sería la siguiente:

@TableView(name = "miModelo1.pais")
private javax.swing.JTable jTable1;

Declaramos nuestro controlador en la vista e inyectamos la dependencia de ésta para poder sincronizarlos. Además setearemos el modelo de datos para nuestro JTable, para lo cual haremos uso de la clase JTableUtils de la librería SwingUtils:

public class MiVista extends javax.swing.JFrame {
   
    private final MiControlador miControlador;
       
    public MiVista() {
        initComponents();
        
        this.miControlador = new MiControlador(this);
        
        JTableUtils.setProperties(jTable1, new Font("Arial", Font.BOLD, 13), new MiModeloTabla());
        jTable1.setSize(350, 250);
        JTableUtils.setAnchoColumnas(jTable1, jTable1.getWidth() - 1, 3, new int[]{20, 30, 50});
    }
    
    private void initComponents() {
        // Código generado por NetBeans
    }
}

La clase MiModeloTabla es el mismo modelo de datos que usamos en el artículo sobre cómo crear un JTable con un modelo de datos genérico, con la diferencia de que en este caso, lo inicializaremos con una lista vacía.

Tal cual como lo vimos en el artículo sobre Cómo sincronizar un JTextField con el controlador, los datos los podríamos obtener y setear de nuestro JTable en la vista de forma sencilla, sin embargo, para este ejemplo lo que queremos es mostrar dos listas diferentes mediante dos botones, así que los métodos que nos permitirán realizar esto serían ligeramente distintos:

// Método para obtener lista de países de Sudamérica
public List<Pais> getListPaisesSudamerica() {
    List<Pais> listaPaises = new ArrayList<>();
    listaPaises.add(new Pais(1, "CO", "Colombia"));
    listaPaises.add(new Pais(2, "AR", "Argentina"));
    listaPaises.add(new Pais(3, "VE", "Venezuela"));
    listaPaises.add(new Pais(4, "EC", "Ecuador"));
    listaPaises.add(new Pais(5, "PE", "Perú"));
    listaPaises.add(new Pais(6, "BO", "Bolivia"));
    listaPaises.add(new Pais(7, "PA", "Paraguay"));
    listaPaises.add(new Pais(8, "UR", "Uruguay"));
    listaPaises.add(new Pais(9, "CH", "Chile"));
    listaPaises.add(new Pais(10, "UR", "Brasil"));
    return listaPaises;
}

// Método para obtener lista de países de Europa
public List<Pais> getListPaisesEuropa() {
    List<Pais> listaPaises = new ArrayList<>();
    listaPaises.add(new Pais(1, "ES", "España"));
    listaPaises.add(new Pais(2, "FR", "Francia"));
    listaPaises.add(new Pais(3, "GE", "Alemania"));
    listaPaises.add(new Pais(4, "EN", "Inglaterra"));
    listaPaises.add(new Pais(5, "HO", "Holanda"));
    listaPaises.add(new Pais(6, "SU", "Suecia"));
    listaPaises.add(new Pais(7, "NO", "Noruega"));
    listaPaises.add(new Pais(8, "BE", "Bélgica"));
    return listaPaises;
}

// Método para mostrar en la tabla la lista de países de Sudamérica
public void verPaisesSudamerica() {
    miModelo1.setListaPaises(getListPaisesSudamerica());
    super.changeData(TipoUpdateEnum.VIEW);
}

// Método para mostrar en la tabla la lista de países de Europa
public void verPaisesEuropa() {
    miModelo1.setListaPaises(getListPaisesEuropa());
    super.changeData(TipoUpdateEnum.VIEW);
}

// Método para limpiar los datos
public void limpiar() {
    miModelo1 = new MiModelo();
    miModelo1.setListaPaises(new ArrayList<>());
    super.changeData(TipoUpdateEnum.VIEW);
}

Puedes revisar este artículo para comprender a fondo cómo funciona éste método super.changeData(), que como tal es el que realiza la actualización automática de los datos de la vista al modelo de datos en el controlador y viceversa. Como podemos apreciar también en el código, para limpiar o vaciar una tabla, es necesario setearle una lista vacía a la lista que tengamos en nuestro modelo de datos, o de lo contrario obtendremos una excepción de tipo java.lang.NullPointerException.

Como podemos apreciar, usando la librería SwingUtils, es muy rápido sincronizar fácilmente datos de un JTable con el Controlador para que la información de nuestra vista se actualice rápidamente en el modelo de datos y viceversa.

Diferencias entre ArrayList sincronizado y CopyOnWriteArrayList en Java

2017-11-03T10:50:00.001-05:00

Aunque tanto los ArrayList sincronizados como CopyOnWriteArrayList nos proporcionan seguridad cuando trabajamos con threads (subprocesos), y pueden ser usados cuando necesitemos que una lista se comparta entre varios threads, existe una sutil diferencia entre estas dos implementaciones: un ArrayList sincronizado, como su nombre lo indica, es una colección sincronizada mientras que un CopyOnWriteArrayList es una colección concurrente.

¿Qué significa esto? Significa que CopyOnWriteArrayList está diseñado teniendo en cuenta escenarios de concurrencia y es más escalable que un ArrayList sincronizado, siempre y cuando la lista se use principalmente para operaciones de lectura. Un ArrayList en Java no es sincronizado por defecto, por lo que no puede usarse directamente en un entorno de subprocesos (threads) múltiples, donde la lista se accede y se modifica mediante varios subprocesos. Para usar un ArrayList en dicho entorno, primero debemos obtener una lista sincronizada llamando a Collections.synchronizedList().

Esta lista sincronizada logra seguridad en el thread al bloquear toda la colección, lo que significa que si un hilo está leyendo de una lista y al mismo tiempo otro también intenta leer de la misma, estos irán uno por uno, es decir, que múltiples hilos pueden leer desde un mismo objeto sin ningún problema.

CopyOnWriteArrayList aprovecha también esta funcionalidad y proporciona lecturas sin bloqueos, lo cual significa un rendimiento mucho mejor si hay más hilos tratando de realizar operaciones de lectura y muy pocos o incluso ninguno realizando operaciones de escritura.

En resumen, la principal diferencia entre un ArrayList sincronizado y CopyOnWriteArrayList en Java proviene del hecho de cómo logran seguridad en sus operaciones entre hilos y qué tan escalables son.

List Sincronizado vs CopyOnWriteArrayList

En primer lugar, debemos de saber que Java hace uso del framework Collection, lo que nos evita usar muchas variantes de clases cunado tengamos que trabajar con listas de datos; así pues, el framework Collection nos proporciona wrappers mediante la clase java.util.Collections; por ejemplo, si necesitamos un ArrayList de solo lectura, podemos obtenerlo llamando a Collections.unmodifiableList(), y de forma similar, si necesitamos una lista sincronizada, podemos obtenerla llamando a Collections.synchronizedList().

Por lo general, estas implementaciones venían funcionado bien, pero con el tiempo, las aplicaciones Java se han vuelto más sofisticadas y cuando estas clases se exponen en entornos altamente concurrentes, se convierten en un cuello de botella. Una vez que los ingenieros detrás de Java se dieron cuenta de este hecho, vieron que necesitaban de colecciones que fuesen más escalables y pudiesen ofrecer mejor rendimiento cuando se utilizaran en un entorno de múltiples subprocesos (threads), y así es como a partir de Java 5 se incorporó un nuevo conjunto de clases para el manejo de colecciones denominado Concurrent Collections.

Esta librería incluye alternativas concurrentes de las colecciones más populares, como por ejemplo ConcurrentHashMap para HashMap y CopyOnWriteArrayList para ArrayList. Estas implementaciones están diseñadas específicamente para escenarios de alta concurrencia y es por eso que logran la seguridad del thread de una forma más sofisticada que simplemente bloquear toda la colección.

Recapitulemos entonces algunas de las diferencias claves entre un ArrayList sincronizado y CopyOnWriteArrayList en Java:

1) La primer diferencia entre un ArrayList sincronizado y CopyOnWriteArrayList proviene del hecho de cómo logran la seguridad del thread. Una lista sincronizada bloquea toda la colección para proporcionar sincronización y seguridad en los threads, mientras que CopyOnWriteArrayList no bloquea la colección y cuando un thread escribe en la lista, simplemente reemplaza la lista copiando sus elementos. De esta manera, proporciona acceso simultáneo a la lista para varios threads sin bloqueos y, dado que las operaciones de lectura son seguras cuando se ejecutan en distintos threads, quiere decir que no hay dos threads que puedan estar escribiendo en la misma lista de datos al tiempo.

2) La segunda diferencia proviene del hecho de cómo se comportan sus iteradores. El iterador devuelto desde un ArrayList sincronizado es un fail-fast iterator (Iterador que puede fallar rápido), mientras que el iterador devuelto por CopyOnWriteArrayList es un fail-safe iterator (Iterador a prueba de fallos), es decir, no lanzará ConcurrentModifcationException incluso en escenarios donde la lista se modifique mientras un thread esté iterando sobre ella.

3) En tercer lugar, y no menos importante, una de las principales diferencias entre CopyOnWriteArrayList y ArrayList es el rendimiento, especialmente si necesitamos que la lista se utilice principalmente con fines de solo lectura. Es probable que CopyOnWriteArrayList supere al ArrayList sincronizado si este es el caso, pero si la lista está expuesta a operaciones de lectura y escritura, es probable que el ArrayList sincronizado presente un mejor rendimiento.

Otra cosa muy importante que se debe tener en cuenta es el tamaño que tiene el ArrayList, o incluso el que pueda llegar a alcanzar, ya que debemos analizar según la necesidad que tengamos, si su gran costo de copiado (después de una operación de lectura) es lo suficientemente alto como para compensar el costo de bloqueo, pero si el ArrayList es pequeño, podría usarse CopyOnWriteArrayList sin preocuparse por este tipo de inconvenientes.

Estas son entonces las diferencias entre un ArrayList sincronizado y CopyOnWriteArrayList en Java que debes tener en cuenta y que te permitirán saber en qué escenario es mejor usar uno u otro. Básicamente, CopyOnWriteArrayList es una mejor opción si se accede principalmente a una lista para leer datos, pero si las operaciones de escritura son considerablemente altas, la mejor opción es usar un ArrayList sincronizado porque el costo de copiar la lista con cada operación sería mayor que la ganancia de sacrificar el bloqueo de la lista.

Otro aspecto que nos permitirá saber rápidamente qué opción escoger, es ver si necesitamos que el iterador detecte modificaciones concurrentes cuando se está recorriendo la lista o si se desea modificar la colección a través del iterador; en estos casos la opción idónea es un ArrayList Sincronizado.

Cómo implementar un Thread (Hilo) en Java

2017-10-24T11:47:00.002-05:00

Considero que los Thread es una de las características más importantes de Java, ya que contribuyó a que éste se convirtiera en un lenguaje de programación mucho más popular, pues una de las habilidades que se busca un programador es su comprensión sobre programación multi-hilos, y su capacidad para escribir aplicaciones que realicen sub-procesos múltiples.

El principal problema con la programación de aplicaciones que puedan ejecutar varios sub-procesos al mismo tiempo, está relacionado con inconvenientes relacionados con concurrencia, deadlock, race condition, entre otros, lo cual lleva a que implementar multi-hilos en algunas aplicaciones Java requiera de cierto esfuerzo.

En este tutorial veremos algunas formas de implementar un Thread (hilo) en Java, lo cual le permitirá crear e inicializar hilos ya sea implementando la interface Runnable o extendiendo de la clase Thread.

Cómo crear un Thread en Java

Existen dos formas de implementar hilos en Java:

1) Extendiendo de la clase java.lang.Thread

2) Implementando la interface java.lang.Runnable

Antes de entrar en detalles sobre cómo implementar una opción o la otra, sería pertinente saber cuando debemos usar un Thread en Java. Un hilo o thread en Java lo usaremos en caso de que queramos que una funcionalidad (parte del código) de nuestro programa se ejecute en paralelo al proceso principal, así pues, dicho código lo colocaríamos dentro del método run() de la clase Thread o la interface Runnable para que se cumpla dicho cometido.

Como tal, el método público run() se define en la interface Runnable, y como la clase Thread implementa dicha interface, hereda automáticamente éste método.

Teniendo en cuenta de que contamos con dos formas de implementar un Thread en Java, una pregunta que tal vez puede surgirnos es saber cuál de las dos es mejor: extendiendo de la clase Thread o implementando la interface Runnable.

Por cuestiones de diseño, considero que la mejor forma es implementando la interface Runnable, ya que si tenemos en cuenta de que en Java sólo podemos extender de una sola clase, si extendemos de la clase Thread, ya no podríamos hacerlo de alguna otra clase, mientras que implementando la interface Runnable, podremos implementar otra interface en cualquier momento que necesitemos.

Además, tengamos en cuenta que según la Programación Orientada a Objetos, el propósito de extender una clase es proporcionar alguna característica o funcionalidad nueva, así que si nuestro propósito es simplemente usar el método run(), el cual usaremos solamente para definir qué parte de nuestro código se ejecutará en otro hilo, la opción más razonable sería implementar la interface Runnable.

Así que después de decidir de qué forma se creará el Thread en java, lo siguiente que debemos hacer es crear el objeto de nuestro thread e iniciar el sub-proceso. Esto creará una ruta de ejecución separada paralela al hilo principal de la aplicación.

Cómo se ejecuta un Thread en Java

Un thread en java está basado en estados, así que cuando se crea un objeto de la clase del thread que definimos extendiendo de la clase Thread o implementando de la interface Runnable, éste solamente se crea con un estado predefinido, pero no se iniciará hasta que se llame al método start() de la clase java.lang.Thread.

Entonces, cuando creamos el objeto del thread en java, éste quedará en un estado New, y al llamar al método start(), la Máquina Virtual de Java ejecuta el método run() de la clase que definimos, lo que hace que el thread pase al estado Runnable. A partir de aquí, sera el planificador de Threads el encargado de asignar CPU a este sub-proceso (hilo).

Ya después de esto, el thread puede pasar a estado Terminated o quedar en estado Waiting, Time Waiting o Blocked. Veamos el código:

Ejemplo de implementación de un Thread en Java

// Implementación de hilos extendiendo de la clase Thread
public class MyThread extends Thread {

    public void run() {
        System.out.println("Thread Running " + Thread.currentThread().getName());
    }

}


// Implementación de hilos implementando la interface Runnable
public class MyRunnable implements Runnable {         

    public void run() {
        System.out.println("Creamos Thread " + Thread.currentThread().getName());
    }

}


// Iniciando Threads en Java
Thread mythread = new MyThread(); // Se crea el Thread pero no inicia
mythread.setName("Thread 1");
Thread myrunnable = new Thread(new MyRunnable(),"Thread 2"); // Thread creado       

mythread.start(); // Inicia el Thread (No necesariamente indica que haya empezado a ejecutarse) 
myrunnable.start();

¿Qué pasaría en caso de que en vez de llamar al método start(), intentemos ejecutar directamente el método run()? No tendríamos error ni una Excepción; simplemente se ejecutará en el mismo thread (hilo) desde el que se llama el método. ¿Y si intentamos llamar dos veces al método start() del mismo objeto Thread?

mythread.start(); 
mythread.start(); // Esta línea lanzará una excepción de tipo IllegalThreadStateException

Puntos a tener en cuenta sobre crear un Thread en Java

1) Este ejemplo no garantiza que el hilo mythread se inicie antes que el hilo myrunnable. Como se explicó, esto depende del planificador de Threads.

2) Un Thread pasará a estado muerto una vez que finaliza la ejecución del método run(), y por tanto, dicho Thread no puede volver a iniciar otra vez.

SwingUtils - Crear JTable con Modelo de Datos Genérico (Java Swing)

2017-10-23T11:07:00.000-05:00

Hace tiempo publiqué un artículo en el que enseñaba Cómo crear un modelo de datos personalizado para un JTable en Java Swing, en el cual podemos ver cómo el API de Java Swing separa la vista de un JTable y su modelo de datos. Teniendo en cuenta lo que enseño en dicho artículo, decidí crear un Modelo de datos Pseudo-genérico dentro de la librería SwingUtils, de tal forma que los modelos de datos que creemos para nuestras tablas sean lo menos verbosos posible.

No me expandiré mucho en los detalles acerca de cómo funciona un modelo de datos en un JTable de Java Swing, ya que eso lo explico en este artículo; así que veamos directamente qué es lo que nos provee la librería SwingUtils para crear los modelos de datos de los JTable de forma rápida y sencilla.
Lo primero que debemos hacer es importar la librería SwingUtils a nuestro proyecto. Puedes ver las instrucciones en el siguiente enlace:

==> SwingUtils - Librería de Utilidades para Java Swing

La librería SwingUtils nos provee la clase TableModelGeneric de la cual podemos extender los modelos de datos que creemos para nuestros JTable. Así que veamos primero la clase modelo que usaremos para nuestro ejemplo:

public class Pais {
    
    private Integer id;
    private String codigo;
    private String nombre;

    public Pais(Integer id, String codigo, String nombre) {
        this.id = id;
        this.codigo = codigo;
        this.nombre = nombre;
    }

    public Pais() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getCodigo() {
        return codigo;
    }

    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 13 * hash + Objects.hashCode(this.id);
        hash = 13 * hash + Objects.hashCode(this.codigo);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Pais other = (Pais) obj;
        if (!Objects.equals(this.codigo, other.codigo)) {
            return false;
        }
        if (!Objects.equals(this.id, other.id)) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return nombre;
    }
    
}

Éste será el tipo de dato que ocuparán los datos de nuestro JTable. Ahora veamos el modelo de datos que usará el JTable de nuestro modelo:

public class MiModeloTabla extends TableModelGeneric<Pais> {
    
    /**
     * Este Constructor sin parámetros lo usaríamos para el comportamiento por
     * defecto de un JTable el cual deseemos inicializar con las propiedades
     * de tipo de dato y título de columnas predefinidas pero sin lista de datos
     */
    public MiModeloTabla() {
        super(
                new Class[]{Integer.class, String.class, String.class}, 
                new String[]{"Id", "Código", "Nombre"}, 
                new ArrayList<>()
        );
    }
    
    /**
     * Este Constructor lo usaríamos para el comportamiento de un JTable el cual
     * deseemos inicializar con las propiedades de tipo de dato y título de
     * columnas predefinidas, pero con una lista de datos proveída por nosotros
     * desde la creación del modelo de datos
     * @param listElements 
     */
    public MiModeloTabla(List<Pais> listElements) {
        super(
                new Class[]{Integer.class, String.class, String.class}, 
                new String[]{"Id", "Código", "Nombre"}, 
                listElements
        );
    }
    
    /**
     * Este Constructor lo usaríamos para el caso en que deseemos proporcionar
     * todas las propiedades de un JTable desde el momento en que creamos
     * nuestro modelo de datos
     * @param typeColumns
     * @param titleColumns
     * @param listElements 
     */
    public MiModeloTabla(Class[] typeColumns, String[] titleColumns, List<Pais> listElements) {
        super(typeColumns, titleColumns, listElements);
    }
    
    /**
     * Este método es necesario que lo sobre-escribamos, ya que mediante éste
     * indicamos los datos que se muestran en cada columna y fila del JTable
     * @param rowIndex
     * @param columnIndex
     * @return 
     */
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        switch (columnIndex) {
            case 0:
                return getListElements().get(rowIndex).getId();
            case 1:
                return getListElements().get(rowIndex).getCodigo();
            case 2:
                return getListElements().get(rowIndex).getNombre();
            default:
                return null;
        }
    }
    
}

En nuestro modelo de datos sólo necesitamos de tres cosas:

1. Extender de la clase TableModelGeneric la cual nos provee la librería SwingUtils.

2. Crear un constructor que llame al constructor de la clase TableModelGeneric. En este ejemplo vemos tres ejemplos, aunque en verdad sólo bastaría con un constructor; todo depende de cómo necesitemos crear nuestros JTable e inicializar sus respectivos modelos de datos.

3. Sobre-escribir el método getValueAt() el cual pertenece a la interface TableModel, ya que mediante éste método indicamos los datos que se muestran en cada columna y fila del JTable.

Con ésto sólo nos resta inicializar nuestro modelo de datos y asignarlo al JTable.

Implementar nuestro modelo de datos en un JTable de Java Swing

Mediante la librería SwingUtils podemos implementar nuestro modelo de datos de forma rápida, ya que nos provee algunos métodos a través de la clase JTableUtils, aunque en este caso sólo haremos uso de uno de ellos. Veamos entonces como quedaría nuestro ejemplo:

public class MiVista extends javax.swing.JFrame {
   
    private javax.swing.JTable jTable1;
       
    public MiVista() {
        initComponents();
         
        List<Pais> listaPaises = new ArrayList<>();
        listaPaises.add(new Pais(1, "CO", "Colombia"));
        listaPaises.add(new Pais(2, "AR", "Argentina"));
        listaPaises.add(new Pais(3, "VE", "Venezuela"));
        listaPaises.add(new Pais(4, "EC", "Ecuador"));
        listaPaises.add(new Pais(5, "PE", "Perú"));
        listaPaises.add(new Pais(6, "BO", "Bolivia"));
        listaPaises.add(new Pais(7, "MX", "México"));
         
        JTableUtils.setProperties(jTable1, new Font("Arial", Font.BOLD, 13), new MiModeloTabla(listaPaises));
    }

    private void initComponents() {
        // Código generado por NetBeans
    }
       
}

En este caso, usamos uno de los métodos estáticos setProperties() de la clase JTableUtils; cabe aclarar que esta clase sobrecarga varias veces éste método, así que para este ejemplo ocupamos el que recibe tres parámetros: El JTable que usaremos, la fuente de los títulos del JTable y la inicialización del modelo de datos que creamos.

Esta es la captura de pantalla de nuestro ejemplo. Como hemos visto, es muy sencillo crear modelos de datos pseudo-genéricos e implementarlos en nuestros JTable a través de la librería SwingUtils.

SwingUtils - Sincronizar datos de un JComboBox con el Controlador (Java Swing)

2017-09-27T14:24:00.001-05:00

En un artículo anterior estuve explicando cómo crear un JComboBox en Java usando un Modelo de Datos genérico que nos provee la librería SwingUtils. Ahora veremos cómo sincronizar los datos de un JComboBox con un objeto de nuestro modelo de datos declarado en el controlador.

Como estuvimos viendo, un JComboBox nos permite trabajar con tipos de datos genéricos y dicho dato genérico es heredado por su modelo de datos, lo cual quiere decir que podemos trabajar incluso con tipos de datos de clases creadas por nosotros mismos.

Lo primero que debemos hacer es descargarnos la librería SwingUtils. Para hacerlo puedes revisar las instrucciones en el siguiente artículo:

==> SwingUtils - Librería de Utilidades para Java Swing

Anotaciones para usar en el Controlador

Las anotaciones que podemos usar en el Controlador según sean nuestras necesidades son las siguientes:

- ModelBean
- PropertyController

Para saber como usar estas anotaciones puedes revisar esta misma sección de "Anotaciones para usar en el Controlador" en el siguiente artículo:

==> SwingUtils - Sincronizar datos de un JTextField con el Controlador (Java Swing)

El modelo de datos que usaremos para nuestro JComboBox será el siguiente:

public class Pais {
    
    private Integer id;
    private String codigo;
    private String nombre;

    public Pais(Integer id, String codigo, String nombre) {
        this.id = id;
        this.codigo = codigo;
        this.nombre = nombre;
    }

    public Pais() {
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getCodigo() {
        return codigo;
    }

    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 13 * hash + Objects.hashCode(this.id);
        hash = 13 * hash + Objects.hashCode(this.codigo);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final Pais other = (Pais) obj;
        if (!Objects.equals(this.codigo, other.codigo)) {
            return false;
        }
        if (!Objects.equals(this.id, other.id)) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return nombre;
    }
    
}

Como vemos, es necesario sobrescribir los métodos toString(), equals() y hashCode().

El modelo de datos que usaremos para sincronizarlo con la vista será el siguiente:

public class MiModelo {

    private Pais pais;

    public Pais getPais() {
        return pais;
    }

    public void setPais(Pais pais) {
        this.pais = pais;
    }
    
}

Recuerda que los Getter y Setter de los atributos son requeridos para asignar y obtener el valor de los atributos.

Anotaciones para usar en un JComboBox de Java Swing

La librería SwingUtils en su actual versión, permite asignar la siguiente anotación a un componente Java Swing de tipo JComboBox:

- ComboBoxView

Como ya he mencionado, el tipo de dato del API de Java a usar en el modelo de datos puede ser de cualquier tipo, ya que los JComboBox nos permiten trabajar con tipos de datos genéricos. Así pues, la forma de usar esta anotación sería la siguiente:


@ComboBoxView(name = "miModelo1.pais", required = true, requiredMessage = "Debe seleccionar un elemento")

private javax.swing.JComboBox<Pais> jComboBox1;

Además del nombre del componente (name), es posible usar también los atributos required y requiredMessage. El primero, es una propiedad booleana mediante la cual podemos indicar si queremos que sea obligatoria o no la selección de un elemento; y el segundo, es un mensaje personalizado que se mostrará al usuario en formato de error, en caso de que la propiedad required sea true y no se haya seleccionado ningún elemento del JComboBox.

Declaramos nuestro controlador en la vista e inyectamos la dependencia de ésta para poder sincronizarlos. Además setearemos el modelo de datos para nuestro JComboBox, para lo cual haremos uso de la clase JComboBoxUtils de la librería SwingUtils:

public class MiVista extends javax.swing.JFrame {
  
    private final MiControlador miControlador;
      
    public MiVista() {
        initComponents();
          
        this.miControlador = new MiControlador(this);
        
        List<Pais> listaPaises = new ArrayList<>();
        listaPaises.add(new Pais(1, "CO", "Colombia"));
        listaPaises.add(new Pais(2, "AR", "Argentina"));
        listaPaises.add(new Pais(3, "VE", "Venezuela"));
        listaPaises.add(new Pais(4, "EC", "Ecuador"));
        listaPaises.add(new Pais(5, "PE", "Perú"));
        listaPaises.add(new Pais(6, "BO", "Bolivia"));
        listaPaises.add(new Pais(7, "MX", "México"));
        
        JComboBoxUtils.setProperties(jComboBox1, listaPaises);
    }
      
}

Tal cual como lo vimos en el artículo sobre Cómo sincronizar un JTextField con el controlador, los datos los obtendríamos y seteariamos en la vista de la siguiente forma:

// Método para guardar los datos
public void guardar() {
    super.changeData(TipoUpdateEnum.MODEL);
    printConsole();
}
  
// Método para limpiar el formulario
public void limpiar() {
    miModelo1 = new MiModelo();
    super.changeData(TipoUpdateEnum.VIEW);
}
  
// Método para imprimir los datos por consola
public void printConsole() {
    System.out.println("País Seleccionado Modelo 1: " + miModelo1.getPais());
}

Como podemos apreciar, usando la librería SwingUtils, es muy rápido sincronizar fácilmente datos de un JComboBox con el Controlador para que la información de nuestra vista se actualice rápidamente en el modelo de datos y viceversa.

SwingUtils - Crear JComboBox con Modelo de Datos Generico (Java Swing)

2017-09-20T12:10:00.003-05:00

En este artículo veremos las opciones que nos ofrece la librería SwingUtils para trabajar de forma sencilla con componentes de tipo javax.swing.JComboBox y un modelo de datos genérico.

El API de Java Swing nos ofrece por defecto la clase javax.swing.DefaultComboBoxModel para setearle un Model a nuestros JComboBox, sin embargo, al analizarla a detalle, encontré cosas que no me convencieron de trabajar directamente con dicha clase:

- La primera es que la clase DefaultComboBoxModel guarda los datos en un Vector, lo que hace que los datos estén sincronizados por defecto, y al menos en mi experiencia, son muy pocos los casos en los que vamos a necesitar una colección de datos sincronizada dentro de un JComboBox, además recordemos que la sincronización requiere de más recursos de máquina.

- La segunda, es que podemos encontrarnos casos en los que pasemos una colección de datos la cual por defecto no permita modificaciones, como el caso de Arrays.asList(T ...a) del paquete java.util.Arrays; si nosotros le pasamos por ejemplo la colección Arrays.asList("a", "b", "c").toArray() al constructor de DefaultComboBoxModel(E[] item), éste lo tomará tal cual y no podremos modificar dicho modelo de datos posteriormente, es decir, que si quisiéramos agregar el elemento "d", obtendríamos una excepción.

Por estas razones, decidí agregar la clase ComboBoxModelGeneric a la librería SwingUtils, la cual, a pesar de estar basada en la clase DefaultComboBoxModel, difiere de ésta en lo siguiente:

- La clase ComboBoxModelGeneric guarda los datos en un java.util.List, lo que evita la sincronización por defecto y ahorra recursos de máquina. ¿Y en caso de que necesitemos sincronización? Como mencioné, no es muy frecuente que necesitemos sincronización de datos, sin embargo SwingUtils también soporta el uso de listas sincronizadas en caso de que lo requiramos.

- Por otro lado, los constructores de la clase ComboBoxModelGeneric siempre van a convertir los datos que reciban, en una colección de tipo java.util.ArrayList, lo que garantiza que podamos modificar los datos del modelo de nuestro JComboBox cuando así se requiera.

Ahora si, vamos a ver cómo podemos hacer uso de un modelo de datos para nuestro JComboBox a través de la clase ComboBoxModelGeneric.

Usar un Modelo de Datos Genérico en un JComboBox de Java Swing

Lo primero que debemos hacer es importar la librería SwingUtils a nuestro proyecto. Puedes ver las instrucciones en el siguiente enlace:

==> SwingUtils - Librería de Utilidades para Java Swing

Para usar un modelo de la clase ComboBoxModelGeneric, no necesitamos mucho código. Esta clase podemos usarla de forma genérica en cualquier JComboBox, por lo tanto, decidí crear una clase de utilería llamada JComboBoxUtils, mediante la cual es muy fácil asociar nuestro modelo de datos.

Esta clase contiene varios métodos estáticos. Algunos de estos métodos son:

setProperties(final JComboBox<E> jComboBox, List<E> list)

setProperties(final JComboBox<E> jComboBox, List<E> list, boolean addElementNullDefault, String textNoSeleccionable)

setProperties(final JComboBox<E> jComboBox, List<E> list, boolean addElementNullDefault, String textNoSeleccionable, boolean isSynchronized, boolean needDetectConcurrentModifications, Class clazz, String nameMethod)

El primer método es la configuración rápida por defecto. Con éste método, tan sólo debemos pasar nuestro JComboBox, el cual ya debe estar inicializado previamente, y la lista de datos que deseamos agregar a nuestro modelo. Éste método además de crear el modelo de datos usando la clase ComboBoxModelGeneric y asociárselo al JComboBox, crea un elemento null con la leyenda "- Seleccione -" al principio de la lista de datos.

El segundo método funciona de forma similar al segundo; sin embargo, a éste podemos indicarle si queremos que agregue el elemento null por defecto al principio de la lista de datos o no, y la leyenda que quisiéramos que tuviera este elemento en caso de que indiquemos true al parámetro addElementNullDefault.

El tercer método, correspondería a la configuración completa, y además de las configuraciones mencionadas en los dos métodos anteriores, podemos indicarle si queremos que sea una lista de datos sincronizada o no, además de poderle indicar si queremos que nuestra lista detecte modificaciones concurrentes. Para entender en qué afecta este atributo a la lista de datos, puedes revisar el siguiente artículo: Diferencias entre ArrayList sincronizado y CopyOnWriteArrayList en Java. Este cambio sólo tendrá efecto si se pasa el parámetro isSynchronized en true. Los dos últimos parámetros corresponden a cómo queremos que se muestren los datos; veamos cómo los usaríamos.

Lo que se muestra en los ítems de un JComboBox por defecto son String, así que si le pasamos una lista de objetos creados por nosotros, por defecto se mostrará lo que esté en el método toString(). ¿Pero qué pasa si nuestro método toString() ya está siendo usado para otra cosa? No se, supongamos que para alguna característica de nuestra aplicación se está devolviendo un código o algo así, pero en nuestro JComboBox lo que deseamos es mostrar una descripción, ¿Qué hacemos en dicho caso?

Para eso son estos dos últimos parámetros. El primero es el class de nuestro objeto, que dicho sea de paso, debe ser del mismo tipo que la lista de datos que estamos pasando al JComboBox, y el segundo es el nombre del método que retornará el valor a mostrar en cada ítem; dicho método debe retornar un valor de tipo String y debe estar declarado en la clase que pasamos en el primer parámetro.

Veamos un sencillo ejemplo de cómo podemos hacer uso de uno de éstos métodos:

List<String> lista = Arrays.asList("Amarillo", "Azul", "Rojo", "Verde", "Gris", "Negro", "Blanco");
JComboBoxUtils.setProperties(miJComboBox, lista);

Recordemos que un JComboBox nos permite trabajar con tipos de datos genéricos y dicho dato genérico es heredado por su modelo de datos, es decir, que no solamente nos debemos limitar a trabajar con datos de tipo String, sino que podemos tener modelos de datos con otros tipos como enums u objetos creados por nosotros mismos.

Lo único que debemos tener en cuenta es realizar los siguientes ajustes en la clase que usaremos como tipo de dato para nuestro JComboBox:

- Sobrescribir el método toString(), ya que este es el texto que se mostrará en cada ítem del JComboBox en caso de que no pasemos los dos últimos parámetros que explicamos. Si pasamos dichos parámetros, necesitaríamos crear el método que nos retornará el texto que se mostraría en cada ítem.

- Sobrescribir los métodos hashCode() y equals(). En caso de que sean enums, estos métodos no son necesarios; sin embargo, si se trata de una clase creada por nosotros, debemos sobrescribirlos pues son los que se usan para asignar y obtener un valor de un JComboBox.

Como podemos apreciar, es muy sencillo asociar un modelo de datos genérico a cualquier JComboBox de Java Swing que tengamos usando la librería SwingUtils.

SwingUtils - Sincronizar datos de un JCheckBox con el Controlador (Java Swing)

2017-09-15T15:36:00.000-05:00

En este artículo veremos como sincronizar un JCheckBox de java swing con un atributo de tipo booleano del controlador para que los datos se actualicen automáticamente tanto en la vista (JCheckBox) como en el modelo de datos (atributo independiente u atributo de objeto compuesto declarados en el controlador), usando la librería SwingUtils.

La librería SwingUtils no sólo permite hacer esta sincronización con componentes de tipo javax.swing.JCheckBox; también es posible usarla con componentes de tipo javax.swing.JToggleButton y los otros componentes que heredan de esta clase:

javax.swing.JToggleButton
javax.swing.JCheckBox
javax.swing.JRadioButton

Lo primero que debemos hacer es descargar la librería SwingUtils, para lo cual puedes revisar las instrucciones en el siguiente enlace:

==> SwingUtils - Librería de Utilidades para Java Swing

Anotaciones para usar en el Controlador

Las anotaciones que podemos usar en el Controlador según sean nuestras necesidades son las siguientes:

- ModelBean
- PropertyController

Para saber como usar estas anotaciones puedes revisar esta misma sección de "Anotaciones para usar en el Controlador" en el siguiente artículo:

==> SwingUtils - Sincronizar datos de un JTextField con el Controlador (Java Swing)

El modelo de datos que usaremos es el siguiente:

public class MiModelo {

    private Boolean booleanModelo;

    public Boolean getBooleanModelo() {
        return booleanModelo;
    }

    public void setBooleanModelo(Boolean booleanModelo) {
        this.booleanModelo = booleanModelo;
    }
    
}

Recuerda que los Getter y Setter de los atributos son requeridos para asignar y obtener el valor de los atributos.

Anotaciones para usar en un JCheckBox, JRadioButton o JToggleButton de Java Swing

La librería SwingUtils en su actual versión, permite asignar un tipo de anotación a un componente de tipo JCheckBox, JRadioButton o JToggleButton:

- ToggleButtonView

Ésta anotación puede ser usada indistintamente de la misma forma en cualquiera de estos tres tipos de componente, pues el valor que nos devuelve cada uno de ellos es siempre un booleano, por lo tanto, el tipo de dato del API de Java a usar en el modelo de datos puede ser:

Boolean o boolean

Como podemos apreciar, podemos usar indistintamente el objeto o el tipo primitivo.

La forma de usar ésta anotación sería la siguiente:

@ToggleButtonView(name = "miModelo1.booleanModelo")
private javax.swing.JCheckBox jCheckBox1;

Recuerda que el uso para componentes de tipo JRadioButton o JToggleButton es igual, sin embargo, para este tutorial sólo haremos el ejemplo con un JCheckBox.

Declaramos nuestro controlador en la vista e inyectamos la dependencia de ésta para poder sincronizarlos:

public class MiVista extends javax.swing.JFrame {
 
    private final MiControlador miControlador;
     
    public MiVista() {
        initComponents();
         
        this.miControlador = new MiControlador(this);
    }
     
}

Tal cual como lo vimos en el artículo sobre Cómo sincronizar un JTextField con el controlador, los datos los obtendríamos y seteariamos en la vista de la siguiente forma:

// Método para guardar los datos
public void guardar() {
    super.changeData(TipoUpdateEnum.MODEL);
    printConsole();
}
 
// Método para limpiar el formulario
public void limpiar() {
    miModelo1 = new MiModelo();
    super.changeData(TipoUpdateEnum.VIEW);
}
 
// Método para imprimir los datos por consola
public void printConsole() {
    System.out.println("Boolean Modelo 1: " + miModelo1.getBooleanModelo());
}

Como podemos apreciar, usando la librería SwingUtils, es muy rápido sincronizar fácilmente datos de un JCheckBox, un JRadioButton o un JToggleButton con el Controlador para que la información de nuestra vista se actualice rápidamente en el modelo de datos y viceversa.

SwingUtils - Sincronizar datos de un JTextField con el Controlador (Java Swing)

2017-09-14T16:12:00.000-05:00

En este artículo veremos como sincronizar un JTextField de java swing con un atributo del controlador para que los datos se actualicen automáticamente tanto en la vista (JTextField) como en el modelo de datos (atributo independiente u atributo de objeto compuesto declarados en el controlador), usando la librería SwingUtils.

La librería SwingUtils no sólo permite hacer esta sincronización con componentes de tipo javax.swing.JTextField; también es posible usarla con los otros componentes que heredan de la clase javax.swing.JTextComponent:

javax.swing.JTextField
javax.swing.JFormattedTextField
javax.swing.JPasswordField
javax.swing.JTextArea
javax.swing.JEditorPane
javax.swing.JTextPane

Lo primero que debemos hacer es descargar la librería SwingUtils; para ésto puedes ver las instrucciones en el siguiente enlace:

==> SwingUtils - Librería de Utilidades para Java Swing

Anotaciones para usar en el Controlador

En el controlador podemos usar dos anotaciones según sea el caso que necesitemos:

- ModelBean

- PropertyController

Veamos cómo podemos usar cada una de estas:

public class MiControlador extends AbstractObserverController {

    @PropertyController
    private String texto1;

    @PropertyController(name = "miTexto")
    private String texto2;

    @ModelBean
    private MiModelo miModelo1;

    @ModelBean(name = "pruebaModelo")
    private MiModelo miModelo2;

    private final MiVista miVista;

    public MiControlador(MiVista miVista) {
        this.miVista = miVista;
        this.miModelo1 = new MiModelo();
        this.miModelo2 = new MiModelo();
        super.setListeners(this, this.miVista);
    }

    public String getTexto1() {
        return texto1;
    }

    public void setTexto1(String texto1) {
        this.texto1 = texto1;
    }

    public String getTexto2() {
        return texto2;
    }

    public void setTexto2(String texto2) {
        this.texto2 = texto2;
    }

    public MiModelo getMiModelo1() {
        return miModelo1;
    }

    public void setMiModelo1(MiModelo miModelo1) {
        this.miModelo1 = miModelo1;
    }

    public MiModelo getMiModelo2() {
        return miModelo2;
    }

    public void setMiModelo2(MiModelo miModelo2) {
        this.miModelo2 = miModelo2;
    }
   
}

A continuación explicaré éste código:

Línea 1: Nuestro controlador debe extender de la clase AbstractObserverController de la librería JavaSwing.

Línea 3: Anotación @PropertyController sin ningún atributo. Esto quiere decir que para acceder a esta propiedad en la vista, debemos hacerlo usando su mismo nombre, es decir, para este caso: "texto1".

Línea 6: Anotación @PropertyController con atributo name definido. Es decir, que para acceder a esta propiedad en la vista, debemos hacerlo usando el valor que hemos definido en name, que para este caso es "miTexto".

Línea 9: Anotación @ModelBean sin ningún atributo. Esto quiere decir que para acceder a este objeto en la vista, debemos hacerlo usando su mismo nombre, es decir, para este caso: "miModelo1.atributo". Los atributos en un objeto compuesto, debemos de llamarlos tal cual están definidos en la clase.

Línea 12: Anotación @PropertyController con atributo name definido. Es decir, que para acceder a esta propiedad en la vista, debemos hacerlo usando el valor que hemos definido en name, que para este caso es "pruebaModelo.atributo". Como en el caso anterior, los atributos en un objeto compuesto, debemos de llamarlos como están definidos en la clase.

Línea 21: Seteamos los objetos del Controlador y la Vista que escucharán los cambios. Lo más recomendable es asignarlos al final del constructor.

El resto de métodos son los Getter y Setter de las propiedades a las que les hemos asignado las anotaciones. Estos métodos son obligatorios para asignar y obtener los datos.

Veamos a continuación el modelo que usaremos:

public class MiModelo {
    
    private String textoModelo;
    private Date fechaModelo;
    private Integer numeroModelo;

    public String getTextoModelo() {
        return textoModelo;
    }

    public void setTextoModelo(String textoModelo) {
        this.textoModelo = textoModelo;
    }

    public Date getFechaModelo() {
        return fechaModelo;
    }

    public void setFechaModelo(Date fechaModelo) {
        this.fechaModelo = fechaModelo;
    }

    public Integer getNumeroModelo() {
        return numeroModelo;
    }

    public void setNumeroModelo(Integer numeroModelo) {
        this.numeroModelo = numeroModelo;
    }
    
}

Recuerda que en una clase de modelo, al igual que en el controlador, también son obligatorios los métodos Getter y Setter para cada uno de los atributos definidos.

Anotaciones para usar en un JTextField de Java Swing

La librería SwingUtils en su actual versión, permite asignar tres tipos de anotaciones a un componente de tipo JTextField:

- TextView

- DateTextView

- NumberTextView

Estas anotaciones pueden ser usadas en cualquier campo de tipo texto de java swing, sin embargo cada una tiene ciertas particularidades; @TextView puede ser usada para sincronizar el JTextField con cualquiera de los siguientes tipos de datos del API de Java:

String
Character o char
Byte o byte
Short o short
Integer o int
Long o long
Float o float
Double o double
BigInteger
BigDecimal
Boolean o boolean
java.util.Date
java.sql.Date
java.sql.Time
java.sql.Timestamp
java.time.LocalDate
java.time.LocalTime
java.time.LocalDateTime

Como podemos ver, también es posible usar tipos de datos primitivos.

@DateTextView es conveniente usarlo para sincronizar el JTextFiel con tipos de datos que heredan de la clase java.util.Date y java.time.temporal.Temporal, ya que esta anotación nos permite definir un atributo pattern en caso que queramos personalizar el formato de fecha, y un locale mediante la clase LocaleEnum de la misma librería SwingUtils.

@NumberTextView es conveniente usarlo para sincronizar el JTextField con tipos de datos que heredan de la clase java.lang.Number, ya que esta anotación nos permite definir un atributo pattern en caso que queramos personalizar el formato de número, y un locale mediante la clase LocaleEnum de la misma librería SwingUtils.

En cada una de estas tres anotaciones es posible usar también los atributos required y requiredMessage. El primero, es una propiedad booleana mediante la cual podemos indicar si queremos que el valor a ingresar sea obligatorio o no; y el segundo, es un mensaje personalizado que se mostrará al usuario en formato de error, en caso de que la propiedad required sea true y no se haya ingresado ningún valor en el campo de texto.

Veamos cómo podemos usar estas anotaciones:

@TextView(name = "miModelo1.textoModelo", required = true, requiredMessage = "Debe ingresar un valor")
private javax.swing.JTextField jTextField1;

@DateTextView(name = "miModelo1.fechaModelo", pattern = "dd-MM-yyyy", locale = LocaleEnum.UK, required = true requiredMessage = "Debe ingresar un valor")

private javax.swing.JTextField jTextField2;

@NumberTextView(name = "miModelo1.numeroModelo", pattern = "#,###", locale = LocaleEnum.US, required = true, requiredMessage = "Debe ingresar un valor")

private javax.swing.JTextField jTextField3;

En éste código sólo hemos tomado el objeto miModelo1 de la clase MiControlador para simplificar un poco el ejemplo, pero si quisiéramos usar las otras propiedades lo haríamos así:

@TextView(name = "texto1")
private javax.swing.JTextField jTFtexto1;

@TextView(name = "miTexto")
private javax.swing.JTextField jTFtexto2;

@TextView(name = "pruebaModelo.textoModelo")
private javax.swing.JTextField jTFtexto3;

Veamos ahora cómo deberíamos definir entonces el controlador en nuestra vista y cómo deberíamos inyectarle la dependencia de ésta (la vista) para poder sincronizarlos:

public class MiVista extends javax.swing.JFrame {

    private final MiControlador miControlador;
    
    public MiVista() {
        initComponents();
        
        this.miControlador = new MiControlador(this);
    }
    
}

Cabe aclarar que no es obligatorio que nuestras vistas extiendan de javax.swing.Frame u otro componente de java swing. En este caso yo lo tengo así, ya que el editor de interfaces de NetBeans es quien me crea la clase así.

Con esto es más que suficiente en cuanto a declarar nuestras variables se trata. Ahora vamos a crear dos funcionalidades sencillas mediante dos botones las cuales serán Guardar y Limpiar. La primera nos mostrará por consola los datos ingresados en el formulario, y la segunda deja vacíos los campos del formulario.

La idea de trabajar con un patrón MVC es que los cambios que hagamos en la Vista se vean reflejados en el Modelo a través del Controlador, y del mismo modo, que cuando tengamos cambios en el Modelo y se quieran mostrar al usuario, éstos se vean reflejados en la Vista también a través del Controlador.

En este ejemplo, crearemos los 3 siguientes métodos en el Controlador:

// Método para guardar los datos
public void guardar() {
    super.changeData(TipoUpdateEnum.MODEL);
    printConsole();
}

// Método para limpiar el formulario
public void limpiar() {
    miModelo1 = new MiModelo();
    super.changeData(TipoUpdateEnum.VIEW);
}

// Método para imprimir los datos por consola
public void printConsole() {
    System.out.println("Texto Modelo 1: " + miModelo1.getTextoModelo());
    System.out.println("Fecha Modelo 1: " + miModelo2.getFechaModelo());
    System.out.println("Numero Modelo 1: " + miModelo2.getNumeroModelo());
}

En éste código cabe destacar las líneas 3 y 10. En el método guardar(), lo primero que hacemos es indicar que tenemos datos en la vista que deben ser actualizados en el modelo de datos, por lo tanto, con la sentencia super.changeData(TipoUpdateEnum.MODEL) estamos sincronizando todos los datos de la Vista con el o los modelos de datos o atributos independientes que tengamos en nuestro Controlador, de tal manera que al llamar el método printConsole() se mostrará todo lo que haya escrito en el formulario.

En el método limpiar(), como lo que queremos hacer es vaciar los campos del formulario, lo primero que deberíamos hacer es limpiar dichos valores en nuestro modelo de datos, y como en este caso sólo estamos tomando el objeto miModelo1, lo único que deberíamos de hacer es re-inicializar dicho objeto. De esta forma, a continuación con la sentencia super.changeData(TipoUpdateEnum.VIEW) sincronizamos todos los datos del o los modelos de datos o atributos independientes que tengamos en nuestro Controlador con la Vista, y en este caso lo que haría es mostrar vacíos los campos de texto, ya que nuestro modelo de datos no tiene valores.

Podemos ver que con TipoUpdateEnum.MODEL indicamos que queremos actualizar el modelo de datos, y con TipoUpdateEnum.VIEW indicamos que queremos actualizar la vista con los datos que están en el modelo de datos.

¿Y en caso de que no queramos actualizar todo el modelo de datos?

Como vimos, a través de la sentencia super.changeData(), es que se logra la actualización inmediata de datos entre la Vista y el Modelo de datos, y para este ejemplo se hacía una actualización a nivel de todos los modelos de datos y/o atributos independientes que tengamos declarados en nuestro Controlador.

Sin embargo, pueden haber casos en los que sólo deseamos actualizar, un modelo con todos sus atributos (en caso de que tengamos declarados varios modelos), un sólo atributo que tengamos declarado con la anotación @PropertyController, un sólo atributo de alguno de nuestros modelos, o incluso una pequeña lista de datos que queramos actualizar en el Modelo o en la Vista.

Para esto, el método super.changeData() está preparado para recibir dos tipos de objetos. Uno es de tipo enum TipoUpdateEnum el cual ya vimos como usarlo; y el otro es de tipo ObjectUpdate, el cual tiene tres constructores con los cuales puede ser instanciado:

new ObjectUpdate(TipoUpdateEnum tipoUpdateEnum)

new ObjectUpdate(TipoUpdateEnum tipoUpdateEnum, String component)

new ObjectUpdate(TipoUpdateEnum tipoUpdateEnum, List<string> listComponents)

El primer constructor funciona de la misma forma que si pasáramos sólo el enum al método changeData(). El segundo constructor, nos pide el enum con el tipo de actualización y adicionalmente el componente a actualizar; y el tercer constructor nos pide el enum con el tipo de actualización y una lista de componentes que deseemos actualizar.

Veamos distintos ejemplos de como podemos usar estas instancias usando los atributos que declaramos al principio de este artículo. En los siguientes ejemplos, actualizaremos los datos en el modelo de datos, pero si lo que deseamos es actualizar los valores que se muestra en la vista, lo haríamos de la misma forma pero usando TipoUpdaeEnum.VIEW:

// Indicamos que sólo queremos que se actualice el modelo miModelo2.
// Al ser declarado con la anotación @ModelBean y con un nombre
// personalizado (pruebaModelo), SwingUtils reconoce que éste es
// un modelo de datos y debe actualizar todos los atributos que
// tenga éste objeto
super.changeData(new ObjectUpdate(TipoUpdateEnum.MODEL, "pruebaModelo"));


// Indicamos que sólo queremos que se actualice el atributo numeroModelo
// del objeto miModelo1. Al ser declarado con la anotación @ModelBean,
// SwingUtils reconoce que éste es un modelo de datos y actualizará sólo
// el atributo de este objeto que le indiquemos
super.changeData(new ObjectUpdate(TipoUpdateEnum.MODEL, "miModelo1.numeroModelo"));


// Indicamos que sólo quieremos que se actualice el atributo texto2.
// Al estar declarado con la anotación @PropertyController y con un
// nombre personalizado (miTexto), SwingUtils reconoce que éste es
// un atributo independiente en el controlador y sólo debe actualizar
// dicho atributo
super.changeData(new ObjectUpdate(TipoUpdateEnum.MODEL, "miTexto"));


// En caso que queramos pasar una lista de componentes, pasamos un List
// de tipo String con los nombres de los componentes que deseemos
// actualizar de la misma forma como lo vimos en los casos anteriores
super.changeData(new ObjectUpdate(TipoUpdateEnum.MODEL, Arrays.asList("texto1", "pruebaModelo", "miModelo1.fechaModelo"));

Con éstos ejemplos, damos por concluido éste artículo en donde hemos visto como podemos sincronizar fácilmente datos de un JTextField con el Controlador usando la librería SwingUtils para que la información de nuestra vista se actualice rápidamente en el modelo de datos y viceversa.

SwingUtils - Librería de Utilidades para Java Swing

2017-09-13T17:09:00.000-05:00

Existen muchas librerías de utilidades disponibles para trabajar con Java Swing que hacen una u otra cosa y que facilitan el trabajo ya sea a nivel de vista, de modelo o de controlador. Sin embargo, siempre hay algo que requerimos pero que las librerías que encontramos no cumplen con esas necesidades.

Por eso decidí crear SwingUtils, una librería con una serie de utilidades que suelo usar en muchos proyectos que he desarrollado usando Java Swing.

¿En qué consiste SwingUtils?

Como ya lo mencioné, la librería SwingUtils posee una serie de utilidades que pueden facilitar el desarrollo de ciertos componentes cuando trabajamos con el API de Java Swing, sin embargo, una de las principales características y que fue la que me motivó a desarrollar esta librería es la siguiente:

Cuando trabajas con Java Enterprise Edition y el framework de JavaServer Faces, notas lo fácil que es la sincronización de datos entre una vista y el controlador, ya que los value en la vista tan sólo deben ser declarados usando EL (Expression Language) de la forma #{claseControlador.atributo} donde atributo puede ser un objeto del API de Java o un objeto de una clase creada por nosotros y a través del cual podemos acceder a sus atributos de la forma #{claseControlador.miObjeto.atributo}; y por otro lado, el controlador es un bean el cual lo único que debe tener es una inyección de dependencias usando la anotación @Named.

En otro artículo entraré más a fondo sobre todo este mundo de Java Enterprise Edition, por ahora sólo me interesa que se aprecie lo fácil que se hace la sincronización de datos entre la vista y el controlador cuando hacemos uso de JEE; sin embargo, cuando trabajamos con Java Standard Edition y el API de Java Swing para desarrollar vistas, vemos que el trabajo se hace un poco más tedioso.

Si has trabajado con Java Swing, sabrás que si quieres obtener los datos de 8 campos de texto por ejemplo, tendrás que hacerlo uno a uno de la siguiente forma:

String dato1 = vista.jTFdato1.getText();
String dato2 = vista.jTFdato2.getText();
...
String dato8 = vista.jTFdato8.getText();

Y en caso de que quieras mostrar valores en dichos campos de texto, igualmente debes hacerlo uno a uno de la siguiente forma:

vista.jTFdato1.setText("Texto 1...");
vista.jTFdato2.setText("Texto 2...");
...
vista.jTFdato8.setText("Texto 8...");

Como verás, es algo que se vuelve un poco tedioso, sobre todo cuando nuestras vistas tienen formularios un poco grandes.

Me di a la tarea de buscar primero si el API de Java Swing tenía una forma de simplificar este trabajo tal como lo hace JavaServer Faces, sin embargo no la encontré; busqué en algunas librerías, y sólo encontré JDAL, la cual tiene cosas muy interesantes, sin embargo no me convencía del todo ya que debía hacer grandes cambios en vistas que ya estuvieran desarrolladas.

Así que pensé en crear anotaciones mediante las cuales podría controlar los cambios tanto desde la vista como desde el controlador, y hacer uso del patrón Observer para notificar dichos cambios tanto a la vista como al controlador.

Entendiendo Cómo Funciona SwingUtils

Actualmente, SwingUtils posee dos packages principales: core y utils. En el package core, tenemos todas las utilidades relacionadas directamente con el uso de de Java Swing; En el package utils, tenemos clases de utilería general.

- Package com.eljavatar.swingutils.core

Como mencioné, en este package están contenidas las clases de utilería que están relacionadas con el uso de Java Swing, y a su vez, éste contiente los siguientes packages: annotations, beansupdate, components, componentsutils, modelcomponents y renderercomponents.

- Package com.eljavatar.swingutils.core.annotations

Este package contiene las anotaciones que deben ser usadas en la vista o en el controlador para permitir la gestión de actualizaciones en cualquiera de los dos.

Anotaciones para usar en la vista:
- ComboBoxView
- ComponentView
- DateTextView
- NumberTextView
- PaginatedTableView
- TableView
- TextView
- ToggleButtonView

Anotaciones para usar en el controlador:
- ModelBean
- PropertyController

- Package com.eljavatar.swingutils.core.beansupdate

Este package contiene las clases que implementan la lógica para notificar los cambios a la vista y al controlador.

- AbstractObservable
- AbstractObserverController (ésta es la clase que debe ser extendida desde el controlador)
- ObjectUpdate
- TipoUpdateEnum

- Package com.eljavatar.swingutils.core.components

Este package contiene algunos componentes gráficos de utilería que extienden de componentes del API de Java Swing. En el momento sólo existen dos componentes:

- JPanelImage
- PaginatedTable

- Package com.eljavatar.swingutils.core.componentsutils

Este package contiene clases de utilería para trabajar con los distintos componentes de Java Swing; actualmente sólo hay unos pocos, que son los que más frecuentemente uso, pero la idea es ampliar la lista ;)

- JComboBoxUtils
- JTableUtils
- NotifyUtils
- SwingComponentsUtils

- Package com.eljavatar.swingutils.core.modelcomponents

Este package contiene clases para manejar el modelo de datos que usen los distintos componentes de Java Swing o los implementados en SwingUtils.

- ComboBoxModelGeneric
- JTableDataProvider
- LazyDataProvider
- ObjectFiler
- PaginationDataProvider
- TableModelGeneric

- Package com.eljavatar.swingutils.core.renderercomponents

Este package contiene clases para manejar el renderer que usen los distintos componentes de Java Swing.

- ComboBoxRendererDefault
- TitlesTableRendererDefault

- Package com.eljavatar.swingutils.utils

Como ya dije antes, este package contiene clases de utilería pero que no están necesariamente relacionadas con el uso de Java Swing. En el momento, este paquete contiene las siguientes clases:

- StringUtils
- LocaleEnum

Aquí sólo me limitaré a mencionar las clases que posee la librería, ya que posteriormente le realizaré un artículo a cada una de las características de la misma.

Cómo descargar SwingUtils

Para descargar la librería sólo se debe agregar la siguiente dependencia Maven:

<dependency>
    <groupId>com.eljavatar</groupId>
    <artifactId>SwingUtils</artifactId>
    <version>1.3.2</version>
</dependency>

En caso de no tener un proyecto gestionado con maven, puede descargar la librería directamente desde su enlace en el repositorio maven e importarla al proyecto que se desee:

==> Proyecto SwingUtils v1.3.2

¿Cómo se Clasifican los Patrones de Diseño?

2017-01-30T15:40:00.000-05:00

Para clasificar los patrones de diseño, nos basaremos en la organización que se presenta en el libro "GoF", el cual los clasifica según su objetivo; así tenemos entonces los patrones de construcción, patrones de estructuración y patrones de comportamiento.

Los patrones de construcción tienen como objetivo organizar la creación de objetos. Estos patrones son: Abstract Factory, Builder, Factory Method, Prototype y Singleton.

Los patrones de estructuración facilitan la organización de la jerarquía de clases y de sus relaciones. Estos patrones son: Adapter, Bridge, Composite, Decorator, Facade, Flyweight y Proxy.

Por último, los patrones de comportamiento son los que proporcionan soluciones para organizar las interacciones y para repartir el procesamiento entre los objetos. Estos patrones son Chain of responsability, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method y Visitor.

¿Cómo escoger y utilizar un patrón de diseño para resolver un problema?

Para saber si existe un patrón de diseño que responde a un problema concreto, el primer paso consiste en ver las descripciones de cada uno de los patrones anteriores, las cuales pueden verse en el artículo "Una Mirada General a los Patrones de Diseño", y determinar si existe uno o varios patrones cuya descripción se acerque a la del problema.

Es importante estudiar a fondo la estructura genérica de los patrones de diseño y entender el objetivo que persigue el problema planteado, lo cual nos servirá como base para utilizar un patrón.

Programación Orientada a Objetos en C++ | Clases y Objetos

2016-11-23T15:12:00.002-05:00

Clases

La base de la Programación Orientada a Objetos es la abstracción de los datos o los Tipos de Datos Abstractos, y dicha abstracción de los datos es posible gracias a las clases y a los objetos.

Podemos decir entonces que una clase es aquella que nos proporciona una estructura de datos con sus respectivas operaciones. Los datos son conocidos como atributos y las operaciones se conocen como métodos. Podemos concluir entonces que una clase es el molde que nos sirve para la creación de un objeto.

Así pues, la unión entre los atributos y los métodos es la que define el comportamiento de un objeto o grupo de objetos según sea el caso.

Algunos ejemplos de clases pueden ser: Auto, Empresa, Libro, Persona, etc.

Objetos e Instancias

La instanciación es una de las principales características de los lenguajes de programación orientados a objetos. Recordemos que la instanciación es la capacidad que tienen los nuevos tipos de datos, en este caso, las clases, de ser "instanciadas" en cualquier momento.

El instanciar una clase produce un objeto o instancia de la clase que asigna un determinado espacio en la memoria para ser gestionada o destruida posteriormente según sea el caso.

Un objeto es por tanto y a grandes rasgos, una instancia de una clase. Todo objeto puede ser identificado en forma única a través de su nombre; además, define un estado el cuál es definido por los valores de sus atributos en un momento dado.

El estado de un objeto cambia de acuerdo a los métodos que le son aplicados. A esta posible secuencia de cambios de estado es la que conocemos como el comportamiento del objeto.

Instanciación: Los objetos pueden ser creados de dos formas al igual que una estructura de datos: Estáticamente y Dinámicamente.

1) Estáticamente: En tiempo de compilación se le asigna un área de memoria al objeto.

2) Dinámicamente: En tiempo de ejecución se le asigna un área de memoria al objeto y su existencia es temporal. Es necesario liberar el espacio usado por el objeto en memoria cuando éste ya no es útil. En algunos lenguajes como Java, el lenguaje nos proporciona mecanismos de recolección de basura y por tanto no debemos preocuparnos por liberar el espacio de memoria usada por los objetos, sin embargo en C++ sí debemos hacerlo explícitamente.

Clases en C++

La definición de una clase define nuevos Tipos de Datos Abstractos. La definición en C++ se realiza mediante la palabra reservada class, seguida del nombre de la clase y finalmente el cuerpo de la clase encerrado entre llaves {} y finalizando con un punto y coma (;).

El cuerpo de la clase contiene la declaración de los atributos (variables) y la declaración de los métodos (funciones). Tanto los atributos como los métodos pertenecen exclusivamente a la clase y sólo pueden ser usados a través de un objeto de dicha clase.

Sintaxis:

class <nombre_clase> {
    <cuerpo de la clase>
};  // Finaliza declaración de la clase

Ejemplo:

class Triangulo {
    int base;
    int altura;
    int area;

    void calcularArea() {
        area = (base * altura) / 2;
    }
};

Miembros de una clase

Una clase está formada por un conjunto de miembros que pueden ser datos, funciones, clases anidadas, enumeraciones, tipos de dato, etc. Primeramente nos enfocaremos en los datos y las funciones (atributos y métodos).

Hay que tener en cuenta que un miembro no puede ser declarado más de una vez. Tampoco es posible añadir miembros después de la declaración de la clase, es decir, después de la llave y el punto y coma (};).

Ejemplo:

class ClaseEjemplo {
    int a;
    int b;
    int a;    // error
    int metodo(int, int);
};

Atributos miembro: Todos los atributos que forman parte de una clase deben ser declarados dentro de la misma.

Métodos miembro: Al igual que los atributos, los métodos deben ser definidos dentro de la declaración de la clase; sin embargo, el cuerpo de la función puede ir dentro o fuera de la clase. Si un método se declara completo dentro de la clase, éste se considera como inline.

La declaración dentro de la clase no cambia con respecto a la declaración de una función, salvo que se hace dentro de la clase. Retomemos la clase del ejemplo inicial, pero ahora la modificaremos agregando un método con el cuerpo del mismo fuera del cuerpo de la clase:

Ejemplo:

class Triangulo {
    public:
        int base;
        int altura;
        int area;
        void calcularArea() {
            area = (base * altura) / 2;
        }
        int obtenerPerimetro(int, int, int);
};

Podemos apreciar que en la definición de la clase se incluye un método en línea o inline (calcularArea) y un prototipo de otro método (obtenerPerimetro).

Para definir un método miembro de una clase fuera de la misma, se debe escribir antes del nombre del método la clase con la que el método está asociado. Para esto, se hace uso del operador de resolución de alcance ::

Continuación del ejemplo:

int Triangulo::obtenerPerimetro(int lado1, int lado2, int lado3) {
    int perimetro = lado1 + lado2 + lado3;
    return perimetro;
}

Es importante tener muy en cuenta que al declarar los métodos fuera de la clase, No es posible mencionar la declaración de un método que no esté contemplado dentro de la clase, ya que si esto fuera posible, cualquiera podría tener acceso a la clase con sólo declarar un método adicional.

Ejemplo:

// Error en la declaración de un método
class MiClase {
    public:
        int a;
        void m();
};

// Esto es un error, ya que el método algo() no ha sido declarado
// dentro de la clase MiClase
int MiClase::algo() {
    return 0;
}

La declaración de un método miembro es considerada dentro del ámbito de su clase, lo cual significa que puede usar nombres de miembros de la clase directamente sin usar el operador de acceso de miembro de la clase.

Recordemos que por convención, en la programación orientada a objetos, las funciones son llamadas métodos, y la invocación o llamada a dichos métodos es conocida como mensaje.

Acceso a miembros

Una de las características de la Programación Orientada a Objetos es la posibilidad de encapsular datos, ocultándolos de otros objetos si es necesario. En C++, existen tres tipos de calificadores que definen a los datos y métodos como públicos, privados o protegidos, aunque por el momento sólo nos enfocaremos en los miembros públicos y privados.

Miembros públicos: Se utiliza cuando queremos dar a usuarios o clientes de una clase el acceso a miembros de esa clase. Los miembros deben ser declarados públicos a través de la palabra reservada public: La sintaxis es la siguiente:

Sintaxis:

public:
    <definición de miembros>

Miembros privados: Se utiliza cuando queremos ocultar ciertos miembros de una clase de los usuarios o clientes de la misma. De esta manera, nadie más que los miembros de la misma clase pueden usar a los miembros privados. Por omisión, los miembros se consideran privados. Sin embargo, en una estructura de datos se consideran públicos por omisión. Los miembros deben ser declarados públicos a través de la palabra reservada private: La sintaxis es la siguiente:

Sintaxis:

private:
    <definición de miembros>

Normalmente, y por buenas prácticas de programación orientada a objetos, se trata de que los atributos de la clase sean privados, y el acceso a dichos atributos se realiza mediante métodos públicos conocidos como Getters y Setters.

Así mismo, los métodos que no sean necesarios externamente, o que puedan conducir a un estado inconsistente del objeto, también deberían declararse como privados.

Ejemplo:

class Fecha {
    private:
        int dia;
        int mes;
        int anio;

    public:
        void setDia(int);    // Asigna día
        int getDia();    // Obtiene día
        void setMes(int);
        int getMes();
        void setAnio(int);
        int getAnio();
};

Objetos de clase

Ya hemos visto como se define una clase, la forma de declarar sus atributos y sus métodos, los cuales hemos aprendido que pueden ir dentro de la definición de la clase (inline) o fuera de ella. Ahora veremos cómo es posible crear objetos o instancias de esa clase.

Recordemos que una de las características de los objetos es que cada uno guarda un estado particular de acuerdo al valor de sus atributos. La importancia de los lenguajes Orientados a Objetos es precisamente el objeto, el cual no es más que una identidad lógica que contiene datos y código que manipula dichos datos.

En C++, un objeto es una variable de un tipo definido por el usuario. Veamos ahora un ejemplo completo:

#include <iostream>
#include <string>

using namespace std;

class MiClase {
    public:
        string a;
        string b;
};

int main() {
    MiClase c1;
    MiClase c2;
    
    c1.a = "Hola";
    c1.b = "Mundo";
    
    c2.a = "Hello";
    c2.b = "World";
    
    cout << c1.a << " " << c1.b << endl;
    cout << c2.a << " " << c2.b << endl;
    
    return 0;
}

Veamos ahora el mismo ejemplo, pero instanciando objetos de la clase y usando métodos mediante los cuales accedemos a los atributos de la misma:

#include <iostream>
#include <string>

using namespace std;

class MiClase {
    private:
        string a;
        string b;

    public:
        string getA();
        void setA(string);
        string getB();
        void setB(string);
        string concatenar();
};

string MiClase::concatenar() {
    return this->a + " " + this->b;
}

string MiClase::getA() {
    return this->a;
}

void MiClase::setA(string a) {
    this->a = a;
}

string MiClase::getB() {
    return this->b;
}

void MiClase::setB(string b) {
    this->b = b;
}

// Método main
int main() {
    MiClase *c1 = new MiClase;
    MiClase *c2 = new MiClase;
    
    c1->setA("Hola");
    c1->setB("Mundo");
    
    c2->setA("Hello");
    c2->setB("World");
    
    cout << c1->concatenar() << endl;
    cout << c2->concatenar() << endl;
    
    delete c1;
    delete c2;
    
    return 0;
}

NOTA: Es recomendable manejar la declaración de las clases mediante archivos .h y la implementación de los métodos de la misma mediante archivos .cpp; de esta forma, en el proyecto se puede incluir el correspondiente objeto importando solamente el archivo .h y sin proporcionar el código de su implementación.

La forma de hacerlo sería la siguiente:

#ifndef MICLASE_H
#define MICLASE_H

<definición de la clase>

#endif

Alcance de Clase

El nombre de un miembro de una clase es local a la clase y las funciones no miembros se definen en un alcance de archivo.

Dentro de la clase, los miembros pueden ser accedidos directamente por todos los métodos miembros. Fuera del alcance de la clase, los miembros de la clase se pueden utilizar seguidos del operador de selección de miembro de punto (.) ó del operador de selección de miembro de flecha (->), posterior al nombre de un objeto de la clase.

Ejemplo:

class ClaseEjemplo {
    public:
        void metodoPrueba();
}

void main() {
    ClaseEjemplo ce1;
    ce1.metodoPrueba();

    ClaseEjemplo *ce2 = new ClaseEjemplo;
    ce2->metodoPrueba();
}

Cuando usamos el operador de desreferencia u operador de indirección (*) en un objeto, debemos acceder a los campos o métodos de dicha clase usando el operador de flecha (->), o bien podemos hacerlo mediante el operador punto (.) siempre y cuando desreferenciemos dicho puntero.

Ejemplo:

#include <iostream>

using namespace std;

class MiClase {
    public:
        int a;
};

int main() {
    MiClase obj;

    (&obj)->a = 1;   // Referenciamos el objeto
    cout << (&obj)->a << endl;

    MiClase *obj2 = new MiClase;
    
    (*obj2).a = 2;   // Desreferenciamos el objeto
    cout << (*obj2).a << endl;
    
    return 0;
}

Sobrecarga de operaciones

En C++, al igual que otros lenguajes de programación Orientados a Objetos como Java, es posible tener el mismo nombre para un método, con la condición de que su firma sea distinta, es decir, que tenga parámetros diferentes. La diferencia debe ser al menos en el tipo de datos de loas parámetros que recibe el método.

Un método está sobrecargado cuando se tienen dos o más métodos con el mismo nombre, pero diferentes parámetros.

El compilador de C++ sabe qué operación debe ejecutar a través de la firma del método, la cual es la combinación entre el nombre del método y el número y tipo de los parámetros que recibe. Del mismo modo, el tipo de retorno del método puede ser igual o diferente.

La sobrecarga de operaciones de gran importancia, ya que es muy útil para escribir código más legible y modular. La idea de este concepto es utilizar el mismo nombre para operaciones relacionadas; de esta forma, si no tienen nada que ver, entonces es mejor utilizar un nombre distinto.

Ejemplo

class MiClase {
    int num;
    
    public:
        void cambiaValor() {
            num++;
        }
        
        void cambiaValor(int x) {
            num = num + x;
        }
};

En C++ también es posible usar la sobrecarga de operaciones por fuera de las clases:

Ejemplo

#include <iostream>

int multipliacion(int x) {
    return x * x;
}

double multiplicacion(double y) {
    return y * y;
}

int main() {
  std::cout << "4 multiplicado por 4 = " << multiplicacion(4) << std::endl;
  std::cout << "6.8 multiplicado por 6.8 = " << multiplicacion(6.8) << std::endl;
  
  return 0;
}

Constructores y destructores

Cunado trabajamos con datos primitivos en C++, el compilador se encarga directamente de reservar la memoria, y así mismo de liberarla cuando estos datos salen de su ámbito.

En la programación orientada a objetos, se trata de proporcionar mecanismos similares. En C++, cuando se crea un objeto, se llama a un método conocido como Constructor, y al salir, se llama a otro conocido como Destructor. Si no se proporcionan dichos métodos, se asume la acción más simple.

Constructor

Un constructor no es más que un método que posee el mismo nombre de la clase. Este método no puede tener un tipo de dato de retorno, sin embargo, al igual que los métodos, si permite la sobrecarga.

Ejemplo

class EjemploConstructor {
    private:
        string saludo;
    
    public:
        EjemploConstructor();
        void setSaludo(string);
        string getSaludo();
};

// Implementación del constructor
EjemploConstructor::EjemploConstructor() {
    this->saludo = "Hola Mundo";
    cout << "Se ha inicializado la clase" < endl;
}

Hay que tener en cuenta que un constructor si puede ser llamado desde un método de la clase.

Destructor

La contraparte del constructor es el destructor. Este es ejecutado momentos antes de que el objeto sea destruido, ya sea porque salen de su ámbito o por medio de la palabra reservada delete. El uso más común para un destructor es liberar la memoria asignada dinámicamente, aunque puede ser también utilizado para otras tareas de finalización, como cerrar archivos, una conexión de red, etc.

El destructor, al igual que el destructor, tiene el nombre de la clase pero con una tilde de negativo como prefijo (~).

Al igual que el constructor, el destructor tampoco regresa valores, sin embargo, éste último tampoco tiene parámetros.

Ejemplo

class EjemploClase {
    private:
        string saludo;
    
    public:
        EjemploClase();   // Constructor
        ~EjemploClase();  // Destructor
        void setSaludo(string);
        string getSaludo();
};

// Implementación del constructor
EjemploClase::~EjemploClase() {
    cout << "Clase destruida" << endl;
}

Miembros estáticos

En la Programación Orientada a Objetos, cada objeto tiene su propio estado, sin embargo, en muchas ocasiones es pertinente tener atributos por clase que conserven su valor a nivel de aplicación, y no por objeto mediante los cuales se obtiene su valor a nivel de instancia. En esos es necesario tener atributos estáticos, los cuales pueden ser compartidos por todos los objetos de la clase.

De este modo, sólo existe una copia de un miembro estático, y dicho miembro no forma parte de los objetos de la clase.

Ejemplo:

class EjemploStatic {
    private:
        string nombre;
        static int cantidadObjetos;
    
    public:
        EjemploStatic(string texto);
        ~EjemploStatic();
};


EjemploStatic::EjemploStatic(string texto) {
    nombre = texto;
    cantidadObjetos++;
}

EjemploStatic::~EjemploStatic() {
    cantidadObjetos--;
}

Un miembro estático, ya sea un atributo o un método, puede ser accedido desde cualquier objeto de la clase, o mediante el operador de resolución de alcance binario (::) y el nombre de la clase, debido a que un miembro estático existe a nivel de aplicación aunque no haya instancias de la clase.

Sin embargo, hay que tener en cuenta que el acceso a un miembro estático se restringe a las reglas de acceso a miembros que ya hemos visto anteriormente:

- Si se quiere acceder a un miembro estático que es privado, se debe hacer a través de un miembro público.

- Si no existe ninguna instancia de la clase, el acceso al miembro debe hacerse entonces a través de un método público estático.

Por otro lado, hay que tener en cuenta que un método estático SÓLO puede tener acceso a miembros estáticos. Además, los atributos estáticos se deben inicializar al igual que lo hacemos con los atributos constantes, fuera de la declaración de la clase. Por ejemplo:

int Clase::atributoEstatico = 0;
int const Clase::atributoConstante = 30;

Veamos ahora un ejemplo un poco más completo:

#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

class EjemploStatic {
    private:
        static int cantidadObjetos;
        static const int CANTIDAD_MAXIMA;
        char *nombre;
    
    public:
        EjemploStatic(char *texto = NULL);
        ~EjemploStatic();
        static int getCantidadMaxima() {
            return CANTIDAD_MAXIMA;
        };
        static int getCantidadObjetos() {
            return cantidadObjetos;
        };
};

// Inicializamos atributos estáticos
int EjemploStatic::cantidadObjetos = 0;
const int EjemploStatic::CANTIDAD_MAXIMA = 10;

EjemploStatic::EjemploStatic(char *texto) {
    if (texto != NULL) {
        this->nombre = new char[strlen(texto) + 1];
        strcpy(this->nombre, texto);
    } else {
        this->nombre = "NULL";
    }
    cout << "Nombre: " << this->nombre << endl;
    cantidadObjetos++;
}

EjemploStatic::~EjemploStatic() {
    cout << "Eliminando nombre: " << this->nombre << endl;
    if (this->nombre) {
        delete []nombre;
    }
    cantidadObjetos--;
}


// Método main
int main() {
    cout << "Cantidad Maxima de Objetos: " << EjemploStatic::getCantidadMaxima() << endl;
    cout << "Cantidad de Objetos: " << EjemploStatic::getCantidadObjetos() << endl;
    
    EjemploStatic obj1;
    cout << "Cantidad Maxima de Objetos: " << EjemploStatic::getCantidadMaxima() << endl;
    cout << "Cantidad de Objetos: " << EjemploStatic::getCantidadObjetos() << endl;
    
    EjemploStatic obj2("nombre 1");
    cout << "Cantidad Maxima de Objetos: " << EjemploStatic::getCantidadMaxima() << endl;
    cout << "Cantidad de Objetos: " << EjemploStatic::getCantidadObjetos() << endl;
    
    return 0;
}

Objetos constantes

En C++ es posible crear objetos de tipo constante, los cuales no van a poder ser modificados en ningún momento durante la ejecución de una aplicación, lo cual ayuda a cumplir el principio del mínimo privilegio, donde se debe restringir al máximo el acceso a los datos cuando este acceso estaría de sobra.

Si tratamos de modificar un objeto constante, obtendremos un error en tiempo de compilación.

Sintaxis:

const <clase> <lista de objetos>

const cHora h1(9, 30, 20);

Para estos objetos, existen compiladores lo bastante rígidos en el cumplimiento de esta instrucción, que no nos permiten hacer llamadas a métodos sobre estos objetos. Por ejemplo, en el caso de C++ de Borland, el compilador tan sólo manda una advertencia y permite que se ejecute la aplicación, pero advierte que debe ser considerado como un error.

Sin embargo, es posible que queramos consultar el estado del objeto a través de llamadas a métodos get, y para esto lo correcto es declarar métodos con la palabra reservada const, pues de esta forma podemos actuar libremente sobre el objeto sin modificarlo.

La sintaxis consiste en añadir después de la lista de parámetros la palabra reservada const en la declaración y en su definición.

Sintaxis

Declaración:

<tipo> <nombre> (<parámetros>) const;

Definición del método fuera de la declaración de la clase:

<tipo> <clase> :: <nombres> (<parámetros>) const {
    <código>
}

Definición del método dentro de la declaración de la clase:

<tipo> <nombres> (<parámetros>) const {
    <código>
}

El compilador de Borland permite usar los métodos constantes de manera indiferente para objetos constantes y no constantes, siempre y cuando no modifiquen al objeto; sin embargo hay compiladores que incluso restringen el uso de métodos constantes a objetos constantes. Para solucionar esto, es posible sobrecargar el método con la única diferencia de la palabra const, aunque el resto de la firma del método sea la misma.

Los constructores no necesitan la declaración const, puesto que deben poder modificar al objeto. Veamos ahora un ejemplo completo:

Ejemplo:

#include <iostream>
#include <stdlib.h>

using namespace std;

class ObjetoConstante {
    private:
        int a[10];
    public:
        ObjetoConstante(int x = 0) {
            for (int i = 0; i < 10; i++) {
                if (x == 0) {
                    x = random();
                }
                a[i] = x;
            }
        }
        char set(int, int);
        int get(int) const;
        int get(int);
};

// Implementación de los métodos
char ObjetoConstante::set(int pos, int val) {
    if (pos >= 0 && pos < 10) {
        a[pos] = val;
        return 1;
    }
    return 0;
}

int ObjetoConstante::get(int pos) const {
    if (pos >= 0 && pos < 10) {
        return a[pos];
    }
}

int ObjetoConstante::get(int pos) { // En este caso no es necesario sobrecargar
    if (pos >= 0 && pos < 10) {
        return a[pos];
    }
}

// Método main
int main () {
    const ObjetoConstante a(5), b;
    ObjetoConstante c;
    
    //a.set(0, 1);    // Esto nos genera un error de compilación porque llamamos a un
    //b.set(0, 2);    // método que modifica un objeto que ha sido declarado constante
    c.set(0, 3);
    //a.set(1, 11);
    //b.set(1, 22);
    c.set(1, 33);
    
    cout << a.get(0) << endl;
    cout << a.get(1) << endl;
    cout << b.get(0) << endl;
    cout << b.get(1) << endl;
    cout << c.get(0) << endl;
    cout << c.get(1) << endl;
}

Introducción a la Programación Orientada a Objetos en C++

2016-11-15T14:08:00.002-05:00

Hace unos días estuve colaborándole a un amigo en la elaboración de una aplicación que debía realizar usando Programación Orientada a Objetos en C++. La mayoría de aplicaciones que he desarrollado, las hecho en Java, y ya que Java es un lenguaje que ha sido influido por C++, pensé que no habría mucha diferencia entre el uno y el otro, y vaya sorpresa que me di ;)

La verdad es que en muchos aspectos se me presentaron bastantes inconvenientes. Recordemos que C++ es un lenguaje que extiende del lenguaje de programación C mecanismos que nos permiten la manipulación de objetos, es decir, que no es un lenguaje meramente orientado a objetos como Java o C#, sino que es más bien un lenguaje híbrido.

Cabe aclarar que estos tutoriales no son básicos, es decir que ya debes de tener algún conocimiento en el lenguaje de programación C++, como sus tipos de datos, declaración de variables, operaciones, ciclos, importación de librerías, uso de namespaces, en fin.

Después de esta breve introducción y antes de adentrarnos en los detalles específicos de la programación orientada a objetos en C++, demos un pequeño repaso a lo que es la POO y sus características.

En el siguiente enlace puedes ver un artículo sobre las características del Paradigma de Programación Orientado a Objetos. Sin embargo, mencionaremos a continuación algunas de ellas y aspectos principales a tener en cuenta:

Programación Orientada a Objetos en C++

1) Objetos: Un objetos es la entidad básica del paradigma de programación Orientado a Objetos y es el que integra la estructura de datos (atributos) y un comportamiento (operaciones). Se distinguen entre sí por medio de su propia identidad, aunque internamente los valores de los atributos sean iguales.

2) Clases: Las clases describen posibles objetos, con una estructura y comportamiento común. Aquellos objetos que contienen los mismos atributos y operaciones pertenecen a la misma clase. La estructura de clases integra las operaciones con los atributos a los cuales se aplican.

3) Instancia: El proceso de crear objetos que pertenecen a una clase se denomina instanciación. De cierta clase, pueden ser instanciados un número indefinido de objetos.

4) Herencia: En una jerarquía de clases, es posible compartir atributos y operaciones entre clases basados en la generalización de clases. Dicha generalización se construye mediante la herencia. Las clases más generales se conocen como superclases y las clases más especializadas se conocen como subclases. En C++, a diferencia de otros lenguajes, la herencia puede ser simple o múltiple.

5) Abstracción: La abstracción se concentra en lo primordial de una entidad y no en sus propiedades secundarias, además de en qué es lo que hace el objeto y no en cómo lo hace. En este sentido, se da énfasis a cuáles son los objetos y no cómo son usados.

6) Encapsulamiento: El encapsulamiento es la separación de las propiedades externas de un objeto de los detalles de implementación internos del objeto. Al separar la interfaz del objeto de su implementación, se limita la complejidad a mostrarse sólo la información relevante. Por otra parte, disminuye el impacto a cambios en la implementación, ya que los cambios a las propiedades internas del objeto no afectan su interacción externa.

7) Modularidad: El encapsulamiento de los objetos trae como consecuencia una gran modularidad. Cada módulo se concentra en una sola clase de objetos, así, cada módulo se concentra en una sola clase objetos. Los módulos tienden a ser pequeños y concisos. La modularidad ofrece la ventaja que facilita el encontrar y corregir problemas, además de que la complejidad de un sistema se reduce facilitando así su mantenimiento.

8) Extensibilidad: La extensibilidad permite hacer cambios en un sistema sin afectar lo que ya existe. De esta forma nuevas clases pueden ser definidas sin tener que cambiar la interfaz del resto del sistema. La definición de los objetos existentes puede ser extendida sin necesidad de cambios más allá del propio objeto.

9) Polimorfismo: El polimorfismo es la característica de definir las mismas operaciones con diferente comportamiento en diferentes clases. De esta forma es posible llamar una operación sin preocuparse de cuál implementación es requerida en qué clase, siendo responsabilidad de la jerarquía de clases y no del programador.

10) Reusabilidad de código: La programación orientada a objetos apoya el reuso de código en un sistema, ya que los componentes orientados a objetos se pueden utilizar para estructurar librerías reusables. El reuso reduce el tamaño de un sistema durante la creación y ejecución. La herencia es uno de los factores más importantes contribuyendo al incremento en el reuso de código dentro de un proyecto.

Con estos conceptos finalizamos este artículo, el cual ha sido un poco teórico. Ya en los siguientes empezaremos a ver algo de código para comprender mejor como se usa la Programación Orientada a Objetos en C++.

Una Mirada General a los Patrones de Diseño

2016-04-10T23:54:00.001-05:00

Como lo mencioné en un anterior artículo, Introducción a los Patrones de Diseño o Design Patterns, iremos viendo los patrones de diseño que se describen en el libro de referencia "GoF". Estos patrones son diversas respuestas a problemas conocidos de la programación orientada a objetos.

A continuación veremos la lista de los patrones de diseño que iré explicando en posteriores entradas.

Lista o Catálogo de Patrones de Diseño

- Abstract Factory: Tiene como objetivo la creación de objetos reagrupados en familias sin tener que conocer las clases concretas destinadas a la creación de estos objetos.

- Builder: Permite separar la construcción de objetos complejos de su implementación de modo que un cliente pueda crear estos objetos complejos con implementaciones diferentes.

- Factory Method: Tiene como objetivo presentar un método abstracto para la creación de un objeto reportando a las subclases concretas la creación efectiva.

- Prototype: Permite crear nuevos objetos por duplicación de objetos existentes llamados prototipos que disponen de la capacidad de clonación.

- Singleton: Permite asegurar que de una clase concreta existe una única instancia y proporciona un método único que la devuelve.

- Adapter: Tiene como objetivo convertir la interfaz de una clase existente en la interfaz esperada por los clientes también existentes para que puedan trabajar de forma conjunta.

- Bridge: Tiene como objetivo separar los aspectos conceptuales de una jerarquía de clases de su implementación.

- Composite: Proporciona un marco de diseño de una composición de objetos con una profundidad de composición variable, basando el diseño en un árbol.

- Decorator: Permite agregar dinámicamente funcionalidades suplementarias a un objeto.

- Facade: Tiene como objetivo reagrupar las interfaces de un conjunto de objetos en una interfaz unificada que resulte más fácil de utilizar.

- Flyweight: Facilita la comparación de un conjunto importante de objetos con granularidad muy fina.

- Proxy: Construye un objeto que se substituye por otro objeto y que controla su acceso.

- Chain of responsability: Crea una cadena de objetos tal que si un objeto de la cadena no puede responder a una petición, la pueda transmitir a sus sucesores hasta que uno de ellos responda.

- Command: Tiene como objetivo transformar una consulta en un objeto, facilitando operaciones como la anulación, la actualización de consultas y su seguimiento.

- Interpreter: Proporciona un marco para dar una representación mediante objetos de la gramática de un lenguaje con el objetivo de evaluar, interpretando las experiencias escritas en este lenguaje.

- Iterator: Proporciona un acceso secuencial a una colección de objetos sin que los clientes se preocupen de la implementación de esta colección.

- Mediator: Construye un objeto cuya vocación es la gestión y el control de las interacciones en el seno de un conjunto de objetos sin que estos elementos se conozcan mutuamente.

- Memento: Salvaguarda y restaura el estado de un objeto.

- Observer: Construye una dependencia entre un sujeto y sus observadores de modo que cada modificación del sujeto sea notificada a los observadores para que puedan actualizar su estado.

- State: Permite a un objeto adaptar su comportamiento en función de su estado interno.

- Strategy: Adapta el comportamiento y los algoritmos de un objeto en función de una necesidad concreta sin por ello cargar las interacciones con los clientes de este objeto.

- Template Method: Permite reportar en las subclases ciertas etapas de una de las operaciones de un objeto, estando éstas descritas en las subclases.

- Visitor: Construye una operación a realizar en los elementos de un conjunto de objetos. Es posible agregar nuevas operaciones sin modificar las clases de estos objetos.

Estos son los 23 Patrones de Diseño que se describen en el libro de referencia "GoF", y que iremos estudiando más a detalle en posteriores entradas a través de ejemplos usando diagramas UML y el lenguaje de programación Java.

Google App Engine Ahora Soporta Node.js

2016-04-01T02:16:00.001-05:00

Ahora ya es posible ejecutar Node.js sobre Google App Engine.

Google ha anunciado una asociación con NodeSource, proveedora de plataformas empresariales para Node.js, en la cual NSolid, que es precisamente la plataforma a nivel empresarial para Node.js de NodeSource, estará en la plataforma de Google Cloud, la cual a su vez cuenta con App Engine.

Ofrecida en una versión beta desde la semana pasada, el entorno en tiempo de ejecución para la popular plataforma JavaScript del lado del servidor le permite a los desarrolladores construir Back-ends para aplicaciones web y móviles con JavaScript y escalar estos sistemas a la nube de Google.

Hasta ahora, Google App Engine ya había añadido soporte para el desarrollo de aplicaciones en Java, Python, PHP y Go.

"NodeSource está asociado con Google para ser el principal proveedor de un entorno de ejecución Node.js sobre la plataforma de Google Cloud", dijo Mark Piening de NodeSource. "Esta asociación le ofrecerá a los desarrolladores de Node.js una sencilla solución fuera de la caja (out-of-the-box) para conseguir una visión profunda dentro de sus aplicaciones Node.js que se están ejecutando en la plataforma de Google Cloud."

Google hizo hincapié en las herramientas disponibles en la App Engine para los usuarios de Node.js: "Cuando ejecutas una aplicación Node.js sobre la App Engine, puedes usar las herramientas y bases de datos que actualmente conoces y más te gustan. Puedes usar Express, Hapi, Parse-server, o cualquier otro servidor Web para construir tu aplicación. Puedes usar MongoDB, Redis, o Google Cloud Datastore para almacenar tus datos." dice Justin Beckwith, Gerente de Producto para la plataforma de Google Cloud, en un detallado boletín sobre el soporte a Node.js

Los usuarios también podrán usar herramientas de Google como Google Container Engine para ejecutar contenedores Docker, o Google Compute Engine, el cual proporciona máquinas virtuales.

El módulo NPM gcloud, por su parte, permite el uso de APIs y servicios de Google, incliyendo el API de Google Cloud Vision, para integrar características de detección visual como el etiquetado de imágenes, y Google BigQuery, para la consulta de un conjunto de datos masivos.

Más cosas vendrán por parte de Google para Node.js, "Esto es sólo el principio, mantén tus oídos atentos para ser testigo de la próxima ola de características que se ofrecerán para Node.js en la plataforma de Google Cloud", dijo Beckwith.

Bien, así que qué les parece esto, creo que es una gran noticia para los amantes de JavaScript :-)

Introducción a los Patrones de Diseño o Design Patterns

2016-03-23T01:42:00.000-05:00

Cuando trabajamos con proyectos medianos o grandes, es bueno contar con metodologías que nos ayuden en muchas ocasiones a simplificar el trabajo, sea que trabajemos solos o en equipo, y si trabajamos en equipo, que tengamos la añadidura de todos hablar el mismo "idioma", o mejor, el mismo "dialecto" (ya que el idioma vendría siendo el lenguaje :-) jejeje) gracias a dichas metodologías.

Por ésta razón he decidido empezar una serie de artículos en las que iremos estudiando poco a poco algunos patrones de diseño y cómo implementarlos en Java. Pero antes que nada, veamos qué son los patrones de diseño o design patterns.

¿Qué son los Patrones de Diseño o Design Patterns?

Un patrón de diseño o pattern design consiste en un diagrama de objetos que forma una solución a un problema conocido y frecuente. Dicho diagrama de objetos está constituido por un conjunto de objetos descritos por clases y las relaciones que enlazan los objetos.

Así como en otras áreas de la Ingeniería se han desarrollado a lo largo de la historia modelos a seguir, por ejemplo en la Ingeniería Civil, existen modelos de buenas prácticas para llevar a cabo una Obra, muchos de los cuales incluso son obligatorios de implementar en ciertos casos; sin embargo en la programación esa palabra "obligación" desaparece, ya que a la final, es el programador quien decide cuál es la mejor solución para su problema en cuestión y tiene la total libertad de decidirse a usar o no un Patrón de Diseño.

Los patrones de diseño responden a problemas de diseño de aplicaciones en el marco de la Programación Orientada a Objetos. Se trata de soluciones conocidas y probadas cuyo diseño proviene de la experiencia de los programadores. No existe un aspecto teórico en los patrones, en particular no existe una formalización (a diferencia como sucede en el caso de los algoritmos).

Los patrones de diseño están basados en las buenas prácticas de la programación orientada a Objetos. Por ejemplo, la siguiente figura muestra el patrón Template method que describiremos en una posterior entrada. En éste patrón, el método calculaPrecioConIVA invoca al método calculaIVA abstracto de la clase Pedido.

Dicho método (calculaIVA) Está definido en las subclases de Pedido, en este caso, las clases PedidoEspaña y PedidoColombia. En efecto, el IVA varía en función del país. Al método calculaPrecioConIVA se le llama "modelo" (template method). Este método introduce un algoritmo basado en un método abstracto.

Este patrón está basado en el polimorfismo, una propiedad importante de la programación orientada a objetos. El precio de un pedido en España o en Colombia está sometido a un impuesto sobre el valor añadido. No obstante la tasa no es la misma, y el cálculo del IVA difiere en España y en Colombia. Por consiguiente, el patrón Template method constituye una buena ilustración del polimorfismo.

Los patrones se introducen en 1995 con el libro del llamado "GoF", de Gang of Four (en referencia a la "banda de los cuatro" autores), llamado "Dessign Patterns -Elements of Reusable Object-Oriented Software" escrito por Erich Gama, Richard Helm, Ralph Johnson y John Vlissides. Este libro constituye la obra de referencia acerca de patrones de diseño.

Los patrones de diseño no son exclusividad del lenguaje de programación Java, ya que como lo dije anteriormente, son la implementación de buenas prácticas en la programación Orientada a Objetos.

Sin embargo, Java es un lenguaje Orientado a Objetos por excelencia, así que éste será el lenguaje escogido para ejemplificar cada uno de los patrones de diseño que iremos estudiando. Así mismo, también usaré el lenguaje de modelización UML, ya que éste nos permite comprender de manera rápida y gráfica los ejemplos expuestos mediante Diagramas de Clase y/o Diagramas de Objetos.

Cómo Hacer un Modelo de Datos Personalizado para un JTable en Java

2016-03-21T10:36:00.004-05:00

Una de las mejores formas de organizar y mostrar la información que obtenemos ya sea de una Base de Datos o de alguna otra fuente de datos, o incluso información estática en nuestros programas es a través de tablas, y en este artículo veremos como crear modelos de datos personalizados para no sólo mostrar información en un JTable en Java, sino también para acceder a la información que se encuentra en ellos, e incluso para modificarla de forma sencilla en caso de que así lo necesitemos.

Cuando queremos mostrar información en un JTable, normalmente lo hacemos a través de una clase del API de Java: DefaultTableModel, que sería la forma más sencilla de hacerlo, sin embargo, desde que aprendí esta forma que les enseñaré a continuación, es decir, usando un Modelo de Datos personalizado, procuro tratar de usarlo, ya que como su nombre lo indica, lo que hacemos es crear un Modelo de Datos, que separa el Modelo de la Vista, de esta forma, lo único que haremos es manipular siempre nuestro modelo, y la vista se actualizará de acuerdo a este.

Uso de Modelos de Datos para JTable en Java

Bien, primero que nada, veamos un poco de teoría... sí, lo se, a veces no nos gusta mucho la teoría, pero muchas veces es necesaria para entender lo que estamos haciendo, sin embargo, vamos a explicar la teoría de una forma sencilla y enfocándonos en lo que nos interesa para este tutorial :-)

Cuando vamos a gestionar los datos dentro de un JTable, siempre debemos hacerlo a través de un modelo de datos, y cómo había mencionado anteriormente, lo más sencillo es hacerlo a través de un DefaultTableModel, ya que lo único que haríamos es lo siguiente:

DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable(modelo);

O en caso de que ya tuviésemos nuestra instancia de JTable creada como sucede cuando trabajamos con el editor gráfico de NetBeans, asignaríamos nuestro modelo de la siguiente forma:

DefaultTableModel modelo = new DefaultTableModel();
tabla.setModel(modelo);

Y esta es la forma más sencilla, puesto que la clase DefaultTableModel implementa todos los métodos de la interface TableModel, y de la clase abstracta AbstractTableModel, brindándonos un comportamiento por defecto para todos nuestros JTables e incluso permitiéndonos sobre-escribir sus métodos para casos en los que necesitemos comportamientos más personalizados.

Esto nos puede ser práctico en caso de que sólo deseáramos mostrar datos que no van a cambiar, por ejemplo, una tabla con valores estáticos, a la cual no nos interesa acceder a sus datos y en la que por ejemplo sólo nos interesara que no se permitiera editar el valor de sus celdas. Esto lo haríamos más o menos de la siguiente forma:

DefaultTableModel modelo = new DefaultTableModel() {
    @Override
    public boolean isCellEditable (int row, int column){
        return false;
    }
};
tabla.setModel(modelo);
// Podemos añadir los datos antes o después de asignar el modelo
// Supongamos que añadimos 10 filas de datos
for (int i = 0; i < 10; i++) {
    modelo.addRow(new Object[]{"Columna 1", "Columna 2", "Columna 3", 1000, 50.8});
}

Esto es totalmente válido, y como vemos, muy rápido de hacer, y hasta podríamos decir que un poco práctico, aunque la verdad no tanto, y ya veremos el por qué, a menos claro, que como lo había mencionado, sólo nos interese mostrar los datos y nada más dejarlos ahí quieticos, incluso sin querer acceder a ellos, lo cual es algo que normalmente no suele suceder.

Empecemos a plantear algunos casos. Primero, supongamos que deseamos obtener los datos de una fila para una operación, o para pasarlo a algún método, o alguna otra tarea que necesitemos; en este caso supongamos que es para mostrarlo en un String; para esto haríamos lo siguiente:

int fila = tabla.getSelectedRow();
String valores = "";
for (int i = 0; i < tabla.getColumnCount(); i++) {
    valores += tabla.getValueAt(fila, i).toString() + ", ";
}

El método getValueAt(row, column) devuelve un dato de tipo Object, por eso usamos su método toString() para pasarlo a String. Hasta aquí, todo está normal y se puede hacer sin ningún problema, aunque desde ya podemos visualizar que acceder a los datos de un JTable a través de este método implica perder comunicación con nuestras clases Bean, en caso de que las usemos para crear las instancias de los datos, ya veremos más adelante a lo que me refiero.

Bueno, de igual modo, si deseamos insertar algún valor, o más bien, modificar algún valor que ya tenemos dentro del JTable lo haríamos con el método:

...
tabla.setValueAt(value, row, column);
...

Bueno, pero vayamos un poco más allá. Supongamos que por ejemplo en las filas en las que agregamos valores numéricos, nosotros deseamos que éstos se vean con un formato específico, por ejemplo con el formato #.##0,## Esto lo haríamos así:

DecimalFormatSymbols simbolos = new DecimalFormatSymbols();
simbolos.setDecimalSeparator(',');
simbolos.setGroupingSeparator('.');
DecimalFormat formato = new DecimalFormat("#,##0.##",simbolos);

for (int i = 0; i < 10; i++) {
    modelo.addRow(new Object[]{"Columna 1", "Columna 2", "Columna 3", formato.format(1000), formato.format(50.8)});
}

Bien, parece que ahora nuestros valores numéricos se muestran un poco más bonitos al tener un formato específico. ¿Pero qué pasaría si nosotros deseamos obtener todos los valores de una columna numérica para por ejemplo hacer una suma con ellos?

El método getValueAt(row, column) nos devuelve un objeto el cual podemos castear al tipo de dato que el compilador reconoce para los datos que el JTable encuentra en esa columna. Así que si deseamos obtener por ejemplo un double, lo haríamos así:

double valor = (double) tabla.getValueAt(row, column);
// También podemos hacerlo a través de esta otra forma:
double valor2 = Double.parseDouble(tabla.getValueAt(row, column).toString());

Si el valor que se obtiene es en efecto un double, no habrá ningún problema, pero en caso de no serlo, se nos arrojará una Excepción en tiempo de ejecución de tipo ClassCastException para el primer caso, o de NumberFormatException para el segundo, lo cual es lo que muy seguro nos pasará ahora.

¿Por qué estoy seguro que tendremos una excepción? Si no me crees, haz una prueba como te he dicho y aplicando los formatos que indico anteriormente y me cuentas jejeje ;-)

Pues bien, recuerda que hemos añadido un formato, y al ingresar un número formateado, no estamos ingresando en el JTable un número, sino un String, así que si intentamos hacer un casting de String a double, obtendremos una Excepción.

Bien, ahora me dirás, ¿y si uso la segundo forma, es decir, haciendo un parsing usando los métodos respectivos de las clases de tipo numérico? Esto puede funcionar, claro, si la cadena obtenida tiene el formato adecuado.

Sin embargo, éste no es el caso, porque para Java un número almacenado en un String puede ser convertido a Integer si éste no posee ningún separador, y a Double si sólamente tiene el separador de decimales, el cual es por defecto el ".", y recuerda que en los formatos hemos indicado que nuestros valores se mostrarán con separador de miles, y además el separador de decimales que hemos asignado es la ",".

Vaya, menudo problema, y no estoy diciendo que no tenga solución si lo hiciéramos así, pero dicha solución sería muy artificiosa, ya que cada vez que obtengamos un valor, primero tendríamos que obtener el String, eliminarle el separador de miles, y posteriormente cambiarle el símbolo decimal, lo cual es un derroche de recursos que sólo hace que nuestra aplicación vaya más lenta.

Así que por estas, y por muchas otras razones, la mejor solución es usar un Modelo de datos que tenga independencia de nuestra JTable. para lo cual crearemos una clase que extienda de la clase AbstractTableModel. También podríamos hacerlo implementando la clase TableModel, sin embargo, al heredar de la clase AbstractTableModel evitamos tener que sobre-escribir los métodos para notificar a los suscriptores, además de que nos evitamos tener que crear un TableModelEvent, rellenarlo con los datos adecuados y avisar a los suscriptores cuando hacemos alguna modificación en los datos.

Un suscriptor es cualquier clase que quiera enterarse de cambios en los datos del modelo. El JTable es un ejemplo claro. El JTable se suscribe a cambios de datos en el modelo y de esta forma, en cuanto cambiemos datos en el modelo, el JTable se entera y se repinta automáticamente la pantalla.

Bien, yo creo que ya es suficiente de teoría y podemos dejar hasta aquí esta introducción. Entremos ahora sí en materia de este tutorial que es aprender cómo hacer un modelo de datos personalizados para un JTable en Java:

¿Qué Usaremos Para Este Tutorial?

- NetBeans 8.1

- Java 1.8

Nivel: Intermedio

Tiempo: 30 minutos

1. Creamos un proyecto en NetBeans con la siguiente estructura:

Aquí podemos observar 3 clases. VentanaPrincipal, que es la clase Main y en la que tendremos nuestros componentes visuales como nuestro JTable, la clase ModeloDatosTablaPersonas que será nuestro Modelo de Datos para el JTable, y nuestra clase Persona que será el Bean de nuestro Modelo de Datos.

2. Creamos la interfaz de usuario la cual comprende un JFrame donde hemos agregado un JTable y un JButton que usaremos para obtener los datos de una fila seleccionada.

3. Creamos el Bean de nuestro modelo de acuerdo a la estructura de esta JTable. Así que nuestra clase Persona nos quedaría de la siguiente forma:

package com.eljavatar.ejemploabstracttablemodel;

/**
 *
 * @author Andres
 */
public class Persona {
    
    private String codigo;
    private String nombres;
    private int edad;
    private double valorDeuda;

    public Persona(String codigo, String nombres, int edas, double valorDeuda) {
        this.codigo = codigo;
        this.nombres = nombres;
        this.edad = edas;
        this.valorDeuda = valorDeuda;
    }

    public Persona() {
    }

    public String getCodigo() {
        return codigo;
    }

    public void setCodigo(String codigo) {
        this.codigo = codigo;
    }

    public String getNombres() {
        return nombres;
    }

    public void setNombres(String nombres) {
        this.nombres = nombres;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }

    public double getValorDeuda() {
        return valorDeuda;
    }

    public void setValorDeuda(double valorDeuda) {
        this.valorDeuda = valorDeuda;
    }
    
}

En ésta clase sólamente hemos creado los parámetros que necesitamos, dos constructores, uno con todos los atributos de la clase y uno por defecto vacío, y los Getters y Setters de cada uno de los atributos, es decir, una clase POJO común y corriente.

4. Ahora vamos a nuestra clase ModeloDatosTablaPersona. lo primero que debemos hacer es heredar de la clase AbstractTableModel, por lo cual debemos importar dicha clase, pero además, ésta posee tres métodos abstractos los cuales debemos implementar; así pues, nuestra clase empezaría teniendo la siguiente forma:

package com.eljavatar.ejemploabstracttablemodel;

import javax.swing.table.AbstractTableModel;

public class ModeloDatosTablaPersonas extends AbstractTableModel {

    @Override
    public int getRowCount() {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public int getColumnCount() {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

}

En un momento iremos editando el código de estos tres métodos, por ahora seguiremos con lo siguiente:

5. Creamos tres atributos. Un array de tipo Class que contendrá el tipo de dato de las columnas, un array de tipo String que contendrá los títulos de las columnas, y una lista de tipo List<Persona> que contendrá los datos de nuestro JTable. Además crearemos el respectivo Get y Set para la lista de datos:

private final Class[] tipoColumnas;
private final String[] titleColumnas;
private List<Persona> personas;

public List<Persona> getPersonas() {
    return personas;
}

public void setPersonas(List<Persona> personas) {
    this.personas = personas;
}

6. Ahora creamos el constructor de la clase en donde inicializaremos la lista y asignaremos los nombres de las columnas y sus correspondientes tipos de datos:

public ModeloDatosTablaPersonas() {
    personas = new ArrayList();
    this.titleColumnas = new String[]{"Código", "Nombres", "Edad", "Valor Deuda"};
    this.tipoColumnas = new Class[]{String.class, String.class, Integer.class, Double.class};
}

7. Ahora sobre-escribiremos tres métodos de la clase AbstractTableModel mediante los cuales retornaremos el título de nuestras columnas, su tipo de dato, y además modificaremos el comportamiento por defecto de la edición de las celdas para que éstas puedan ser editadas:

@Override
public String getColumnName(int column) {
    return titleColumnas[column];
}

@Override
public Class<?> getColumnClass(int columnIndex) {
    return tipoColumnas[columnIndex];
}

@Override
public boolean isCellEditable(int rowIndex, int columnIndex) {
     return true;
}

8. Bien, ahora vamos a ver como quedarían los métodos que implementamos inicialmente:

@Override
public int getRowCount() {
    return personas.size();
}

@Override
public int getColumnCount() {
    return titleColumnas.length;
}

Con éstos dos métodos lo que hacemos es obtener la cantidad de filas según la cantidad de elementos que tiene nuestro List, y la cantidad de columnas según la cantidad de elementos que tiene el array que guarda los títulos de las columnas.

Y el método getValueAt(int rowIndex, int columnIndex) nos quedaría de la siguiente forma:

@Override
public Object getValueAt(int rowIndex, int columnIndex) {
    switch (columnIndex) {
        case 0:
            return personas.get(rowIndex).getCodigo();
        case 1:
            return personas.get(rowIndex).getNombres();
        case 2:
            return personas.get(rowIndex).getEdad();
        case 3:
            return personas.get(rowIndex).getValorDeuda();
        default:
            return null;
    }
}

Es con éste método con el que mostramos los datos en el JTable.

9. Para poder cambiar datos en el JTable, debemos sobre-escribir el método setValueAt(Object aValue, int rowIndex, int columnIndex) de la clase AbstractTableModel y hacerlo de forma similar a como lo hicimos con el método getValueAt, pero además, notificamos la modificación en los datos a través de dos métodos de ésta misma clase:

@Override
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
    switch (columnIndex) {
        case 0:
            personas.get(rowIndex).setCodigo(aValue.toString());
            break;
        case 1:
            personas.get(rowIndex).setNombres(aValue.toString());
            break;
        case 2:
            personas.get(rowIndex).setEdad((int) aValue);
            break;
        case 3:
            personas.get(rowIndex).setValorDeuda((double) aValue);
        default: ;
    }
    this.fireTableCellUpdated(rowIndex, columnIndex);
    this.fireTableRowsUpdated(rowIndex, rowIndex);
}

Como podemos apreciar, cuando modificamos entonces ahora un valor en el JTable, este no se afecta directamente en el JTable, sino en la lista de tipo Persona, la cual es la que se encarga de gestionar los datos y no un Object genérico como sucedía cuando usábamos DefaultTableModel.

Bueno, parece que ya todo está tomando forma. Ahora sólo nos falta hacer uso de este modelo, pero antes, veamos cómo quedó completa nuestra clase ModeloDatosTablaPersonas:

package com.eljavatar.ejemploabstracttablemodel;

import java.util.ArrayList;
import java.util.List;
import javax.swing.table.AbstractTableModel;

/**
 *
 * @author Andres
 */
public class ModeloDatosTablaPersonas extends AbstractTableModel {

    private final Class[] tipoColumnas;
    private final String[] titleColumnas;
    private List<Persona> personas;

    public List<Persona> getPersonas() {
        return personas;
    }

    public void setPersonas(List<Persona> personas) {
        this.personas = personas;
    }

    public ModeloDatosTablaPersonas() {
        personas = new ArrayList();
        this.titleColumnas = new String[]{"Código", "Nombres", "Edad", "Valor Deuda"};
        this.tipoColumnas = new Class[]{String.class, String.class, Integer.class, Double.class};
    }

    @Override
    public String getColumnName(int column) {
        return titleColumnas[column];
    }

    @Override
    public Class<?> getColumnClass(int columnIndex) {
        return tipoColumnas[columnIndex];
    }

    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return true;
    }

    @Override
    public int getRowCount() {
        return personas.size();
    }

    @Override
    public int getColumnCount() {
        return titleColumnas.length;
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        switch (columnIndex) {
            case 0:
                return personas.get(rowIndex).getCodigo();
            case 1:
                return personas.get(rowIndex).getNombres();
            case 2:
                return personas.get(rowIndex).getEdad();
            case 3: 
                return personas.get(rowIndex).getValorDeuda();
            default:
                return null;
        }
    }

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        switch (columnIndex) {
            case 0:
                personas.get(rowIndex).setCodigo(aValue.toString());
                break;
            case 1:
                personas.get(rowIndex).setNombres(aValue.toString());
                break;
            case 2:
                personas.get(rowIndex).setEdad((int) aValue);
                break;
            case 3:
                personas.get(rowIndex).setValorDeuda((double) aValue);
            default: ;
        }
        this.fireTableCellUpdated(rowIndex, columnIndex);
        this.fireTableRowsUpdated(rowIndex, rowIndex);
    }

}

10. En nuestra clase VentanaPrincipal que es donde hemos creado nuestro JTable, creamos un atributo de tipo ModeloDatosTablaPersonas y creamos un método en el que asignaremos nuestro respectivo modelo:

private ModeloDatosTablaPersonas modeloTablaPersonas;

private void setModeloTabla() {
    modeloTablaPersonas = new ModeloDatosTablaPersonas();
    modeloTablaPersonas.setPersonas(obtenerPersonas());
    this.jTpersonas.setModel(modeloTablaPersonas);
    this.jTpersonas.getColumnModel().getColumn(3).setCellRenderer(new DecimalFormatRenderer());
}

11. El método obtenerPersonas() es cualquier método que nos retorne un ArrayList con datos ya sea de una base de datos, o de algún otro lado, pero en este caso será una lista de datos que crearemos a lo más Hard Coding :-P

public ArrayList<Persona> obtenerPersonas() {
    ArrayList<Persona> lista = new ArrayList();
    lista.add(new Persona("Cod001", "Juan", 24, 5000.4));
    lista.add(new Persona("Cod002", "Felipe", 27, 6700.8));
    lista.add(new Persona("Cod003", "Diana", 31, 354.9));
    lista.add(new Persona("Cod004", "María", 46, 5300));
    lista.add(new Persona("Cod005", "Camilo", 28, 2890.6));
    lista.add(new Persona("Cod006", "Pedro", 52, 1600.5));
    lista.add(new Persona("Cod007", "Sandra", 43, 2000));
    lista.add(new Persona("Cod008", "Esteban", 39, 752));
    lista.add(new Persona("Cod009", "Pablo", 26, 2430.1));
    lista.add(new Persona("Cod010", "Ana", 38, 3470.3));
    return lista;
}

12. La clase DecimalFormatRenderer es una clase estática dentro de nuestra clase encargada de darle formato a los valores decimales, en este caso de la columna 3:

static class DecimalFormatRenderer extends DefaultTableCellRenderer {
        
    private static DecimalFormatSymbols simbolos;
    private static DecimalFormat formato;
        
    @Override
    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
        simbolos = new DecimalFormatSymbols();
        simbolos.setDecimalSeparator(',');
        simbolos.setGroupingSeparator('.');
        formato = new DecimalFormat("#,##0.##", simbolos);
        value = formato.format((Number) value);
        return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
    }
}

Sé lo que algunos estarán pensando, y si.. es cierto, esto mismo lo hubiéramos podido hacer con el DefaultTableModel, pero a poco no es más bonita esta implementación jejejeje... bueno hablando en serio, la mayor ventaja de hacerlo de este modo es que no perdemos la referencia de los datos que instanciamos a través de nuestra clase Bean, lo cual veremos ahora cuando queramos obtener los datos de alguna fila, pero antes, añadamos el método setModeloTabla() a nuestro constructor:

public VentanaPrincipal() {
    initComponents();
    setModeloTabla();
}

13. Vamos a añadir un evento de tipo ActionListener a nuestro botón, para ello, basta con hacer doble clic sobre el botón, y NetBeans automáticamente nos añadirá el evento y nos ubicará dentro del método en el cual escribiremos las acciones que se realizarán cuando se haga clic sobre el botón. Así pues, el código de nuestro botón sería el siguiente:

private void jBobtenerDatosActionPerformed(java.awt.event.ActionEvent evt) {
    int fila = this.jTpersonas.getSelectedRow();
    if (fila < 0) {
        JOptionPane.showMessageDialog(this, "Debe Seleccionar una Fila", "Error", JOptionPane.ERROR_MESSAGE);
        return;
    }
    Persona persona = modeloTablaPersonas.getPersonas().get(fila);
    String mensaje = "Datos de la Persona Seleccionada\n"
            + "Código: " + persona.getCodigo() + "\n"
            + "Nombre: " + persona.getNombres() + "\n"
            + "Edad: " + persona.getEdad() + "\n"
            + "Valor Deuda: " + persona.getValorDeuda();
    JOptionPane.showMessageDialog(this, mensaje, "Datos", JOptionPane.INFORMATION_MESSAGE);
}

Como podemos apreciar, los datos no los estamos recuperando del JTable, sino del List<Persona>, lo cual es por un lado mucho más práctico ya que evitamos tener que castear los datos cuando los recuperamos ahorrando así recursos y agilizando el rendimiento de nuestras aplicaciones, y por otro lado seguimos buenas prácticas de Programación en las que separamos las vistas de los modelos de datos.

Además como lo he venido mencionando a lo largo de éste tutorial, no perdemos la referencia que tenemos con nuestra clase Bean, que en este caso es Persona, ya que cuando lo hacemos a través de un DefaultTableModel, la perdemos desde que ingresamos los datos en el JTable ya que debemos meter nuestros datos en un array de tipo Object para poder hacerlo, y para recuperarlos en un Bean si así lo quisiéramos, tendríamos que recuperar los datos como Objects y castearlos; mientras que con esta forma, ingresamos un objeto de tipo Persona, y de igual forma recuperamos un objeto de tipo Persona.

Así pues, el código completo de nuestra clase VentanaPrincipal, y omitiendo el código auto-generado por NetBeans, nos quedaría así:

package com.eljavatar.ejemploabstracttablemodel;

import java.awt.Component;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableCellRenderer;

/**
 *
 * @author Andres
 */
public class VentanaPrincipal extends javax.swing.JFrame {

    private ModeloDatosTablaPersonas modeloTablaPersonas;

    /**
     * Creates new form VentanaPrincipal
     */
    public VentanaPrincipal() {
        initComponents();
        setModeloTabla();
    }

    public ArrayList<Persona> obtenerPersonas() {
        ArrayList<Persona> lista = new ArrayList();
        lista.add(new Persona("Cod001", "Juan", 24, 5000.4));
        lista.add(new Persona("Cod002", "Felipe", 27, 6700.8));
        lista.add(new Persona("Cod003", "Diana", 31, 354.9));
        lista.add(new Persona("Cod004", "María", 46, 5300));
        lista.add(new Persona("Cod005", "Camilo", 28, 2890.6));
        lista.add(new Persona("Cod006", "Pedro", 52, 1600.5));
        lista.add(new Persona("Cod007", "Sandra", 43, 2000));
        lista.add(new Persona("Cod008", "Esteban", 39, 752));
        lista.add(new Persona("Cod009", "Pablo", 26, 2430.1));
        lista.add(new Persona("Cod010", "Ana", 38, 3470.3));
        return lista;
    }

    private void setModeloTabla() {
        modeloTablaPersonas = new ModeloDatosTablaPersonas();
        modeloTablaPersonas.setPersonas(obtenerPersonas());
        this.jTpersonas.setModel(modeloTablaPersonas);
        this.jTpersonas.getColumnModel().getColumn(3).setCellRenderer(new DecimalFormatRenderer());
    }

    static class DecimalFormatRenderer extends DefaultTableCellRenderer {
        
        private static DecimalFormatSymbols simbolos;
        private static DecimalFormat formato;
        
        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            simbolos = new DecimalFormatSymbols();
            simbolos.setDecimalSeparator(',');
            simbolos.setGroupingSeparator('.');
            formato = new DecimalFormat("#,##0.##", simbolos);
            value = formato.format((Number) value);
            return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
        }
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")                       
    private void initComponents() {
     // Código Generado por NetBeans
    }

    private void jBobtenerDatosActionPerformed(java.awt.event.ActionEvent evt) {
        int fila = this.jTpersonas.getSelectedRow();
        if (fila < 0) {
            JOptionPane.showMessageDialog(this, "Debe Seleccionar una Fila", "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }
        Persona persona = modeloTablaPersonas.getPersonas().get(fila);
        String mensaje = "Datos de la Persona Seleccionada\n"
                + "Código: " + persona.getCodigo() + "\n"
                + "Nombre: " + persona.getNombres() + "\n"
                + "Edad: " + persona.getEdad() + "\n"
                + "Valor Deuda: " + persona.getValorDeuda();
        JOptionPane.showMessageDialog(this, mensaje, "Datos", JOptionPane.INFORMATION_MESSAGE);
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        // Código Generado por NetBeans
    }

    // Variables declaration - do not modify                     
    private javax.swing.JButton jBobtenerDatos;
    private javax.swing.JScrollPane jScrollPane1;
    private javax.swing.JTable jTpersonas;
    // End of variables declaration                   
}

Con esto ya tendríamos todo listo, y si ejecutamos nuestro proyecto obtendremos el siguiente resultado:

Y si seleccionamos una fila, y damos clic sobre el botón "Obtener Datos de Fila Seleccionada" lo que obtenemos seríamos un JOptionPane que muestra la siguiente información:

Bueno, eso es todo por este artículo... creo que me salió un poco largo ;-) jejeje pero bueno, quería que todo quedara lo más claro posible.

Sin embargo, si tienes alguna duda, puedes hacérmela sabre a través de los comentarios y yo trataré de responderla a la mayor brevedad posible.

Si lo deseas, puedes descargar el código fuente de este proyecto en GitHub:

==> Ejemplo AbstractTableModel en GitHub

Tutorial Java - Características de Java

2016-02-12T01:58:00.000-05:00

En sí, las principales características que caracterizan (valga la redundancia) al lenguaje Java, no son muchas, sin embargo, son suficientes para definir la esencia de éste, y así empezar a entender cómo funciona:

Simple
Orientado a Objetos
Independencia de Plataforma
Seguro
Robusto
Arquitectura Neutra
Portable
Dinámico
Interpretado
Alto rendimiento (High Performance)
Multi-hilos (Multithreaded)
Distribuido

A continuación veremos en qué consisten cada una de estas características:

1. Simple

Según Sun MicroSystems, (ahora propiedad de Oracle), Java es un lenguaje sencillo porque su sintaxis es basada en C++ (lo cual lo hace un lenguaje fácil de aprender para aquellos programadores que han trabajado antes con C++), eliminando muchas características confusas y/o un poco extrañas para algunos usuarios como por ejemplo el uso explícito de punteros, sobre-carga de operadores, entre otras.

Además, no es necesario eliminar los Objetos de la memoria, ya que el Recolector de Basura de Java se encarga de esta tarea.

2. Orientado a Objetos

Al programar con un lenguaje Orientado a Objetos, significa que podemos organizar nuestro Software como una combinación de diferentes tipos de objetos en los que se incorporan tanto sus atributos o características, como su comportamiento.

La programación orientada a objetos (POO) es una metodología que simplifican el desarrollo y el mantenimiento de software, proporcionando algunas reglas para ello. Los conceptos básicos de la Programación Orientada a Objetos son los siguientes:

Objeto
Clase
Herencia
Polimorfismo
Abstracción
Encapsulamiento

Para entender un poco más sobre cómo funciona la Programación Orientada a Objetos, puedes leer el siguiente artículo: Paradigmas de Programación IV: Programación Orientada a Objetos.

3. Independencia de Plataforma

Podemos considerar en este punto una plataforma como el entorno de hardware o software en el que se ejecuta un programa. Hay entonces dos tipos de plataformas: las basadas en hardware, y las basadas en software, y Java proporciona una plataforma basada en software.

La plataforma sobre la cual se ejecuta Java difiere de la mayoría de otras plataformas en el sentido de que es una plataforma basada en software que se ejecuta sobre otra plataforma basada en hardware. La plataforma Java se compone de dos componentes principales:

El Entorno de Ejecución (Java Runtime Enviroment)
API (Interfaz de Programación de Aplicaciones)

El código Java puede ejecutarse en múltiples plataformas o Sistemas Operativos como Windows, Linux, Mac OS,entre otros. El código escrito en Java es compilado por el compilador y convertido a bytecode. Este bytecode es independiente de la plataforma, ya que no se ejecuta propiamente sobre el Sistema Operativo, sino sobre la Máquina Virtual de Java, haciendo alusión así a la promesa de James Gosling: Write Once Run Anywhere (Escribe una vez, Ejecuta donde quieras).

4. Seguro

Java es seguro porque:

- No hace uso de punteros explícitos, lo cual indica que no se trabaja directamente sobre la memoria del computador.

- Los programas escritos en Java se ejecutan sobre la Máquina Virtual de Java, la cual se encarga de gestionar la seguridad.

- Classloader: Añade seguridad al separar el paquete para las clases del sistema de archivos local, de los que se importan a través de fuentes de red.

- Verificador de Bytecode: Comprueba los fragmentos de código para evitar que código malicioso pueda violar el debido acceso de los objetos a la memoria.

- Security Manager: Determina qué recursos de una clase pueden acceder con permisos tanto de lectura y escritura al disco local.

Estos son los aspectos en seguridad proporcionados por la plataforma de Java. Algunas características de seguridad también puede ser proporcionadas por los mismos desarrolladores para sus aplicaciones como puede ser SSL, JAAS, criptografía, etc.

5. Robusto

Robusto simplemente significa fuerte. Java utiliza una sólida gestión de la memoria. Además, al no haber punteros se evitan problemas de seguridad. La recolección de basura en Java es automática. Tiene manejo de excepciones y un mecanismo de verificación de tipos. Todos estos puntos, hacen de Java un lenguaje bastante robusto.

6. Arquitectura Neutra

Un lenguaje o tecnología se dice que es de arquitectura neutra cuando puede ejecutarse en cualquier procesador disponible en el mundo real, sin tener en cuenta a la arquitectura y el proveedor en el proceso de desarrollo y compilación, y Java cumple con estas características.

7. Portable

El bytecode de Java puede ser ejecutado en cualquier plataforma.

8. Dinámico

El proceso de asignación del espacio de memoria al entrar a un programa en tiempo de ejecución se conoce como asignación de memoria dinámica; cuando programamos en Java, para asignar un espacio de memoria dinámicamente a un nuevo objeto, usamos la palabra reservada del lenguaje "new", algo que veremos en más detalle en próximos tutoriales.

9. Alto rendimiento (High Performance)

Java es más rápido que los lenguajes interpretados tradicionales, ya que el bytecode es muy cercano al código nativo siendo sólo un poco más lento que un lenguaje compilado como C++.

10. Distribuido

Podemos crear aplicaciones distribuidas en Java. Los RMI y EJB se utilizan para la creación de aplicaciones distribuidas. Así, podemos acceder a los archivos haciendo llamadas a los diversos métodos desde cualquier máquina en Internet.

11. Multi-hilos (Multithreaded)

Un hilo o thread es como un programa separado ejecutándose al mismo tiempo que el programa principal. Podemos escribir programas en Java que se ocupan de muchas tareas a la vez mediante la definición de múltiples hilos. La principal ventaja del multi-threading es que se comparte la misma memoria del proceso principal del programa. Los hilos son importantes para multimedia, aplicaciones web, etc.

Tutorial Java - Historia de Java

2016-01-14T02:03:00.000-05:00

Es interesante conocer la historia de Java. La historia de Java data sus inicios desde el Proyecto Green. Los miembros del equipo de Java (también conocido como equipo Green) dirigidos por James Gosling, iniciaron una revolucionaria tarea de desarrollar un lenguaje para dispositivos digitales tales como decodificadores, lavadoras, televisores, etc.

Para los miembros del equipo Green, este era un concepto un poco avanzado para la época, pero sin embargo fueron más allá, y lo adaptaron para la programación de la entonces creciente Internet. Así pues, más tarde la tecnología Java sería incorporada en Netscape.

Actualmente, Java se utiliza para programar sobre entornos web, de escritorio, dispositivos móviles, juegos, soluciones empresariales, etc. A continuación veremos los principales puntos que describen la historia de Java:

Principales puntos en la Historia de Java

1) James Gosling, Mike Sheridan, y Patrick Naughton inician el proyecto para desarrollar el lenguaje Java en Junio de 1991. El pequeño equipo compuesto por trece ingenieros de Sun MicroSystems, fue llamado equipo Green.

2) Originalmente fue diseñado para sistemas pequeños integrados en equipos electrónicos tales como decodificadores.

3) Primeramente, James Gosling denominó al lenguaje "Greentalk", y la extensión del archivo era .gt.

4) Después de esto, fue llamado "Oak", y fue desarrollado como parte del Proyecto Green.

¿Por qué se le puso el nombre Oak al lenguaje?

5) ¿Por qué Oak? Oak es el nombre de un árbol, es símbolo de fuerza y ha sido elegido como el árbol nacional en muchos países como Estados Unidos, Francia, Alemania, Rumania, etc.

6) En 1995, Oak fue rebautizado como "Java", porque era una marca comercial registrada usada por "Tecnologías Oak".

¿Por qué se le puso el nombre Java al lenguaje?

7) ¿Por qué se escogió el nombre de Java para el Lenguaje? El equipo tuvo que reunirse para elegir un nuevo nombre; se sugirieron palabras como "dinámico", "revolucionario", "Silk", "Jolt", entre otras. Querían algo que reflejara la esencia de la tecnología que habían creado: Revolucionaria, dinámica, animada, fresca, única y fácil de deletrear.

Según James Gosling "Java fue una de las mejores opciones". Java era un nombre tan único, que la mayoría de los miembros del equipo lo prefirió.

Otra hipótesis, y quizás una de las más fuertes, indican que el nombre de Java se debe a un tipo de café que vendían en una cafetería cercana, de ahí que el ícono de java sea una taza de café caliente.

8) Los objetivos de James Gosling eran implementar una máquina virtual y un lenguaje con una estructura y sintaxis similar a C++.

9) Entre junio y julio de 1994, tras una sesión maratónica de tres días entre John Gaga, James Gosling, Patrick Naughton, Wayne Rosing y Eric Schmidt, el equipo reorientó la plataforma hacia la Web

10) La primera versión de Java, la 1.0a estuvo disponible para su descarga por primera vez en 1994, pero hubo que esperar hasta el 23 de mayo de 1995, durante las conferencias de SunWorld, a que se vieran la luz pública Java y HotJava, el navegador Web.

11) La promesa inicial de Gosling era Write Once, Run Anywhere (Escríbelo una vez, ejecútalo en cualquier lugar), proporcionando un lenguaje independiente de la plataforma y un entorno de ejecución (la Máquina Virtual de Java) ligero y gratuito para las plataformas más populares de forma que los binarios (bytecode) de las aplicaciones Java pudiesen ejecutarse en cualquier plataforma.

12) En 1995, la revista Time, nombró a Java como uno de los mejores productos de 1995.

13) La versión 1.0 del JDK es lanzada el 23 de enero de 1996

14) Desde su primer lanzamiento, Java ha experimentado numerosos cambios, así como un enorme crecimiento en el número de clases y paquetes que componen la biblioteca estándar.

15) Desde la versión J2SE 1.4, la evolución del lenguaje ha sido regulada por el JCP (Java Community Process), que usa Java Specification Requests (JSRs) para proponer y especificar cambios en la plataforma Java.

Historial de las Versiones de Java

JDK Alpha and Beta (Mayo de 1995)
JDK 1.0 (23 de Enero de 1996)
JDK 1.1 (19 de Febrero de 1997)
J2SE 1.2 (8 de Diciembre de 1998)
J2SE 1.3 (8 de Mayo de 2000)
J2SE 1.4 (6 de Febrero de 2002)
J2SE 5.0 (30 de Septiembre de 2004)
Java SE 6 (11 de Diciembre de 2006)
Java SE 7 (28 de Julio de 2011)
Java SE 8 (18 de Marzo de 2014)

Articulo anterior del Tutorial Java:

==> Tutorial Java - Introducción a Java

Artículo siguiente del Tutorial Java:

==> Tutorial Java - Características de Java

Tutorial Java - Introducción a Java

2016-01-06T04:29:00.000-05:00

¿Qué es Java?

Java no sólo es un lenguaje de programación, también es una plataforma.

Java es un lenguaje de programación de alto nivel, robusto, seguro, concurrente, de propósito general y orientado a objetos.

Se considera como una plataforma cualquier entorno de hardware o software en el que un programa se ejecuta. Java tiene su propio entorno de ejecución llamado Java Runtime Environment (JRE) que traducido al español significa Entorno en Tiempo de Ejecución de Java, y su propia API; al conjunto de estos dos elementos se le conoce como plataforma Java.

Ejemplo de Código Java

A continuación veremos un ejemplo rápido de programación en java. En este caso veremos el código del famoso Hola Mundo; En los siguientes artículos de este Tutorial de Java iremos entendiendo el funcionamiento de éstas líneas de código:

public class HolaMundo {
    public static void main(String[] args) {
        System.out.println("Hola ElJavatar");
    }
}

¿Dónde se utiliza Java?

Según Oracle, 3 mil millones de dispositivos ejecutan Java. Existen muchos dispositivos en los cuales Java está siendo usado, y algunos de ellos son los siguientes:

Aplicaciones de escritorio como Acrobat Reader, Reproductores multimedia, antivirus, etc.
Aplicaciones web como Servicios en Línea DIAN (Colombia) y Caribbean Online Judge.
Aplicaciones empresariales, tales como aplicaciones bancarias e intranets.
Aplicaciones móviles
Sistemas Embebidos
Tarjetas Inteligentes
Robots
Juegos, etc.

Tipos de Aplicaciones Java

Hay 4 principales tipos de aplicaciones que se pueden crear usando lenguaje Java:

1) Aplicaciones Standalone

Son también conocidas como aplicaciones de escritorio o aplicaciones basadas en ventanas. Son el tipo de aplicaciones que tenemos que instalar como pueden ser reproductores multimedia, antivirus, software utilitario, etc. Para crear aplicaciones standalone con Java usamos AWT y Swing, los cuales veremos en próximos tutoriales.

2) Aplicaciones Web

Una aplicación que se ejecuta en el lado del servidor y crea páginas dinámicas, se denomina aplicación web. Actualmente, tecnologías como Servlets, JSP, Struts, JSF, etc., son usadas para la creación de aplicaciones web usando Java.

3) Aplicaciones Empresariales

Son aplicaciones que se distribuyen en el mundo empresarial, como lo son aplicaciones bancarias e intranets para empresas. Tienen la ventaja de contar con un alto nivel de seguridad, balanceo de cargas, gestión de concurrencia y manejo de agrupamiento. En Java, el estándar es el uso de EJB para la creación de aplicaciones empresariales.

4) Aplicaciones Móviles

Son aplicaciones creadas para dispositivos móviles como SmartPhones, SmartTV, Relojes Inteligentes, etc. Actualmente se utilizan Android y Java ME para la creación de aplicaciones móviles.

A continuación encontrarás el siguiente artículo de este Tutorial de Java:

Tutorial Java - Historia de Java

Aplicaciones Móviles: Apps Nativas VS Apps Web VS App Híbridas

2015-07-23T02:14:00.000-05:00

Ya hace más de un año que no publico en mi blog por razones de estudio y trabajo, sin embargo he decidido volver a darle vida a esta bitácora :) En este largo periodo de tiempo he incursionado bastante en el mundo móvil, y por tal razón he decidido empezar hablando del desarrollo de aplicaciones móviles.

Y es que para nadie es un secreto que el mercado móvil cada día crece más y más, no sólo por la cantidad creciente de usuarios, sino por la cantidad de plataformas que están disponibles en el mercado, lo cual representa también para nosotros como desarrolladores un gran abanico de opciones a la hora de escoger una tecnología para crear apps, ya que nuestro ideal sería llegar a la mayor cantidad de usuarios posibles.

En este orden de ideas lo primero que hemos de saber es que existen tres tipos de aplicaciones móviles con sus respectivas características, y cada una de ellas posee una serie de ventajas y desventajas, las cuales se valoran de acuerdo al tipo de desarrollo que vayamos a llevar a cabo.

Los tres tipos de Aplicaciones Móviles son:

Apps Nativas
Apps Web
Apps Híbridas

A continuación veremos en que consiste cada una de ellas, y como decía, sus respectivas ventajas y desventajas o inconvenientes que pueden presentar cada una de ellas.

1. Apps Nativas

Una aplicación nativa es aquella que se desarrolla un determinado sistema operativo en específico, usando su respectivo SDK (Software Development Kit). Cada una de las plataformas, Android, iOS, Windows Phone, Blackberry, entre otros, tienen un sistema diferente, por lo tanto, si quisiéramos que una app esté disponible en todas las plataformas haciendo uso de un desarrollo nativo, se deberán crear varias apps y cada una con el lenguaje del sistema operativo correspondiente.

Por ejemplo:

Las apps para iOS se desarrollan con lenguaje Objective-C o Swift
Las apps para Android se desarrollan con lenguaje Java
Las apps en Windows Phone se desarrollan en .Net (Visual Basic o C#)

Ventajas de las Apps Nativas

Acceso completo a todas las características del hardware del móvil (GPS, cámara, acelerómetro, agenda, almacenamiento, etc.)
Mejor experiencia de usuario
Por lo general, la ejecución es más fluída

Inconvenientes de las Apps Nativas

Se debe tener dominio de cada uno de los lenguajes y herramientas de desarrollo para cada una de las plataformas de destino
El desarrollo de una app conlleva tanto tiempo según cada una de las plataformas de destino
El código no es reutilizable entre las diferentes plataformas

2. Apps Web

Una aplicación web o webapp es aquella que se desarrolla con lenguajes como HTML, Javascript y CSS. La principal ventaja de este tipo de app con respecto a la nativa es la posibilidad de programar independientemente del sistema operativo en el que se usará la aplicación. De esta forma, una app se puede ejecutar en diferentes dispositivos sin tener que crear varias aplicaciones para cada plataforma.

Las aplicaciones web se ejecutan dentro del propio navegador web del dispositivo a través de una URL. Una de las cosas a tener en cuenta a la hora de desarrollar este tipo de aplicaciones es que el contenido debe adaptarse a la pantalla de cada uno de los dispositivos en los cuales se ejecuta adquiriendo un aspecto de navegación APP.

La gran diferencia con una aplicación nativa (además de los inconvenientes que veremos a continuación) es que una webapp no necesita instalación, por lo que no pueden estar visibles en los app store y por tanto la promoción y comercialización debe realizarse de forma independiente. De todas formas se puede crear un acceso directo que sería como “instalar” la aplicación en el dispositivo.

Ventajas de las Apps Web

El mismo código es reutilizado en múltiples plataformas
El proceso de desarrollo es más rápido
No necesitan ninguna aprobación externa para publicarse
El usuario siempre dispone de la última versión
Pueden reutilizarse sitios "responsive" ya diseñados

Inconvenientes de las Apps Web

Requieren siempre de conexión a Internet
Acceso muy limitado a las características hardware del dispositivo
La experiencia de usuario en cuanto a navegación e interacción y tiempos de respuesta es menor que en una app nativa
Requieren de mayor esfuerzo en cuanto a promoción y visibilidad

3. Apps Híbridas

Una aplicación híbrida o web app nativa es una combinación de las dos anteriores, se podría decir que recoge lo mejor de cada una de ellas. Las apps híbridas se desarrollan con lenguajes propios de las webapp, es decir, HTML, Javascript y CSS por lo que permite su uso en diferentes plataformas, pero también dan la posibilidad de acceder a gran parte de las características del hardware del dispositivo. La principal ventaja es que a pesar de estar desarrollada con HTML, Javascript y CSS, es posible agrupar los códigos y distribuirla en los app store.

Para el desarrollo de apps híbridas es común el uso de frameworks que agilizan el desarrollo de las mismas, y uno de los más utilizados es PhoneGap (Apache Cordova).

Ventajas de las Apps Híbridas

El mismo código es reutilizado en múltiples plataformas
Acceso a la gran mayoría de las características hardware del dispositivo
Instalación nativa pero construida con HTML, Javascript y CSS

Inconvenientes de las Apps Híbridas

La experiencia de usuario en cuanto a navegación e interacción y tiempos de respuesta es menor que en una app nativa
El Diseño visual no siempre va acorde con el sistema operativo en el que se muestra

¿Cuál es la mejor Opción a elegir?

Para nosotros como desarrolladores, seleccionar el tipo de app más adecuado va a depender de diversos factores. Por un lado, si el desarrollo es para un cliente que nos está contratando debemos tener en cuenta el coste que éste está dispuesto a asumir.

Por otra parte, también debemos considerar el tipo de aplicación, ya que si por ejemplo deseamos desarrollar un juego, a pesar de que HTML5 está muy avanzado en este campo, debemos tener en cuenta que los recursos de memoria y procesamiento de un dispositivo móvil son más limitados que los de un computador, por lo cual sería preferible inclinarnos a desarrollar una app nativa que nos proporcione una mejor experiencia de usuario y mayor fluidez en los gráficos.

Por ejemplo, si nuestra aplicación no requiere acceso a las características hardware del dispositivo, podríamos pensar mejor en el desarrollo de una web app o una app híbrida dependiendo de las necesidades de la misma.

En conclusión, como podrás darte cuenta, son muchas las opciones con las que cuentas, pero a fin de cuentas, lo más importante es definir primero las características y necesidades de tu app, ya que éstas te indicarán cual es la mejor opción a elegir a la hora de desarrollar una aplicación móvil.

¿Qué es una API?

2014-05-25T22:36:00.002-05:00

Es muy probable que hayas escuchado antes el término API y tal vez tengas una vaga idea acerca de su significado ¿pero realmente sabes qué es una API y para que se usa?

Una API es un conjunto de funciones y procedimientos que cumplen una o muchas funciones con el fin de ser utilizadas por otro software. Las siglas API vienen del inglés Application Programming Interface, lo cual traducido al español sería Interfaz de Programación de Aplicaciones.

Una API nos permite implementar las funciones y procedimientos que engloba en nuestro proyecto sin la necesidad de programarlas de nuevo. En términos de programación, es una capa de abstracción.

Por ejemplo, digamos que estas desarrollando una aplicación web y necesitas hacer peticiones HTTP. En lugar de desarrollar todo el código para hacer una petición HTTP, puedes utilizar una API que se encargue de esto, como por ejemplo Requests de Python. Si necesitas utilizar archivos .yaml, puedes usar la API Yaml de Ruby.

Ahora, el término API ha evolucionado un poco con la revolución de los servicios web que dieron a lugar lo que hoy se conoce como API REST, o como muchos suelen llamarla, solo API.

¿Qué es una API REST?

Una API REST es una una biblioteca apoyada totalmente en el estándar HTTP. Visto de una forma más sencilla, una API REST es un servicio que nos provee de funciones que nos dan la capacidad de hacer uso de un servicio web que no es nuestro, dentro de una aplicación propia, de manera segura.

Un ejemplo claro sería la API de Twitter. Todos los clientes desarrollados por terceros usan esa API, sin importar el sistema operativo para el cual fueron desarrollados. Al implementarla, la API te pone a disposición ciertos métodos o funciones para tu desarrollo.

Al usar una API todo el desarrollo que se quiera realizar estará limitado por los métodos o funciones que ésta incluya, es decir, no pueden ser añadidas nuevas funcionalidades. De esta manera compañías como Twitter se aseguran de lo que pueden o no hacer los clientes desarrollados por terceros.

Tweetbot, Birdie, Turpial, Fenix, Carbon, Metrotwit; todos son clientes de Twitter diferentes pero construidos usando la misma base, la API de Twitter.

Entonces, ¿para qué perder el tiempo reinventando la rueda cuando una API te permite usar código que otros desarrolladores han probado exitosamente? Es mejor usar esas funciones encapsuladas y enfocarte en tu aplicación y sus características, lo importante es que te asegures de entregar un producto de calidad.