Existen librerías en un montón de lenguajes que facilitan aún mas su uso. Pero en este caso yo he preferido programar un servicio desde cero (lo cual, gracias a la documentación del API no ha sido nada complicado).

El siguiente ejemplo es una aproximación sencilla que permite actualizar nuestro estado (enviar un post) desde aplicación Java.

/*
 *   http://creativecommons.org/licenses/by-nc/3.0/deed.es
 */

package org.francho.java.twitter;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
// http://commons.apache.org/codec/
import org.apache.commons.codec.binary.Base64;

/**
 *
 * @author francho - http://francho.org/lab/
 */
public class Twitter {

    private String username;
    private String pass;
    private String response;

    Twitter(String username, String pass) {
        setCredentials(username, pass);
    }

    /**
     * Ejemplo de acción implementada.
     *
     * Actualiza el estado de Twitter con el texto que recibe
     *
     * @param status
     */
    public void statusesUpdate(String status) {
        try {
            URL url = new URL("http://twitter.com/statuses/update.xml");
            status = URLEncoder.encode(status, "UTF-8");
            String parametros = "status=" + status;
            doTwitterRequest(url, parametros);
        } catch (MalformedURLException ex) {
            Logger.getLogger(Twitter.class.getName()).log(Level.SEVERE, null, ex);
        } catch (UnsupportedEncodingException ex) {
            Logger.getLogger(Twitter.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    /**
     * Se encarga de la conexión con Twitter.
     * Necesita tener precargada los datos de autentificación (constructor), la url y los parámetros
     */
    private void doTwitterRequest(URL url, String parametros) {
        response = "";
        try {
            // Creamos una conexión
            URLConnection conn;
            conn = url.openConnection();
            conn.setAllowUserInteraction(false);
            conn.setDoOutput(true);

            // Configuramos la autentificación (sencilla basada en HTTP)
            conn.setRequestProperty("Authorization", "Basic " + getBasicCredentials());

            // Preparamos la conexión con el servidor (vamos a mandar un formulario por post)
            conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            // Abrimos el canal de comunicación de envío
            DataOutputStream out = new DataOutputStream(conn.getOutputStream());
            // Mandamos los parámetros de la acción que (los ha tenido que precargar el método correspondiente)
            out.writeBytes(parametros.toString());
            // Nos aseguramos de que todo se envíe
            out.flush();
            // Ya hemos dicho lo que teníamos que decir, así que cerramos la conexión de envio
            out.close();

            // Capturamos la respuesta
            BufferedReader input = new BufferedReader(new InputStreamReader(conn.getInputStream()));

            String l = "";
            while ((l = input.readLine()) != null) {
                response += l + "\n";
            }

        } catch (IOException ex) {
            Logger.getLogger(Twitter.class.getName()).log(Level.SEVERE, null, ex);

        }

    }

    public void setCredentials(String username, String pass) {
        this.username = username;
        this.pass = pass;
    }

    public String getBasicCredentials() {
        byte[] credentialsBytes = (username + ":" + pass).getBytes();
        byte[] encodedBytes = Base64.encodeBase64(credentialsBytes);
        return new String(encodedBytes);
    }

    public String getResponse() {
        return response;
    }
}

Este sería un ejemplo de uso de nuestra clase:

/*
 *   http://creativecommons.org/licenses/by-nc/3.0/deed.es
 */

package org.francho.java.twitter;

import java.util.Date;

/**
 *
 * @author francho - http://francho.org/lab/
 */
public class Test {
    public static void main(String[] args) {
        Twitter twitter = new Twitter("yoEnTwitter", "miclave");

        Date ahora = new Date();

        twitter.statusesUpdate("Jugando con Java y el API de Twitter " + ahora);
        System.out.println(twitter.getResponse());
    }
}

A partir de Java SE 5.0 se incluyo una modalidad de tipos enumerados que mantiene la seguridad de los tipos. En la práctica viene a ser como si definiéramos nuestros propios tipos de variables.

En Java, los tipos enumerados se pueden definir fuera o dentro de una clase. Otra ventaja que traen los tipos enum de Java es que al ser una “especie de clase” podemos añadirles métodos, variables de instancia, constructores, etc… lo que los hace muy potentes.

A continuación os dejo un pequeño ejemplo que ilustra todos estos conceptos.

/*
 *   http://creativecommons.org/licenses/by-nc/3.0/deed.es
 */
package org.francho.java.ejemplos;

/*
 *
 * @author francho - http://francho.org/lab/
 */

/*
 * Un tipo enumerado "complejo", tiene sus propios métodos y constructor
 */

enum Vaso {
    // Tipos de vaso disponibles. Pasan al constructor su capacidad en cc.
    JARRA(500), TUBO(250), TERCIO(333), CAÑA(200);

    private int cc; // Variable interna donde almacenaremos la capacidad

    // Nuestro constructor nos fuerza a pasar parámetros al definir un nuevo tipo
    Vaso(int cc) {
        this.cc = cc;
    }

    // Devuelve la capacidad del vaso
    public int getCentimetrosCubicos() {
        return cc;
    }
}

/*
 * Definimos un tipo de bebida
 */

class BebidaCerveza {
    enum MarcaCerveza { AMBAR, GUINNESS, HEINEKEN } // Tipos enumerados sencillos. Solo tenemos estas marcas

    private Vaso vaso;
    private MarcaCerveza marca;

    BebidaCerveza(MarcaCerveza marca, Vaso vaso) {
        this.marca = marca;
        this.vaso = vaso;
    }

    public void servir() {
        System.out.println("Sirviendo " + vaso.getCentimetrosCubicos() + "cc. de cerveza " + marca);
    }
}

/*
 * Clase pública que prueba todo esto
 */

public class PruebaEnum {
    public static void main(String[] args) {
        BebidaCerveza birra = new BebidaCerveza(BebidaCerveza.MarcaCerveza.AMBAR, Vaso.JARRA);

        birra.servir();
    }
}

Se caracterizan por tener tres cuadrados en las esquinas, que sirven para que los escáneres puedan centrarlos, y la información codificada dibujando píxeles. Es un estándar de código abierto, muy popular en Japón que gracias a los móviles se está empezando a popularizar en nuestro país. Por ejemplo muchas páginas incluyen imágenes con el código QR con URLs de descarga para que con solo enfocar con el móvil se inicie la descarga.

En Android para leerlos podemos usar, entre otras, Barcode Scanner, una herramienta gratuita que se puede encontrar en el Android Market.

A nivel técnico, si queremos programar un lector en Java podemos usar las librerías Zxing disponibles bajo licencia Apache2. Estas librerías nos permiten trabajar con códigos de barras de una (los de toda la vida) y dos dimensiones.

Si lo que queremos es generar una imagen QR con nuestra propia información podemos usar un generador QR online. La imagen que ilustra el artículo por ejemplo es mi tarjeta de visita

Para probar su funcionamiento lanzaremos varios threads que intentarán añadir y borrar elementos al vector de forma simultanea.

Main.java

/*
 * Crear una implementación sincronizada de un vector dinámico
 *
 * Métodos:
 *  - añadir(elemento)
 *  - añadirEn(elemento, posicion)
 *  - borrar(elemento)
 *  - borrar(posicion)
 */
package ejerciciovectordinamico;

/**
 *
 * @author: $Author: franchux $
 * @version: $Rev: 100 $
 * @date: $Date: 2009-04-21 09:38:58 +0200 (mar 21 de abr de 2009) $
 * $Id: Main.java 100 2009-04-21 07:38:58Z franchux $
 */
public class Main
{

    public static final int HILOS = 8;

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args)
    {
        VectorDinamicoSincronizado vector = new VectorDinamicoSincronizado();

        // Este array nos permitirá controlar los hilos que creemos
        //Thread[] manejador = new Thread[HILOS];

        // Creamos los hilos que intentarán modificar posiciones del vector con valores aleatorios
        for (int i = 0; i < HILOS; i++) {
            TestVectorDinamicoRunnable r = new TestVectorDinamicoRunnable(vector);
            Thread t = new Thread(r);
            t.start();
        //manejador[i] = new Thread(r);
        //manejador[i].start();
        }

        // Ahora llenamos el vector para que los hilos que puedan los sobreescriban
        for (int i = 0; i < HILOS; i++) {
            vector.añadir("-");
        }

        // Damos un tiempo para que los hilos intenten hacer su trabajo
        espera(5000);

        // Cerramos los hilos que quedan abiertos
        int numActivas = Thread.activeCount();
        Thread[] manejador = new Thread[numActivas];
        Thread.enumerate(manejador);
        for (Thread t : manejador) {
            if (t.isAlive()) {
                t.interrupt();
            }
        }

        System.out.println(vector);

        System.out.println("Hilo principal terminado");

    }

    public static void espera(int milisegundos)
    {

        long t0, t1;

        t0 = System.currentTimeMillis();
        do {
            t1 = System.currentTimeMillis();
        } while (t1 - t0 < milisegundos);
    }
}

VectorDinamicoSincronizado.java

package ejerciciovectordinamico;

/**
 *
 * @author: $Author: franchux $
 * @version: $Rev: 100 $
 * @date: $Date: 2009-04-21 09:38:58 +0200 (mar 21 de abr de 2009) $
 * $Id: VectorDinamicoSincronizado.java 100 2009-04-21 07:38:58Z franchux $
 */
public class VectorDinamicoSincronizado {

    protected String[] datos;
    final static int TIMEOUT = 1000;

    public VectorDinamicoSincronizado() {
        datos = new String[0];
    }

    /**
     * Añade un número al final de la lista
     *
     * @param numero a insertar
     */
    public void añadir(String texto) {
        //insertarOrdenado(numero);
        String[] nuevo = new String[datos.length + 1];
        for (int i = 0; i < datos.length; i++) {
            nuevo[i] = datos[i];
        }
        nuevo[datos.length] = texto;
        datos = nuevo;
        loguea("pongo " + texto + " al final");
    }

    /**
     * Añade una cadena en una determinada posicion
     *
     * @param texto a añadir
     * @param posicion posición donde colocarlo
     */
    public synchronized void añadirEn(String texto, int posicion) {

        try {  // Si la posición que intentamos insertar está fuera del vector actual
            // Esperamos a ver si hay suerte y el vector crece
            while(posicion > (datos.length - 1)) {
                loguea("no puedo insertar " + texto + " en posicion " + posicion + " espero...");
                wait(TIMEOUT);
            }
            datos[posicion] = texto;
            loguea("pongo " + texto + " en " + posicion);

        } catch (InterruptedException ex) {
            // Logger.getLogger(VectorDinamicoSincronizado.class.getName()).log(Level.SEVERE, null, ex);
            loguea("HILO TERMINADO: no puedo insertar " + texto + " en posicion " + posicion + " abandono");
        }

        notifyAll();
    }

    public synchronized void borrar(int posicion) {
        String [] nueva = new String[datos.length -1];
        int n=0;

        for(int i=0;i<datos.length;i++) {
            if(i!=posicion) {
                nueva[n++] = datos[i];
            }
        }

        datos = nueva;
    }

    /**
     * Muestra por pantalla un mensaje de debug
     *
     * @param texto a mostrar
     */
    public void loguea(String texto) {
        System.out.println(Thread.currentThread().toString() + texto);
    }

    /**
     * Maqueta el contenido
     *
     * @return cadena con todos los numeros del array
     */
    @Override
    public String toString() {
        String cad = "[ ";
        for (String d : datos) {
            cad += "" + d + " ";
        }
        cad += "]";

        return cad;
    }
}

TestVectorDinamicoSincronizadoRunnable.java

package ejerciciovectordinamico;

/**
 *
 * @author: $Author: franchux $
 * @version: $Rev: 99 $
 * @date: $Date: 2009-04-21 00:49:25 +0200 (mar 21 de abr de 2009) $
 * $Id: TestVectorDinamicoRunnable.java 99 2009-04-20 22:49:25Z franchux $
 */
public class TestVectorDinamicoRunnable implements Runnable {

    VectorDinamicoSincronizado vector;

    public TestVectorDinamicoRunnable(VectorDinamicoSincronizado vector) {
        this.vector = vector;
    }

    public void run()
    {
        int num = (int) (Math.random() * 10);
        int pos;
        do {
            pos = (int) (Math.random() * 10) - 1;
        } while(pos < 0);

        vector.añadirEn(""+num, pos);

        //        vector.borrar((int)Math.random());
        System.out.println(Thread.currentThread() + ": " + vector.toString());
    }
}

Implementa las operaciones básicas: sumar, restar, multiplicar y dividir

Main.java

/*
 * Ejercicio: Calculadora sencilla
 *   - Implementar la Interfaz de usuario
 *   - Implementar los métodos siguientes a través de los listeners adecuados:
 *          - Sumar
 *          - Restar
 *          - Multiplicar
 *          - Dividir
 */

package calculadora;

/**
 *
 * @author: $Author: franchux $
 * @version: $Rev: 70 $
 * @date: $Date: 2009-04-13 13:06:00 +0200 (lun 13 de abr de 2009) $
 * $Id: Main.java 70 2009-04-13 11:06:00Z franchux $
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        VentanaCalculadora calculadora = new VentanaCalculadora();
        calculadora.setVisible(true);
    }

}

VentanaCalculadora.java

/*
 * Interfaz para nuestra calculadora sencilla
 */
package calculadora;

import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.*;
import javax.swing.border.EmptyBorder;

/**
 *
 * @author: $Author: franchux $
 * @version: $Rev: 75 $
 * @date: $Date: 2009-04-14 00:21:18 +0200 (mar 14 de abr de 2009) $
 * $Id: VentanaCalculadora.java 75 2009-04-13 22:21:18Z franchux $
 */
public class VentanaCalculadora extends JFrame {

    /** numero tecleado */
    JTextField pantalla;

    /** guarda el resultado de la operacion anterior o el número tecleado */
    double resultado;

    /** para guardar la operacion a realizar */
    String operacion;

    /** Los paneles donde colocaremos los botones */
    JPanel panelNumeros, panelOperaciones;

    /**  Indica si estamos iniciando o no una operación */
    boolean nuevaOperacion = true;

    /**
     * Constructor. Crea los botones y componentes de la calculadora
     */
    public VentanaCalculadora() {
        super();
        setSize(250, 300);
        setTitle("Calculadora Simple");
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        setResizable(false);

        // Vamos a dibujar sobre el panel
        JPanel panel = (JPanel) this.getContentPane();
        panel.setLayout(new BorderLayout());

        pantalla = new JTextField("0", 20);
        pantalla.setBorder(new EmptyBorder(4, 4, 4, 4));
        pantalla.setFont(new Font("Arial", Font.BOLD, 25));
        pantalla.setHorizontalAlignment(JTextField.RIGHT);
        pantalla.setEditable(false);
        pantalla.setBackground(Color.WHITE);
        panel.add("North", pantalla);

        panelNumeros = new JPanel();
        panelNumeros.setLayout(new GridLayout(4, 3));
        panelNumeros.setBorder(new EmptyBorder(4, 4, 4, 4));

        for (int n = 9; n >= 0; n--) {
            nuevoBotonNumerico("" + n);
        }

        nuevoBotonNumerico(".");

        panel.add("Center", panelNumeros);

        panelOperaciones = new JPanel();
        panelOperaciones.setLayout(new GridLayout(6, 1));
        panelOperaciones.setBorder(new EmptyBorder(4, 4, 4, 4));

        nuevoBotonOperacion("+");
        nuevoBotonOperacion("-");
        nuevoBotonOperacion("*");
        nuevoBotonOperacion("/");
        nuevoBotonOperacion("=");
        nuevoBotonOperacion("CE");

        panel.add("East", panelOperaciones);

        validate();
    }

    /**
     * Crea un boton del teclado numérico y enlaza sus eventos con el listener correspondiente
     *
     * @param digito boton a crear
     */
    private void nuevoBotonNumerico(String digito) {
            JButton btn = new JButton();
            btn.setText(digito);
            btn.addMouseListener(
                    new MouseAdapter() {

                        @Override
                        public void mouseReleased(MouseEvent evt) {
                            JButton btn = (JButton) evt.getSource();
                            numeroPulsado(btn.getText());
                        }
                    });

            panelNumeros.add(btn);

    }

    /**
     * Crea un botón de operacion y lo enlaza con sus eventos.
     *
     * @param operacion
     */
    private void nuevoBotonOperacion(String operacion) {
        JButton btn = new JButton(operacion);
        btn.setForeground(Color.RED);

        btn.addMouseListener(
                new MouseAdapter() {

                    @Override
                    public void mouseReleased(MouseEvent evt) {
                        JButton btn = (JButton) evt.getSource();
                        operacionPulsado(btn.getText());
                    }
                });

        panelOperaciones.add(btn);
    }

    /**
     * Gestiona las pulsaciones de teclas numéricas
     *
     * @param digito tecla pulsada
     */
    private void numeroPulsado(String digito) {
        if (pantalla.getText().equals("0") || nuevaOperacion) {
            pantalla.setText(digito);
        } else {
            pantalla.setText(pantalla.getText() + digito);
        }
        nuevaOperacion = false;
    }

    /**
     * Gestiona el gestiona las pulsaciones de teclas de operación
     * @param tecla
     */
    private void operacionPulsado(String tecla) {
        if (tecla.equals("=")) {
            calcularResultado();
        } else if(tecla.equals("CE")) {
            resultado = 0;
            pantalla.setText("");
            nuevaOperacion = true;
        } else {
            operacion = tecla;
            if((resultado > 0) && !nuevaOperacion) {
                calcularResultado();
            } else {
                resultado = new Double(pantalla.getText());
            }
        }

        nuevaOperacion = true;
    }

    /**
     * Calcula el resultado y lo muestra por pantalla
     */
    private void calcularResultado() {
        if (operacion.equals("+")) {
            resultado += new Double(pantalla.getText());
        } else if (operacion.equals("-")) {
            resultado -= new Double(pantalla.getText());
        } else if (operacion.equals("/")) {
            resultado /= new Double(pantalla.getText());
        } else if (operacion.equals("*")) {
            resultado *= new Double(pantalla.getText());
        }

        pantalla.setText("" + resultado);
        operacion = "";
    }
}