Se trata de una implementación en Java del juego Pong que ha hecho EON hace un tiempo. Como siempre, un excelente ejemplo para todos aquellos estudiantes que estén desarrollando este tipo de aplicaciones. Comentarios y problemas en este post.

Recuerda que puedes colaborar cuando quieras!

Descargar!

El siguiente es un pequeño programa que usando el método getenv de la clase System, devuelve información del sistema operativo y de las variables de entorno. La salida del mismo es algo como esto:

El código...

Leer el resto de la entrada...

Se trata del mítico juego de invaders, colaboración de mi amigo E0N, programado en Java. Como pueden ver es bastante básico, y por eso mismo lo pongo aquí: hay bastantes estudiantes que me piden este tipo de ejemplos, y entre más sencillos sean mejor entenderán el código y aprenderán de una manera más amena. Así que de aquí puedes aprender lo básico para crear tus propios juegos, y entender como se manejan los sprites.

Descargar

Se trata de una implementación chichi del famoso Juego de la Vida en Java, ya que Burnhack me ha picado con el gusanillo de la curiosidad En fin... el programa simula un espacio de células que cumplen con las reglas básicas del juego, permite dibujar nuevos patrones, generar granjas aleatorias, y poner en marcha automática o manualmente. De paso me sirvió para explicarle a mis hermanos el porqué del emblema hacker

Puedo decir que me divertí mucho programando, y que a la vez me da pena no haber podido dedicarle más de tres días: el resultado es un programa que funciona bien cuando se ejecuta de manera normalita, pero con la opción de zoom hay problemas. Y aquí les doy un par de consejos: puesto que al principio el programa lo iba a hacer junto con Burnhack, utilicé una clase que él utilizaba llamada BufferedImage (para dibujar las figuras). Luego, cuando me dí cuenta de que no entendía ni mierda nada del código de mi amigo, decidí hacer la lógica desde cero; y aquí van los consejos:

• Hacer comentarios es SUPREMAMENTE IMPORTANTE, sobre todo cuando se programa en grupo
• Cuando hagas este tipo de proyectos es mejor que uses Canvas; yo caí en cuenta muy tarde y ya me da flojera arreglarlo

Por supuesto, el programa está disponible para que lo estudien, lo copien, lo regalen, etc. Espero le sirva a alguien. Les quedo debiendo la explicación porqué es algo largo

Nota: los iconos los he tomado de Icojoy

Compilación y ejecución...

#compilación
javac Glider.java
#ejecución normal
java Glider
#ejecución con la característica zoom (umm, que mal programador soy )
java Glider --zoom

Descargar código fuente

En este artículo utilizaré un pequeño ejemplo para explicar cómo manipular documentos XML usando XERCES Java Parser. En este primer ejemplo usaré el API DOM, y la utilizaremos para generar un archivo XML y guardarlo en disco, y posteriormente procesaremos (parsearemos) dicho archivo para leer su información.

Nota: Sino tienes claro qué es un parser XML, qué es un API XML para Java y cuáles están disponibles, o aún tienes algunas dudas en relación con Java y XML, puedes/debes leer este pequeño artículo.

Generación de archivos XML usando Xerces

En esta ocasión utilizaremos el API DOM para generar un archivo XML, que guardará información acerca de un listado de descargas ficticio. Como resultado, nuestra aplicación generará el siguiente documento XML:

<?xml version="1.0" encoding="ISO-8859-1"?>
<Descargas>
    <descarga id="1">
        <titulo>Libros Java</titulo>
        <ruta>http://casidiablo.net/libros.zip</ruta>
        <hits>2546</hits>
    </descarga>
    <descarga id="2">
        <titulo>Libros C Sharp</titulo>
        <ruta>http://casidiablo.net/libroscs.zip</ruta>
        <hits>1654</hits>
    </descarga>
</Descargas>

En el cual tenemos un elemento llamado descarga que contiene un atributo llamado id; además posee tres nodos hijos: titulo, ruta y hits. Teniendo en cuenta esto crearemos un pequeño bean (clase Descargas.java), que contiene dichos datos:

public class Descargas {
    //Variables
    private int id;
    private String titulo;
    private String ruta;
    private int hits;
    //Constructor de la clase
    public Descargas(int id, String titulo, String ruta, int hits){
        this.id = id;
        this.titulo = titulo;
        this.ruta = ruta;
        this.hits = hits;
    }
    //Metodos Setters y Getters
    public void setID(int id) {
        this.id = id;
    }
    public int getID() {
        return this.id;
    }
    //etc... (AL FINAL DEL ARTÍCULO PUEDES DESCARGAR EL EJEMPLO COMPLETO)
}

Más adelante utilizaremos la clase GenerarXML.java, quien se encargará de crear el archivo XML. De momento detallaremos los pasos básicos para realizar tareas de ese tipo:

• Crear los objetos a cargar en el documento XML (en nuestro ejemplo, objetos tipo Descargas)
• Crear un objeto Document que contendrá el documento XML
• Generar los datos XML para los objetos creados en primer paso
• Crear un archivo (o salida) XML

En nuestro ejemplo, la invocación a los métodos que realizan estas tareas se encuentra en el método main:

public static void main(String args[])
{
   GenerarXML generador = new GenerarXML();
   // A. Crear el objeto(s) a Descargas
   Descargas descarga = new Descargas(1, "Libros Java", "http://casidiablo.net/libros.zip", 2546);
   Descargas descarga2 = new Descargas(2, "Libros C Sharp", "http://casidiablo.net/libroscs.zip", 1654);
   // B. Generar un documento XML usando Document
   generador.generaDocumentoXML();
   // C. Generar XML para el/los objeto(s)
   generador.generarDocumentoXMLDescarga(descarga);
   generador.generarDocumentoXMLDescarga(descarga2);
   // D. Obtener el código XML
   String textoXML = generador.obtenerTextoXML();
   generador.guardarDocumentoXML(textoXML);
   System.out.println(textoXML);
}

Veamos con más profundidad cómo funciona el segundo paso (Crear un objeto Document que contendrá el documento XML):

public void generaDocumentoXML() {
    try {
        // 1. Crear objeto DocumentBuilderFactory
        DocumentBuilderFactory dbFactory = DocumentBuilderFactoryImpl.newInstance();
        // 2. A partir del objeto DocumentBuilderFactory crear un objeto DocumentBuilder
        DocumentBuilder docBuilder = dbFactory.newDocumentBuilder();
        // 3. Generar el documento XML
        documentoXML = docBuilder.newDocument();
    } catch (Exception e) {
        System.out.println("Error : " + e);
    }
    // 4. Crear el elemento "descargas"
    descarga = documentoXML.createElement(TAG_DESCARGAS);
    // 5. Agregar al documento principal
    documentoXML.appendChild(descarga);
}

1. Creamos un objeto DocumentBuilderFactory, utilizando la el método newInstance() de la clase DocumentBuilderFactoryImpl.
2. Creamos un objeto DocumentBuilder, con el que crearemos el objeto Document
3. Generamos el documento usando el método newDocument() de DocumentBuilder
4. Se crea el elemento raíz del documento XML y,
5. Se añade dicho elemento al objeto Document

Después de esto, ya tenemos listo nuestro objeto Document en donde crearemos el documento XML. El paso siguiente será alimentar el documento XML con la información de nuestros objetos, lo cual se hace en el método generarDocumentoXMLDescarga:

public void generarDocumentoXMLDescarga(Descargas descargas)
{
    Element elemento;
    Element item;
    // 1. Crear elemento
    elemento = documentoXML.createElement(TAG_DESCARGA);
    // 2. Asignar un atributo
    elemento.setAttribute(TAG_ID, ""+descargas.getID());
    // 3. Aniadir elemento al documento
    descarga.appendChild(elemento);
    // a. Crear item
    item = documentoXML.createElement(TAG_TITULO);
    // b. Asignar un dato al item
    item.appendChild(documentoXML.createTextNode(descargas.getTitulo()));
    // c. Aniadir el item
    elemento.appendChild(item);
    // todos los items se crean sigiuendo el patron a, b, c
    // el código fuente completo se encuentra
    //disponible para su descarga al final de este artículo
}

1. Se crea un elemento (<descarga>)
2. Se asigna un atributo al elemento (<descarga id="xxx">)
3. Se añade el elemento al documento XML; posteriormente tenemos la creación de items, para dicho elemento:
   a. Se crea el item (<titulo></titulo>)
   b. Se asigna un dato al item (<titulo>datos, muchos datos</titulo>)
   c. Se añade el item al elemento (<descarga id="xxx"><titulo>datos, muchos datos</titulo></descarga>)

Para generar una salida del documento XML se utilizamos el método generaTextoXML() el cual devuelve un string que contiene el documento XML:

private String generaTextoXML() {
   StringWriter strWriter = null;
   XMLSerializer seliarizadorXML = null;
   OutputFormat formatoSalida = null;
   try {
      seliarizadorXML = new XMLSerializer();
      strWriter = new StringWriter();
      formatoSalida = new OutputFormat();
      // 1. Establecer el formato
      formatoSalida.setEncoding(XML_ENCODING);
      formatoSalida.setVersion(XML_VERSION);
      formatoSalida.setIndenting(true);
      formatoSalida.setIndent(4);
      // 2. Definir un objeto donde se generara el codigo
      seliarizadorXML.setOutputCharStream(strWriter);
      // 3. Aplicar el formato
      seliarizadorXML.setOutputFormat(formatoSalida);
      // 4. Serializar documento XML
      seliarizadorXML.serialize(documentoXML);
      strWriter.close();
   } catch (IOException ioEx) {
      System.out.println("Error : " + ioEx);
   }
   return strWriter.toString();
}

1. Utilizando un objeto de la clase OutputFormat, se asigna el tipo de codificación y versión del archivo XML, activamos la identación y la ponemos a 4 espacios
2. Un objeto XMLSerializer escribe los datos del documento XML sobre un objeto de flujo de salida, en este caso un objeto StringWriter.
3. Asignamos el tipo de formato que el objeto XMLSerializer generará
4. Generamos el documento XML

El string generado por generaTextoXML() podemos imprimirlo directamente en pantalla, o escribirlo en un archivo como lo hace el método guardarDocumentoXML():

public void guardarDocumentoXML(String texto) {
   try {
      OutputStream fout = new FileOutputStream(NOMBRE_ARCHIVO_XML);
      OutputStream bout = new BufferedOutputStream(fout);
      OutputStreamWriter out = new OutputStreamWriter(bout, JAVA_ENCODING);
      out.write(texto);
      out.flush();
      out.close();
   } catch (UnsupportedEncodingException e) {
   //etc, bla, bla, catchichurri
}

El método guardarDocumentoXML() un objeto FileOutputStream para escribir los datos del documento XML en un archivo (cuyo nombre define la variable NOMBRE_ARCHIVO_XML).

Continúa leyendo la segunda parte, en donde aprenderemos a Parsear archivos XML. Vamos parce!

CódiLa validación de formularios nos permite asegurarnos que los datos que, por ejemplo, un usuario ingrese en un campo de texto sean válidos. Dicha validación puede hacerse una vez que el usuario haya digitado todos los datos, o mientras el usuario los esté digitando.

Para el primer caso, lo mejor es utilizar expresiones regulares usando el método matches() de la clase String (si necesitas un ejemplo, clic aquí).

Para el segundo caso tendremos que manejar los eventos del teclado que se generen sobre determinado control, usando la interfaz KeyAdapter y el método keyReleased. Así, en nuestro código de ejemplo tenemos un JTextField al que le añadimos un Listener que escuchará los eventos del teclado, y verificará si la tecla presionada es un caractér válido (solo letras), de lo contrario lo elimina.

No hay nada especial en el código de ejemplo salvo por un par de líneas:

• Línea 17: se utiliza el método anidado getToolkit().beep(), que hará que el sistema alerte al usuario con un pitido cada vez que un dato erróneo.
• Línea 25: comparamos el char que digite el usuario con el entero 8, que es el código resultado al usar el Backspace (tecla para borrar hacia la izquierda); lo cual permite al usuario borrar caracteres.

Código...

import java.awt.Robot;
import javax.swing.*;
import java.awt.event.*;
public class SoloLetras extends JFrame {
	private JTextField caja = new JTextField();
	public SoloLetras() {
		super("Solo dejo escribir letras");
		caja.addKeyListener(new KeyAdapter() {
			public void keyReleased(KeyEvent e) {
				Character caracter = new Character(e.getKeyChar());
				if (!esValido(caracter)) {
					String texto = "";
					for (int i = 0; i < caja.getText().length(); i++)
						if (esValido(new Character(caja.getText().charAt(i))))
							texto += caja.getText().charAt(i);
					caja.setText(texto);
					getToolkit().beep();
				}
			}
			public boolean esValido(Character caracter)
			{
				char c = caracter.charValue();
				if ( !(Character.isLetter(c) //si es letra
						|| c == ' ' //o un espacio
						|| c == 8 //o backspace
					))
					return false;
				else
					return true;
			}
		});
		getContentPane().add(caja);
		setSize(300, 60);
		setVisible(true);
	}
	public static void main(String args[]) {
		JFrame.setDefaultLookAndFeelDecorated(true);
		SoloLetras ventana = new SoloLetras();
		ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}

Descargar código fuente