Programacion II

Generador de Combinaciones de n, r en Consola en Java

2013-05-03T23:48:00.000-05:00

Generador de Combinaciones de n, r en Java

Gracias a la pregunta de una amiga sobre Matemáticas Discretas, en esta ocasión quiero compartir un poco acerca de la combinatoria enumerativa, la cual estudia los métodos para contar (enumerar) las distintas configuraciones de los elementos de un conjunto que cumpla con ciertos criterios especificados.

Esta fue una de las primeras áreas de la combinatoria en ser desarrollada, y como otras áreas más recientes se estudian sólo en cursos especializados, es común que se haga referencia a esta subárea cuando se menciona combinatoria en entornos educativos.

Un ejemplo citado de Wikipedia para facilitar la comprensión de este artículo es el siguiente:

Considérese el conjunto S = {A, E, I, O, U}. Podemos imaginar que estos elementos corresponden a tarjetas dentro de un sombrero.

Un primer problema podría consistir en hallar el número de formas diferentes en que podemos sacar las tarjetas una después de otra (es decir, el número de permutaciones del conjunto). Por ejemplo, dos formas distintas podrían ser: EIAOU o OUAIE.
Después, se puede preguntar por el número de formas en que se puede sacar sólo 3 tarjetas del sombrero (es decir, el número de 3-permutaciones del conjunto). En este caso, ejemplos pueden ser IOU, AEI o EAI.
También se puede preguntar sobre cuáles son los posibles grupos de 3 tarjetas que se pueden extraer, sin dar consideración al orden en que salen (en otras palabras, el valor de un coeficiente binomial). Aquí, consideraríamos AOU y UAO como un mismo resultado.
Otro problema consiste en hallar el número de formas en que pueden salir 5 tarjetas, una tras otra, pero en cada momento se regresa la tarjeta escogida al sombrero. En este problema los resultados posibles podrían ser EIOUO, IAOEU o IEAEE.

Luego de esta explicación teórica procedamos a trabajar con el código, la siguiente función genera las combinaciones utilizando un algoritmo de Kenneth H. Rosen.

//La función recibe los valores de n y r como argumentos

public static void combinaciones(int n, int r)

{

int i = 0, j = 0, ci = 0;

int v[] = new int[n];

for(i = 0; i < n; i++)

{ v[i]=i; }

escribe(v, r);

ci++;

while(ci < p1)

{

i = r - 1;

while (v[i] == n - r + i) { i--; }

v[i] = v[i] + 1;

for (j = i + 1; j < r; j++) { v[j] = v[i] + j - i; }

escribe(v,r);

ci++;

}

La función de nombre "escribe" que es llamada en el código anterior nos sirve para imprimir los resultados en la consola del IDE, para descargar una copia completa del Programa funcionando procede a la JavaBox al final del Blog.

Eventos en Swing

2013-04-03T00:16:00.000-05:00

Eventos en Java Swing

En Java Swing, cada vez que el usuario interactúa con la aplicación se gatilla un evento, para que una componente determinada reaccione frente a un evento, debe poseer un "escuchador" (Listener) con, al menos, un método determinado que se ejecutará al escuchar un evento en particular, por ejemplo, en el siguiente código se crea un botón que al ser presionado imprime en la salida estándar un mensaje.


JButton boton=new JButton("Un botón");

boton.addActionListener(new ActionListener()
{

public void actionPerformed(ActionEvent e)
    {
System.out.println("Apretó el Botón");
    }


}

Swing puede utilizar una variedad set de eventos, en la siguiente tabla se resumen los más comunes con sus respectivos "escuchadores".

Ejemplos de eventos y sus escuchadores

Acción que activa un evento Tipo de escuchador

El usario hace un click, presiona Return
en un área de texto o selecciona un menú ActionListener(Acciones Sobre Componentes)

El usuario escoje un frame (ventana principal) WindowListener

El usuario hace un click sobre una componente MouseListener

El usuario pasa el mouse sobre una componente MouseMotionListener

Una componente se hace visible ComponentListener

Una componente adquiere el foco del teclado FocusListener

Cambia la selección en una lista o tabla ListSelectionListener

Si tienen cualquier duda, pueden comunicarse a través de los comentarios. =)

Instalar Oracle Java 7 en Ubuntu 12.04

2013-03-03T22:00:00.000-05:00

Instalar Oracle Java 7 en Ubuntu 12.04

Algo que me pareció importante compartir es como podemos tener instalado el Oracla Java 7 en una distribución de GNU/Linux, para este ejemplo se utilizará Ubuntu 12.04, ya que normalmente las distribuciones como esta utiliza el OpenJDK, pero, y si deseo la versión de Oracle, qué hago, cómo lo instalo, está en los repositorios oficiales, es tal vez un archivo *.deb que se puede instalar fácilmente?, todas estas dudas surgieron en algunos compañeros cuando hicimos unos proyectos y para beneficio de todos, la respuesta será publicada en este post.

OpenJDK y el plugin IcedTea son mantenidos por la Comunidad y reciben actualizaciones periódicas. funciona bien para la mayoría de los propósitos,

Lo más probable es que no necesitemos Oracle Java en absoluto, pero podemos vernos en la necesidad de instalarlo por X razón y esto es un problema, ya que fue retirado de los repositorios "Partner" por la revocación de la anterior licencia.

Explicaré un poco más de OpenJDK, ya que hay cierta confusión con los tipos de paquetes y sus siglas JRE y JDK y de paso nos servirá para tener las cosas claras en la instalación de Oracle Java, incluso puedes ampliar sobre este tema en una publicación anterior de mi blog:

En los repositorios oficiales de Ubuntu tenemos 2 versiones de Java, la 6 y la 7, además del plugin "icedtea":

Y aquí es donde se produce la confusión, ya que cada versión dispone de 2 paquetes: JRE & JDK

Para la versión 6 tenemos 2 paquetes: "openjdk-6-jre" y "openjdk-6-jdk"
Para la versión 7 tenemos 2 paquetes: "openjdk-7-jre" y "openjdk-7-jdk"

Para un mejor entendimiento, especifico los distintos paquetes de Java:

JDK(Java Development Kit)->Kit de desarrollo Java, esta es la versión para los desarrolladores. Incluye el compilador de Java (javac) que mencioné como usar en entradas anteriores, JRE y JVM.
JRE(Java Runtime Environment)->Entorno de ejecución Java, esta es la versión para los usuarios normales que solo quieren poder ejecutar aplicaciones Java en su equipo, posee un conjunto de utilidades de Java, que actúa como un "intermediario" entre el sistema operativo y Java., también incluye la JVM.
JVM(Java Virtual Machine)->Máquina Virtual de Java, es un Programa que ejecuta el código Java previamente compilado (bytecode) mientras que las librerías de clase estándar son las que implementan el API de Java. Ambas JVM y API deben ser consistentes entre sí, de ahí que sean distribuidas de modo conjunto.

La mayoría de los usuarios solo deben de instalar la JRE, y los desarrolladores deberán instalar la JDK, asegurándose de tener la misma versión de java y javac, también se listan a continuación algunos comandos que pueden ser muy útiles para controlar Java:

Mostrar la versión del entorno de Java "Runtime" (JRE):

java -version

Mostrar la versión del compilador de Java "Javac" (JDK):

javac -version

Permite seleccionar la versión de Java Runtime (JRE), si tenemos varias (no del compilador "javac")

sudo /usr/sbin/update-alternatives --config java

Terminada la explicación de OpenJDK vamos a empezar con la Instalación de Oracle Java:

Añadimos los repositorios con:

sudo add-apt-repository ppa:webupd8team/java

Luego los actualizamos con:

sudo apt-get update

Con este comando instalamos Oracle Java 7:

sudo apt-get install oracle-java7-installer

Para comprobar que la instalación ha tenido éxito, ejecuta en una terminal el comando para saber la versión de Java que utiliza tu Ubuntu:

java -version

La terminal te debe devolver algo parecido a esto (el último número de la versión (_12), puede variar):

java version "1.7.0_12"

Java(TM) SE Runtime Environment (build 1.7.0_04-b20)

Java HotSpot(TM) Server VM (build 23.0-b21, mixed mode)

Si tienes otro Java instalado puede ser que te responda con esa versión, para seleccionar la versión de Oracle Java, ejecuta:

sudo update-alternatives --config java

Y seleccionas la opción que necesites, Si no funciona, puedes desinstalarlo con:

sudo apt-get remove oracle-java7-installer

Y quitar los repositorios con estos 2 comandos:

sudo apt-get install ppa-purge

sudo ppa-purge ppa:webupd8team/java

En caso de que el método anterior no te haya funcionado, también podemos hacerlo de forma manual, para lo cual debemos seguir los siguientes pasos, empieza por descargar el Oracle Java desde su sitio Oficial, puede ser el JDK o JRE, abajo está la forma de instalar ambos.

Instalación de JRE para Usuarios Finales

Una vez seleccionada la página de descarga de JRE, activamos la casilla para aceptar la licencia y seleccionamos el paquete para Linux ".tar.gz" de 32 bits "jre-[version]-linux-i586.tar.gz" o 64 bits "jre-[version]-linux-x64.tar.gz", según sea la arquitectura de nuestro Ubuntu. En este ejemplo voy a instalar: jre-7u12-linux-x64.tar.gz (versión 7u12 para 64 bits)

El número de versión "[versión]" puede variar dependiendo del momento en que leas el post.

Los comandos a continuación deben de ser modificados con el nombre del archivo exacto que tú te hayas descargado, ya que puede variar la versión y la arquitectura.

Una vez descargado en nuestra carpeta personal (es decir en "/home/miUsuario/", no en la carpeta Descargas), lo descomprimimos con el comando:

tar -xvf jre-7u12-linux-x64.tar.gz

Si no lo tenemos, creamos un directorio "/jvm/jdk1.7.0" en "/usr/lib", donde moveremos la carpeta descomprimida:

sudo mkdir -p /usr/lib/jvm/jre1.7.0

Movemos la carpeta descomprimida al directorio creado:

sudo mv jre1.7.0_12/* /usr/lib/jvm/jre1.7.0/

Ejecutamos el siguiente comando para java:

sudo update-alternatives --install /usr/bin/java java /usr/lib/jvm/jre1.7.0/bin/java 0

Si hemos instalado OpenJDK u otras versiones de Java (la 6), debemos decirle al sistema que utilice jdk1.7.0 de Oracle con el comando:

sudo update-alternatives --config java

La terminal nos responderá algo similar a esto:

Hay 3 opciones para la alternativa java (proporcionando /usr/bin/java).

Selección Ruta Prioridad Estado

------------------------------------------------------------

0 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 modo automático

1 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 modo manual

2 /usr/lib/jvm/java-6-sun/jre/bin/java 63 modo manual

* 3 /usr/lib/jvm/jre1.7.0/jre/bin/java 12 modo manual

Presione Entrar para mantener la opción actual [*], o escriba el número de la selección:

Seleccionamos la opción que contenga "jre1.7.0". En el ejemplo es la opción 3, escribimos 3 y presionamos Enter.

Instalar el plugin, para el navegador Mozilla Firefox:

En primer lugar, debemos de eliminar anteriores plugin de Java:

rm -f ~/.mozilla/plugins/libnpjp2.so ~/.mozilla/plugins/libjavaplugin_oji.so

sudo rm -f /usr/lib/firefox/plugins/libnpjp2.so /usr/lib/firefox/plugins/libjavaplugin_oji.so

Creamos el directorio para los plugins, si no lo tenemos:

mkdir -p ~/.mozilla/plugins

Ahora, vamos a crear un enlace simbólico para el nuevo Java en el directorio de plugins de Mozilla:

- Para 64 bit:

ln -s /usr/lib/jvm/jdk1.7.0/jre/lib/amd64/libnpjp2.so ~/.mozilla/plugins/

- Para 32 bit, sería:

ln -s /usr/lib/jvm/jre1.7.0/lib/i386/libnpjp2.so ~/.mozilla/plugins/

Instalación de JDK para Desarrolladores

Una vez seleccionada la página de descarga de JDK, activamos la casilla para aceptar la licencia y seleccionamos el paquete para Linux ".tar.gz" de 32 bits "jdk-[version]-linux-i586.tar.gz" o 64 bits "jdk-[version]-linux-x64.tar.gz", según sea la arquitectura de nuestro Ubuntu. En este ejemplo voy a instalar: jdk-7u12-linux-x64.tar.gz (versión 7u12 para 64 bits)

El número de versión "[versión]" puede variar de acuerdo al tiempo en que leas este post.

Los comandos a continuación deben de ser modificados con el nombre del archivo exacto que tú te hayas descargado, ya que puede variar la versión y la arquitectura.

Una vez descargado en nuestra carpeta personal (es decir "/home/miUsuario/", no en la carpeta Descargas), lo descomprimimos con el comando:

tar -xvf jdk-7u12-linux-x64.tar.gz

Si no lo tenemos, creamos un directorio "/jvm/jdk1.7.0" en "/usr/lib", donde moveremos la carpeta descomprimida:

sudo mkdir -p /usr/lib/jvm/jdk1.7.0

Movemos la carpeta descomprimida al directorio creado:

sudo mv jdk1.7.0_12/* /usr/lib/jvm/jdk1.7.0/

Ejecutamos los siguientes comandos para java, javac (compilador) y javaws, respectivamente:

sudo update-alternatives --install "/usr/bin/java" "java" "/usr/lib/jvm/jdk1.7.0/bin/java" 1

sudo update-alternatives --install "/usr/bin/javac" "javac" "/usr/lib/jvm/jdk1.7.0/bin/javac" 1

sudo update-alternatives --install "/usr/bin/javaws" "javaws" "/usr/lib/jvm/jdk1.7.0/bin/javaws" 1

Si hemos instalado OpenJDK u otras versiones de Java (la 6), debemos decirle al sistema que utilice jdk1.7.0 de Oracle con el comando:

sudo update-alternatives --config java

La terminal nos dará como resultado algo similar a esto:

Hay 3 opciones para la alternativa java (proporcionando /usr/bin/java).

Selección Ruta Prioridad Estado

------------------------------------------------------------

0 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 modo automático

1 /usr/lib/jvm/java-6-openjdk/jre/bin/java 1061 modo manual

2 /usr/lib/jvm/java-6-sun/jre/bin/java 63 modo manual

* 3 /usr/lib/jvm/jdk1.7.0/jre/bin/java 12 modo manual

Presione Entrar para mantener la opción actual [*], o escriba el número de la selección:

Seleccionamos la opción que contenga "jdk1.7.0". En este caso como es la 3, escribimos 3 y pulsamos Enter.

Instalar el plugin, para el navegador Mozilla Firefox:

En primer lugar, debemos de eliminar anteriores plugin de Java:

rm -f ~/.mozilla/plugins/libnpjp2.so ~/.mozilla/plugins/libjavaplugin_oji.so

sudo rm -f /usr/lib/firefox/plugins/libnpjp2.so /usr/lib/firefox/plugins/libjavaplugin_oji.so

Creamos el directorio para los plugins, si no lo tenemos:

mkdir -p ~/.mozilla/plugins

Ahora, vamos a crear un enlace simbólico para el nuevo Java en el directorio de plugins de Mozilla:

- Para 64 bit:

ln -s /usr/lib/jvm/jdk1.7.0/jre/lib/amd64/libnpjp2.so ~/.mozilla/plugins/

- Para 32 bit, sería:

ln -s /usr/lib/jvm/jdk1.7.0/jre/lib/i386/libnpjp2.so ~/.mozilla/plugins/

Y para finalizar podemos verificar la instalación desde la página de Oracle:

http://www.java.com/es/download/installed.jsp

Cómo Crear un Jar con Java desde la Consola (cmd) en Windows (Todas las Versiones)

2013-02-03T23:16:00.000-05:00

Cómo Crear un Jar con Java desde la Consola (cmd) en Windows (Todas las Versiones)

Esta publicación es una continuación de la Entrada "Cómo Ejecutar Java desde la Consola (cmd) en Windows (Todas las Versiones)", hoy veremos como crear un archivo con extensión Jar a partir de la línea de comandos, es decir sin depender de los IDEs más conocidos como Netbeans o Eclipse.

Para crear los archivos .jar debemos primero crear un Archivo de Manifiesto en el cual se deberá poner el nombre de la clase que contenga el método main, este archivo en Windows puede ser creado a partir del Bloc de Notas, entonces abrimos el Notepad (Bloc de Notas) y escribimos lo siguiente:

Main-Class: HolaMundo

Sealed: true

*Nótese que no se agrega el .class y que la palabra MAIN-CLASS: es obligatoria.

Donde HolaMundo es el Nombre de la Clase que tiene mi método main, una vez escrito eso lo guardamos con el siguiente nombre en el mismo lugar donde tenemos nuestros archivos .java y .class:

temp.mf

Ahora que tenemos todo listo para construir el .jar vamos a la línea de comandos (CMD) y ejecutamos la siguiente sentencia:

jar -cf HolaMundo.jar HolaMundo.class

Después de haber ejecutado la sentencia anterior ya tendremos el archivo HolaMundo.jar en nuestro directorio, y contendrá el fichero de manifiesto, la clase o clases que tenga nuestro proyecto, ahora al archivo .jar que tenemos, vamos a modificarlo para indicarle que archivo de manifiesto debe usar, esto con la siguiente sentencia:

jar cmf temp.mf HolaMundo.jar HolaMundo.class

Se permiten comodines (por ejemplo, para incluir todos los archivos class de la carpeta o que cumplan con alguna condición dada):

jar cmf temp.mf HolaMundo.jar fichero$.class
jar cmf temp.mf HolaMundo.jar *.class

Y finalmente ejecutamos nuestro archivo en la línea de comandos con la siguiente llamada:

java -jar HolaMundo.jar

Les adjunto una captura de todos los pasos antes mencionados al final del post, para que tengan una mejor idea del Proceso llevado a cabo, les recuerdo que solo empezamos con los archivos:

HolaMundo.java
temp.mf

Y a partir de la ejecución de los comandos terminamos con los siguientes archivos:

HolaMundo.java
temp.mf
HolaMundo.class
HolaMundo.jar

Cualquier duda la pueden hacer en los comentarios.

Crear un Jar desde la Consola (CMD)

Cómo Compilar y Ejecutar archivos Java desde la Consola (cmd) en Windows (Todas las Versiones)

2013-01-15T21:33:00.000-05:00

Cómo Compilar y Ejecutar archivos Java desde la Consola (cmd) en Windows (Todas las Versiones)

Buenas noches a todos, en este post les voy a compartir como podemos compilar y ejecutar archivos de java desde la Consola de Windows (cmd o símbolo del sistema), esto sirve para todas las ediciones de Windows (probado desde Windows XP hasta Windows 8).

Lo primero que debes hacer es tener le última versión estable del JDK, la cual te puedes bajar del sitio web oficial:

Java SE Development Kit 7 Downloads

Una vez que lo hayas bajado e instalado correctamente, procede a buscar la ruta de instalación por ejemplo:

1 | C:\Program Files\Java\jdk1.7.0_02\bin

Esa dirección es la ruta que tendremos que agregar a la variable de entorno Path, para ello debemos ir a:

Mi PC -> Click derecho -> Propiedades -> [Pestaña] Opciones Avanzadas -> Variables de Entorno

Equipo -> Click derecho -> Propiedades -> Configuración Avanzada del Sistema -> [Pestaña] Opciones Avanzadas -> Variables de Entorno

Buscamos en el cuadro mostrado la variable de nombre Path, presionamos Editar, en el cuadro mostrado, nos vamos hasta el final del texto que ya está escrito y agregamos lo siguiente sin las comillas:

";C:\Program Files\Java\jdk1.7.0_02\bin;"

Quedando algo similar a lo mostrado en la siguiente imagen:

Editando la Variable de Entorno Path, para agregar Java (Windows 7)

Una vez que hayamos añadido la ruta, presionamos OK, luego nuevamente OK e iniciamos una consola (cmd) y escribimos javac, nos debería salir algo así:

Ejecución de Javac desde el CMD (Windows 8)

Si te salió algo similar a la imagen superior es que el proceso se realizó correctamente y que Java está bien instalado y configurado en tu computador, como simple prueba de concepto vamos a crear un Hola Mundo.

Abrimos el Bloc de Notas (Como saben, no se requiere de un IDE al 100% para programar en Java), y escribimos el siguiente código:

1

2

3

4

5

6

7

class HolaMundo

{

 public static void main(String[] args)

 {

  System.out.println("Hola Mundo!");

 }

}

Luego guardamos el archivo con el nombre "HolaMundo.java", en mi caso lo guardé en la raíz del disco duro, es decir en: "C:\HolaMundo.java", para compilarlo ejecutamos la siguiente sentencia:

javac HolaMundo.java

Esto nos genera un archivo HolaMundo.class, y para ejecutar el código compilado en la Consola escribimos:

java HolaMundo

Muy importante, no se coloca la extensión del archivo (es decir el .class)

En la siguiente entrada publicaré como crear a partir de lo que tenemos hasta ahora un archivo.jar y así mismo como ejecutarlos desde la línea de comandos.

Cifrado de DES en Java

2012-12-12T18:44:00.000-05:00

Cifrado de DES en Java

En esta ocasión les comparto la implementación del Cifrado DES (Data Encryption Standard) realizado en Java, si no lo conocen en detalle o nunca escucharon de él como siempre veremos un resumen en la parte inferior, pero si quieren adentrar mucho más en el tema pueden acceder aquí.

"Data Encryption Standard (DES) es un algoritmo de cifrado, es decir, un método para cifrar información, escogido como un estándar FIPS en los Estados Unidos en 1976, y cuyo uso se ha propagado ampliamente por todo el mundo. Posteriormente DES fue sometido a un intenso análisis académico y motivó el concepto moderno del cifrado por bloques y su criptoanálisis.

Hoy en día, DES se considera inseguro para muchas aplicaciones. Esto se debe principalmente a que el tamaño de clave de 56 bits es corto; las claves de DES se han roto en menos de 24 horas. Existen también resultados analíticos que demuestran debilidades teóricas en su cifrado, aunque son inviables en la práctica. Se cree que el algoritmo es seguro en la práctica en su variante de Triple DES, aunque existan ataques teóricos.

Desde hace algunos años, el algoritmo ha sido sustituido por el nuevo AES (Advanced Encryption Standard).

En algunas ocasiones, DES es denominado también DEA (Data Encryption Algorithm)."

Si desean profundizar en Seguridad Informática, especificamente en Aplicaciones Web les recomiendo que visiten las siguientes páginas y se suscriban:

En esta Comunidad se suelen dar cursos y capacitaciones en áreas como Software Libre, GNU/Linux y Seguridad Informática y Ethical Hacking, incluso personas que residan en Ecuador pueden participar activamente de forma presencial.

Volviendo al tema, este es uno de los primeros algoritmos que se podría considerar ya de nivel complejo para analizar su funcionamiento y de como se aplican las rondas, a continuación se adjunta una imagen con la estructura básica de este algoritmo de cifrado:

Estructura Básica de DES

Ahora cómo funcionaría esto en código Java?

El procedimiento básico a seguir sería:

1. Generar una clave DES aleatoria. (Usamos KeyGenerator)

2. Cifrar con DES nuestro mensaje (Ingresado por Consola o archivo), Usaremos DES/ECB/PKCS5Padding

3. Descifrar con DES nuestro mensaje (Desde un archivo o por Consola), Acá es el procedimiento inverso, no cambia nada más.

Ahora les incluyo parte del código de la función que utilizaremos para cifrar:

cifrador.init(Cipher.ENCRYPT_MODE, clave);

byte[] buffer = new byte[1000];

byte[] bufferCifrado;

FileInputStream in = new FileInputStream(args[0]);

FileOutputStream out = new FileOutputStream(args[0]+".cifrado");

int bytesLeidos = in.read(buffer, 0, 1000);

while (bytesLeidos != -1)

{

bufferCifrado = cifrador.update(buffer, 0, bytesLeidos);

out.write(bufferCifrado);

bytesLeidos = in.read(buffer, 0, 1000);

}

bufferCifrado = cifrador.doFinal();

out.write(bufferCifrado);

in.close();

out.close();

Y finalmente el código de la función inversa que descifra nuestro mensaje:

cifrador.init(Cipher.DECRYPT_MODE, clave);

in = new FileInputStream(args[0]+".cifrado");

out = new FileOutputStream(args[0]+".descifrado");

byte[] bufferPlano;

bytesLeidos = in.read(buffer, 0, 1000);

while (bytesLeidos != -1)

{

bufferPlano = cifrador.update(buffer, 0, bytesLeidos);

out.write(bufferPlano);

bytesLeidos = in.read(buffer, 0, 1000);

}

bufferPlano = cifrador.doFinal();

out.write(bufferPlano);

in.close();

out.close();

Como siempre la solución completa se encuentra al final del blog en la Java Box, si tienen preguntas o inquietudes sobre el programa y su funcionamiento no duden en comentarlo.

Forma de Uso:

Una vez compilado el archivo.jar procedemos a abrir un cmd (Terminal en GNU/Linux) y ejecutamos así:

java -jar DES_Cipher.jar mensajeACifrar.txt

La salida en consola deberá ser similar al algoritmo que planteamos en la parte superior, se adjunta una captura:

Cómo pueden observar la llave es generada desde el programa de forma aleatoria, en el ejemplo utilice un archivo de entrada y obtuve los siguientes archivos finales con su respectivo contenido:

mensajeACifrar.txt

Hola Mundo desde Java con DES! =)

mensajeACifrar.txt.cifrado

»§õžê _ Ì

øÂñÀ¡ ê 4²YÃCR u×üôûšëØ‚qì98

mensajeACifrar.txt.descifrado

Hola Mundo desde Java con DES! =)

Cifrado de Vigenère en Java

2012-11-08T00:17:00.002-05:00

Cifrado de Vigenère en Java

Siguiendo con la serie de programas de criptografía realizados en Java, ahora veremos el Cifrado Vigenère si no lo conocen o no han profundizado en el tema, a continuación un breve resumen:

"El cifrado Vigenère es un cifrado basado en diferentes series de caracteres o letras del cifrado César formando estos caracteres una tabla, llamada tabla de Vigenère, que se usa como clave. El cifrado de Vigenère es un cifrado de sustitución simple polialfabético.
El cifrado Vigenère se ha reinventado muchas veces. El método original fue descrito por Giovan Battista Belasso en su libro de 1553 La cifra del Sig. Giovan Battista Belasso. Sin embargo, fue incorrectamente atribuido más tarde a Blaise de Vigenère, concretamente en el siglo XIX, y por ello aún se le conoce como el "cifrado Vigenère".
Este cifrado es conocido porque es fácil de entender e implementar, además parece irresoluble; esto le hizo valedor del apodo el código indescifrable (le chiffre indéchiffrable, en francés)."

Si desean profundizar en Seguridad Informática, especificamente en Aplicaciones Web les recomiendo que visiten las siguientes páginas y se suscriban:

Los Sitios pertenecen a la Comunidad de Software Libre y Seguridad Informática [Hackem], y la Escuela Politécnica Nacional (EPN) es actualmente la sede de OWASP (Open Web Application Security Project) del Capítulo Nacional y del Capítulo Universitario de Ecuador gracias a Hackem Research Group, más información en los 2 enlaces antes mencionados.

Pero bueno, ahora entrando en materia, el cifrado Vigenère ganó una gran reputación por ser excepcionalmente robusto. Incluso el escritor y matemático Charles Lutwidge Dodgson (Lewis Carroll) dijo que el cifrado Vigenère era irrompible en el artículo "The Alphabet Cipher" para una revista de niños. En 1917, "Scientific American" describió el cifrado Vigenère como imposible de romper. Esta reputación fue mantenida hasta que el método Kasiski resolvió el cifrado en el siglo XIX y algunos criptoanalistas habilidosos pudieron romper ocasionalmente el cifrado en el siglo XVI.
El cifrado Vigenère es lo suficientemente simple si se usa con discos de cifrado. Los Estados confederados de América, por ejemplo, utilizaron un disco de cifrado para implementar el cifrado Vigenère durante la Guerra Civil Estadounidense. Los mensajes confederados fueron poco secretos, ya que los miembros de la Unión solían descifrar los mensajes.
Gilbert Vernam trató de arreglar el cifrado (creando el cifrado Vernam-Vigenère en 1918), pero no importa lo que hiciera, el cifrado sigue siendo vulnerable al criptoanálisis.

Veamos un ejemplo de un mensaje con una clave y cómo obtenemos el texto cifrado:

mensaje:      P A R I S  V A U T  B I E N
clave:        L O U P L  O U P L  O U P L
criptograma:  A O L X D  J U J E  P C T Y

En este abecedario solo existen 26 letras donde A=0, B=1 , C=2 ... Z=25
En términos matemáticos puede expresarse como:

Donde Xi es el numero de ubicación de la letra, es decir, que P le corresponde al numero 15 en modo horizontal y Zi la L en modo vertical le corresponde al numero 11, y la letra T es el total de números del alfabeto. Entonces la ecuación quedará de la siguiente manera: Yi= (15 + 11) mod 26. El resultado es: 0, donde 0 es igual a A en modo horizontal.
Se observa que a una misma letra en el texto claro le pueden corresponder diferentes letras en el texto cifrado.

En base al ejemplo anterior podemos realizar la siguiente función encargada de Cifrar el mensaje con la clave proporcionada:

for (int ptextIndex = 0; ptextIndex < textoPlano.length(); ptextIndex++)
{
char pChar = textoPlano.charAt(ptextIndex);
int asciiVal = (int) pChar;
if (pChar == ' ')
{
textoCifrado += pChar;
continue;
}
if (asciiVal < 65 || asciiVal > 90)
{
textoCifrado += pChar;
continue;
}

int basicPlainTextValue = ((int) pChar) - 65;

char kChar = llave.charAt(llaveIndex);
int basicLlaveValue = ((int) kChar) - 65;
int tableEntry = tablaVigenere[basicPlainTextValue][basicLlaveValue];
char cChar = (char) (tableEntry + 65);
textoCifrado += cChar;
llaveIndex++;
if (llaveIndex == llave.length())
{
llaveIndex = 0;
}
}

Una vez realizada esta función, para hacer la versión que descifre el texto, solo debemos realizar las operaciones inversas:

for (int ctextIndex = 0; ctextIndex < textoCifrado.length(); ctextIndex++)
{
char cChar = textoCifrado.charAt(ctextIndex);
int asciiVal = (int) cChar;
if (cChar == ' ')
{
textoPlano += cChar;
continue;
}
if (asciiVal < 65 || asciiVal > 90)
{
textoPlano += cChar;
continue;
}

int basictextoCifradoValue = ((int) cChar) - 65;
char kChar = llave.charAt(llaveIndex);
int basicKeyValue = ((int) kChar) - 65;

for (int pIndex = 0; pIndex < TamañoColumnaTabla; pIndex++)
{
if (tablaVigenere[basicKeyValue][pIndex] == basictextoCifradoValue)
{
char potcChar = (char) (tablaVigenere[basicKeyValue][pIndex] + 65);
char potpChar = (char) (pIndex + 65);
textoPlano += potpChar;
}
}
llaveIndex++;
if (llaveIndex == llave.length())
{
llaveIndex = 0;
}
}

Los dos pedazos de código irían dentro de la clase main o también pueden crearlas como funciones independientes, las cuales serían invocadas en el método principal de su programa. Próximamente si les interesa este ejemplo lo subiré al JavaBox.

Y para terminar les adjunto una ejecución del programa tanto para cifrar como para descifrar una cadena de texto:

Cifrando el Mensaje:
Ingresa el Mensaje en Claro (Texto Plano):
Hola Mundo!
Ingresa la Llave: Secreto
El Texto Cifrado es: ZSNR QNBVS!

Descifrando el Mensaje:
Ingresa el Texto Cifrado:
ZSNR QNBVS!
Ingresa la Llave: Secreto
El Mensaje en Claro (Texto Plano) es: Hola Mundo!

Cambiar Versión de JDK en Netbeans

2012-08-20T00:50:00.000-05:00

Cambiar Versión por Defecto del JDK en Netbeans 7.2 (Funciona en 8.2 también)

Para los proyectos de desarrollo en Java normalmente utilizo los IDE's Netbeans o Eclipse de acuerdo a los requerimientos y facilidades que tiene cada uno para determinados escenarios, y recientemente decidí actualizar las versiones de estos, al hacer esto surgió un pequeño inconveniente en Netbeans, el directorio del JDK por defecto que era utilizado por Netbeans era inválido.

Escenario Inicial:

Netbeans 7.0 para 64 bits
JDK 1.6 Update 25 para 64 bits

Procedo a actualizar primero la versión de Netbeans a la última publicada (Netbeans 7.2), al terminar la instalación reviso el estado de los proyectos y todos funcionaban normalmente, luego actualizo el JDK, igual a la última versión disponible (Java Platform (JDK) 7u6), al terminar la instalación intento abrir el IDE Netbeans 7.2 para revisar los proyectos nuevamente, y la sorpresa fue que se mostró un mensaje como el de la imagen adjunta a continuación:

[Directorio Home del JDK Inválido - Netbeans 7.2]

El problema era que como se actualizó primero el Netbeans al momento de su instalación, el IDE reconoció al directorio del JDK antiguo como la versión por defecto a utilizar y como esta fue luego eliminada del equipo es por eso que se mostraba este mensaje, y qué hacemos para solucionarlo?, pues se debe modificar manualmente el archivo de configuración donde esta alojada la ruta del JDK que Netbeans intentará utilizar.

Pasos para solucionar el problema:

1) Buscar el directorio de instalación de Netbeans 7.2, por defecto suele ser:

"C:\Program Files\NetBeans 7.2" --> 64 bits

"C:\Program Files (x86)\NetBeans 7.2" --> 32bits

2) En el directorio anterior buscamos la carpeta que guarda las configuraciones del IDE, de nombre "etc":

"C:\Program Files\NetBeans 7.2\etc" --> 64 bits

"C:\Program Files (x86)\NetBeans 7.2\etc" --> 32bits

3) Abrir el archivo "netbeans.conf", se puede hacerlo con cualquier editor de texto, por ejemplo Notepad.

4) Buscar y editar en el archivo de configuración la variable de nombre "netbeans_jdkhome", la cual contiene el directorio que necesita Netbeans para utilizar el JDK, por ejemplo:

Antes de la edición:

netbeans_jdkhome="C:\Program Files\Java\jdk1.6.0_25"

Después de la edición:

netbeans_jdkhome="C:\Program Files\Java\jdk1.7.0_06"

En Sistemas Operativos superiores a Windows XP, la edición de este archivo se debe hacer con Permisos de Administrador, luego de la edición, guardamos cambios y volvemos a abrir el IDE Netbeans 7.2, y ya no tendremos ningún problema, todo funcionará como antes.

Esta edición se puede realizar en las las versiones 6.XX, 7.XX y 8.XX que he probado, las versiones anteriores pueden contener algún archivo de configuración similar, o puede que funcione la misma solución de este post.

Adicionalmente esta modificación nos puede servir para utilizar varias versiones del JDK en un mismo equipo e incluso se puede cambiar de 64 bits a 32 bits, en caso de desear verificar si el cambio fue efectivo podemos dirigirnos en Netbeans al menú Herramientasl/Tools --> Plataformas Java/Java Platforms, donde podremos ver la versión del JDK que Netbeans reconoció para trabajar, por ejemplo:

[Plataformas Java - Netbeans]

Cifrado de César en Java

2012-07-14T03:21:00.002-05:00

Cifrado de César en Java

Regresando de un largo descanso ahora quiero compartirles una serie de programas realizados en Java para ciertos fines, voy a empezar con un poco de criptografía, y en específico el cifrado de César, para los que no han escuchado de este, a continuación un breve resumen:

"En criptografía, el cifrado César, también conocido como cifrado por desplazamiento, código de César o desplazamiento de César, es una de las técnicas de codificación más simples y más usadas. Es un tipo de cifrado por sustitución en el que una letra en el texto original es reemplazada por otra letra que se encuentra un número fijo de posiciones más adelante en el alfabeto. Por ejemplo, con un desplazamiento de 3, la A sería sustituida por la D (situada 3 lugares a la derecha de la A ), la B sería reemplazada por la E, etc. Este método debe su nombre a Julio César, que lo usaba para comunicarse con sus generales.

El cifrado César muchas veces puede formar parte de sistemas más complejos de codificación, como el cifrado Vigenère, e incluso tiene aplicación en el sistema ROT13. Como todos los cifrados de sustitución alfabética simple, el cifrado César se descifra con facilidad y en la práctica no ofrece mucha seguridad en la comunicación."

Si desean profundizar en el arte de la criptografía y la seguridad informática les recomiendo que visiten el siguiente sitio:
Hackem Community Website at EPN (Escuela Politécnica Nacional)

El sitio pertenece a la Comunidad de Software Libre y Hackers Éticos de la Facultad de Ingeniería en Sistemas Informáticos y de Computación de la Escuela Politécnica Nacional, la cual es actualmente la sede de OWASP (Open Web Application Security Project) del Capítulo Nacional y del Capítulo Universitario de Ecuador, más información en el enlace superior.

En esta Comunidad se suelen dar cursos y capacitaciones en áreas como Software Libre, GNU/Linux y Seguridad Informática y Ethical Hacking, incluso personas que residan en Ecuador pueden participar activamente de forma presencial.

Pero bueno, ahora entrando en materia, el cifrado de César es llamado de desplazamiento, porque mueve cada letra un determinado número de espacios en el alfabeto, en la imagen inferior se representa de forma gráfica:

Es decir que si nosotros queremos enviar un mensaje con el texto en claro: "Kathy" y utilizamos una llave con un valor de 4, el resultado en texto cifrado (En el Idioma Inglés) sería: "Oexlc" y en Español sería "Ñexlc".

Con el ejemplo anterior podemos ver que solo desplazamos 4 letras a todos los caracteres presentes en la palabra, pudiendo ser aplicado a frases completas también; para tener una referencia, este estas son las equivalencias para una llave con valor de 6 para el Idioma Español:

Texto original:   ABCDEFGHIJKLMNÑOPQRSTUVWXYZ
Texto codificado: GHIJKLMNÑOPQRSTUVWXYZABCDEF

La codificación también se puede representar usando aritmética modular, transformando las letras en números, de acuerdo al esquema A = 0, B = 1,..., Z = 26. La codificación de la letra x con un desplazamiento n puede ser descrita matemáticamente como:

Y la decodificación se hace de manera similar:

La operación de sustitución se conserva siempre a lo largo de todo el mensaje, por lo que el cifrado se clasifica como un cifrado de tipo sustitución monoalfabética, en oposición a la sustitución polialfabética.

El programa que esta vez les comparto es uno sencillo (próximamente uno mejor) donde solo realizamos la función de descifrado a una cadena que podemos mandar en el Main, por lo tanto el código más importante de esta sería:

public String decrypt(int c)
{
int posicion = c + desplazamiento;
if(posicion > array.length - 1)
{
posicion = posicion - array.length;
}
String decod = String.valueOf(array[posicion]);
return decod;
}

Pero ustedes pueden hacer su propia implementación mejorada utilizando algunas entradas explicadas anteriormente, por ejemplo el programa podría leer archivos planos (Lectura de Archivos en Java), podría leer los datos desde teclado (Scanner & InputStreamReader), podría ser en una interfaz gráfica con un Formulario, etc.

Otra función que necesitamos es una que recorra la cadena de caracteres (el mensaje) para poderlo descifrar carácter por carácter:

private void recorrerMensaje()
{
String decod = "";
for(int i = 0; i <= mensaje.length() - 1; i++)
{
caracter = mensaje.substring(i, i + 1);
if(!caracter.equals(" "))
{
int posicion = getPosicionCaracter(caracter);
decod = decrypt(posicion);
clave += decod;
}
else
{
clave += " ";
}
}
}

Eso es lo básico que necesitamos para nuestra implementación, si deseas una copia del código fuente completo para probarlo en tu computador, lo puedes encontrar en la parte inferior del blog, en la Java Box.

La clase se llama CaesarCipher.java, ustedes deberán crear una clase Main donde creamos la instancia del CaesarCipher y mandamos como parámetro el mensaje cifrado, un ejemplo:

Cipher descifrar = new Cipher();
//Desciframos KATHY --> GWPDU
System.out.println(descifrar.descifrarMensaje("GWPDU", 4));

Por cierto en la implementación que se pueden descargar el descifrado utiliza una llave dinámica, para el ejemplo está 4.

Escritura de un Archivo en Java

2011-03-04T18:08:00.001-05:00

Escritura de un Archivo de Texto en Java

Tal y cómo expliqué en la entrada anterior, existen diversas clases y métodos para leer y escribir los datos en un fichero de texto, pero para facilitar las cosas, hoy veremos como utilizar la clase "File Writer", la cual nos permitirá escribir nuestros datos e información en los archivos, esta clase puede recibir 1 o 2 parámetros dependiendo de lo que necesites, el primer parámetro siempre será el nombre del Archivo en donde grabaremos la información y el segundo parámetro que es opcional, es una valor boolean que indicará si sobrescribirá al archivo (borrando todo contenido anterior) o solo agregará la información obtenida al final del archivo ya existente.
Esto es útil en el caso de que el programa que realicemos necesite llevar un registro con fechas o una lista de datos que se van agregando conforme pasa el tiempo, como en una lista de clientes de algún negocio. Bueno, ahora para implementar FileWriter necesitamos también de la clase PrintWriter, la cual es solo utilizada como un buffer en donde se almacenará toda la información que se va a escribir en nuestro archivo, y solo una vez que todo se realizó correctamente, la información se graba en el archivo. Ahora procedemos con el ejemplo:

//Import que administra entrada y salida de datos

import java.io.*;

//Nuevo FileWriter

FileWriter fichero = new FileWriter("c:/archivo.txt");

//Nuevo PrintWriter

PrintWriter pw = new PrintWriter(fichero);

//Escribimos en el Archivo lo deseado

pw.println("Hola Mundo desde un Archivo");

//Cerramos el archivo

fichero.close();

Es aconsejable colocar el código anterior dentro de un try-catch, debido a que en el manejo de archivos existen algunas excepciones tales como:

Archivo No Encontrado
Acceso al Archivo Denegado (tanto en lectura y escritura)
Cadena de Texto no encontrada, y otras más.

Lectura de un Archivo en Java

2011-03-04T15:54:00.011-05:00

Lectura de un Archivo de Texto en Java

Existen diversas clases y métodos para leer y escribir los datos en un fichero de texto, pero para el día de hoy utilizaremos la clase "File Reader", esta clase tiene métodos que nos permiten leer caracteres, pero no las líneas completas, ahora por qué queremos las líneas completas?, bueno puede ser para analizarla y extraer ciertos campos de nuestro interés y trabajar con estos.
Entonces como la clase File Reader no puede hacer esto, utilizaremos otra clase auxiliar llamada "Buffered Reader", la cual si contiene los métodos que necesitamos para leer las líneas enteras de un fichero. Para utilizar estas clases necesitamos hacer el siguiente import: "java.io.*", el cual se encarga de administrador todas las formas de entrada y salida de datos en un programa. Ahora lo que haremos será implementar la clase File Reader para construir un Buffered Reader, de la siguiente forma:

File arNew = new File ("C:\\archivo.txt");

FileReader fr = new FileReader (arNew);

BufferedReader br = new BufferedReader(fr);

//cad almacenará línea de archivo

String cad = br.readLine();

//Imprimir cad

System.out.println(cad);

Modificadores de Acceso

2011-01-02T05:07:00.003-05:00

Modificadores de Acceso en Java

Los modificadores son elementos del lenguaje que se colocan delante de la definición de variables locales, datos miembro, métodos o clases y que alteran o condicionan el significado del elemento. En entradas anteriores se ha descrito uno, el modificador static que se usa para definir datos miembros o métodos como pertenecientes a una clase, en lugar de pertenecer a una instancia. En entradas futuras se describirán otros modificadores como final, abstract o synchronized. En este capítulo se presentan los modificadores de acceso, que son aquellos que permiten limitar o generalizar el acceso a los componentes de una clase o a la clase en si misma.

Los modificadores de acceso permiten al diseñador de una clase determinar quien accede a los datos y métodos miembros de una clase, estos preceden preceden a la declaración de un elemento de la clase (ya sea dato o método), de la siguiente forma:

[modificadores] tipo_variable nombre; <--> public int numero;

Existen los siguientes modificadores de acceso:

public - Todo el mundo puede acceder al elemento. Si es un dato miembro, todo el mundo puede ver el elemento, es decir, usarlo y asignarlo. Si es un método todo el mundo puede invocarlo.

private - Sólo se puede acceder al elemento desde métodos de la clase, o sólo puede invocarse el método desde otro método de la clase.

protected - Se explicará en el capítulo dedicado a la herencia.

Sin modificador - Se puede acceder al elemento desde cualquier clase del package donde se define la clase.

Pueden utilizarse estos modificadores para cualquier tipo de miembros de la clase, incluidos los constructores (con lo que se puede limitar quien puede crear instancias de la clase).

En el ejemplo los datos miembros de la clase Punto se declaran como private, y se incluyen métodos que devuelven las coordenadas del punto. De esta forma el diseñador de la clase controla el contenido de los datos que representan la clase e independiza la implementación de la interface.

class Punto

{

private int x , y ;

static private int numPuntos = 0;

Punto ( int a , int b )

{

x = a ; y = b;

numPuntos ++ ;

}

int getX()

{

return x;

}

int getY()

{

return y;

}

static int cuantosPuntos()

{

return numPuntos;

}

Si alguien, desde una clase externa a Punto, intenta:

Punto p = new Punto(0,0);

p.x = 5;

Lo que obtendrá será un error del compilador.

Usando Modificadores de Acceso en Clases:

public - Todo el mundo puede usar la clase. Se pueden crear instancias de esa clase, siempre y cuando alguno de sus constructores sea accesible.

sin modificador - La clase puede ser usada e instanciada por clases dentro del package donde se define.

Las clases no pueden declararse ni protected , ni private .

¿Por qué son importantes los modificadores de acceso?

Porque estos permiten al diseñador de clases delimitar la frontera entre lo que es accesible para los usuarios de la clase, lo que es estrictamente privado y 'no importa' a nadie más que al diseñador de la clase e incluso lo que podría llegar a importar a otros diseñadores de clases que quisieran alterar, completar o especializar el comportamiento de la clase.

Con el uso de estos modificadores se consigue uno de los principios básicos de la Programación Orientada a Objetos, que es la encapsulación: Las clases tienen un comportamiento definido para quienes las usan conformado por los elementos que tienen un acceso público, y una implementación oculta formada por los elementos privados, de la que no tienen que preocuparse los usuarios de la clase.

Los otros dos modificadores, protected y el acceso por defecto (package) complementan a los otros dos. El primero es muy importante cuando se utilizan relaciones de herencia entre las clases y el segundo establece relaciones de 'confianza' entre clases afines dentro del mismo package. Así, la pertenencia de las clases a un mismo package es algo más que una clasificación de clases por cuestiones de orden.

Cuando se diseñan clases, es importante pararse a pensar en términos de quien debe tener acceso a que. Qué cosas son parte de la implantación y deberían ocultarse (y en que grado) y que cosas forman parte de la interface y deberían ser públicas.

Lectura de Datos por Consola (System)

2010-11-20T00:52:00.003-05:00

Lectura de Datos por Consola en Java (System)

Para esta ocasión utilizaremos una versión más sencilla que todas las anteriores, y será una función propia del lenguaje Java, así como utilizamos System.out, para imprimir en Pantalla, ahora utilizaremos System.in para ingresar datos en nuestro programa.

Es algo similar a C++ en este caso, para los que recuerden o hayan visto algo de este lenguaje, las sentencias de entrada y salida que utilizaba la librería iostream.h eran cin y cout respectivamente, pero en Java tenemos la ventaja de que no necesitamos de ninguna librería y directamente podremos utilizar ambas propiedades de System (in & out).

Procedimiento y Uso:

El System.in.read() leerá los caracteres y los retornará en valores ASCII ya que los vamos a almacenar en una variable entera.

Definimos una variable de tipo int:

int caracter=0;

Luego colocamos un bucle, el cual debe ser estrictamente finito caso contrario nunca terminaría la operación de lectura., un ejemplo:

while (caracter!=48)

El número 48 representa en código ASCII al Número 0, esto significa que la lectura de datos terminará cuando el usuario ingrese un Cero y y presione Enter, ahora hacemos que el programa lea los datos así:

caracter = System.in.read();

Y listo, esta es la manera más sencilla de una lectura de datos por consola en Java sin usa librerías externas, pero una cosa importante que se debe recordar es controlar en la línea donde está el .read() que siempre haya un Try & Catch para que el Programa no falle en caso de tipos de dato erróneos ingresados.

Lectura de Datos por Consola (Scanner)

2010-11-20T00:21:00.004-05:00

Lectura de Datos por Consola en Java (Scanner)

Ésta es otra forma para leer datos en Java, puede ser más fácil de entender que la que utiliza el InputStreamReader y el BufferedReader, así que para utilizar el Scanner de java necesitamos primero agregar el siguiente import a nuestro programa:

import java.util.Scanner;

También necesitaremos distintas variables, una variable String, una int, y una float en donde almacenaremos el contenido leído:

String cadena="";

int entero;

float flotante;

Creación de un Objeto Tipo Scanner:

Scanner leer = new Scanner(System.in);

Ahora dependiendo del tipo de dato a leer colocamos:

entero = leer.nextInt(); //Lee solo enteros

flotante = leer.nextFloat(); //Lee solo flotantes

cadena = leer.next(); //Lee Strings

Algo que hay que tener cuidado es cuando el usuario ingrese un tipo de dato erróneo, es decir si en la variable entero, le pedimos que ingrese un número entero y este ingresa un caracter, el programa fallaría y se cerraría, o entraría en un bucle infinito; para esa y otras fallas es recomendable utilizar un Try & Catch, aquí la entrada donde detallo el uso de este: Uso de Sentencia Try & Catch

Lectura de Datos por Consola

2010-11-19T23:26:00.004-05:00

Lectura de Datos por Consola en Java

Las entradas y salidas (E/S) en Java utilizan streams conocidos como secuencias o flujos. Un flujo representa una corriente de datos con (al menos) un escritor y un lector. Por ejemplo, cuando leemos del teclado estamos usando una corriente de entrada donde el programa es el lector.

Si deseamos que el usuario ingrese datos (números o cadenas de caracteres) en una consola de Java es necesario utilizar la Clase InputStreamReader, donde utilizaremos el Objeto System.in, este método solo lee bytes, lo que significa que si ingresamos un caracter cualquiera, nos devolverá un número correspondiente a los bytes del caracter ingresado.

Creación de un Objeto de Tipo InputStreamReader:

InputStreamReader leer = new InputStreamReader (System.in);

Con el InputStreamReader leer que creamos podemos utilizar el método .read() para leer los caracteres, pero aún así no es suficiente puesto que necesitamos de otros "puentes" que conviertan el flujo en modo carácter a uno en modo buffer (un tipo de cadena de caracteres). Para ello contamos con clases como BufferedReader que recibe en su constructor el flujo de caracteres y maneja el flujo en la forma de buffer, con un método como .readLine() que lee los caracteres hasta encontrar un final de línea ("\n"). Un ejemplo de estas transformaciones (de flujo de byte a flujo de carácter y de éste a buffer) se encuentra en el manejo de teclado.

Creación de un BufferedReader:

BufferedReader entrada = new BufferedReader(leer);

Y ahora que lo hacemos para leer una línea desde Consola es:

entrada.readLine();

Estos caracteres leídos desde Consola pueden almacenarse en un String para luego retornar el valor así:

String cadena="";

cadena = entrada.readLine();

return cadena;

Obviamente para poder usar el return, el código anterior debe estar dentro de un método que devuelva un dato de tipo String, aunque esta forma no es obligatoria si se utiliza en programas cortos

Uso de RadioButtons en Java

2010-10-11T00:27:00.004-05:00

Utilización de RadioButton

Conocido también como botón de opción o botón de radio es un tipo de widget utilizado en interfaces gráficas de usuario que permite elegir una sola opción de un conjunto predeterminado de estas.

Los botones de opción (botones de radio) se llaman así en referencia a los botones físicos que se usan en los radios para seleccionar estaciones preajustadas - cuando se presionaba uno de los botones, otro de los botones saltaba.

Es posible que, inicialmente, ninguno de los botones de opción en un grupo esté seleccionado. Este estado no puede restaurarse interactuando con el widget del botón de opción (pero es posible a través de otros elementos de la interfaz de usuario).

Un aspecto interesante de los botones de opción, cuando se utilizan en un formulario HTML, es que si no se marca ningún botón en un grupo, entonces no se pasa ningún par nombre-valor cuando se envía el formulario. Por ejemplo, para un grupo de botones de opción llamado Sexo, con las opciones de Masculino y Femenino, la variable Sexo no pasaría, ni siquiera con un valor en blanco.

Este es un ejemplo común de un RadioButton en donde sólo se permitirá seleccionar un elemento de la lista definida previamente por el Programador:

Bueno, ahora vamos al código, veamos que se debe hacer para crear uno de estos.

Imports Utilizados:

import javax.swing.ButtonGroup;
import javax.swing.JRadioButton;

Definir un RadioButton:

JRadioButton rbtn1=new JRadioButton("txt1",true);

JRadioButton rbtn2=new JRadioButton("txt2",false);

JRadioButton rbtn3=new JRadioButton("txt3",false);

Creación del Grupo de Botones:

ButtonGroup grupo1 = new ButtonGroup();
grupo1.add(rbtn1);
grupo1.add(rbtn2);
grupo1.add(rbtn3);

La Clase que se utiliza se llama JRadioButton y donde la clase que nos permite crear un grupo donde "almacenaremos" nuestro botones es la ButtonGroup. Los parámetros que se pasan al momento de crearlo son el Texto que llevará y si estará seleccionado este ítem al momento de ejecutar nuestro programa.

Existen otras formas tanto de colocar el texto en un RadioButton como de configurar si este estará seleccionado por defecto, tales como:

rbtn1.setText("Texto");

rbtn1.setSelected(true);

En el caso de necesitar una validación podríamos hacerlo con un IF:

if(rbtn1.isSelected()==true)

{

System.out.print("Seleccionó opción 1");

}

Ejemplo de Ejecución de un RadioButton en Java:

Nota: Si deseas algún código en especial deja tu petición en algún comentario.

Manejo del Formato de Impresión en Consola

2010-09-19T00:05:00.001-05:00

Alinear Texto en Java

Así como en C++, se puede alinear el texto al momento de imprimir una tabla de datos obtenidos, Java tiene la misma función implementada de una manera mucho más simple y sin la necesidad de importar alguna librería extraña, pudiendo controlar la cantidad de espacios que queremos separar entre cada una de las columnas a imprimir, aquí la instrucción:

System.out.printf("%10s %10s\n", "Hilary", "Standfield");

Aquí un ejemplo de como trabaja la misma función pero en C:

Si deseas descargar un ejemplo de este código funcionando 100% dirígete a la parte inferior del blog, deja algún comentario y Descarga el archivo de mi Java Box, el nombre de archivo para este ejercicio es: "Lista con Formato EPN.java" el cual tiene una lista de estudiantes con Nombre/Apellido, Nota 1, Nota 2, y Promedio, todos alineados correctamente.

Si deseas algún código en especial deja tu petición en algún comentario.

Uso del Formateador Decimal

2010-09-18T16:51:00.001-05:00

Uso de la Clase DecimalFormat

Muchas veces necesitamos imprimir una variable doble que almacenamos o que obtuvimos por medio de algún cálculo matemático, pero nos vemos con el problema de que nos salen unos 20 decimales, así que para solucionar este problema utilizaremos la Clase Decimal Format, primero veamos algunos conceptos acerca de esta clase:

DecimalFormat: Es una clase de Java que nos permite mostrar los números en la pantalla (sea en consola o en un JtextFiled) con un formato deseado, es decir, limitar el número de decimales, si usaremos punto o coma, etc, incluso podemos tomar los valores desde un JTextField y reconstruir el número, ahora el ejemplo:

//import requerido para el Formateador

import java.text.DecimalFormat;

DecimalFormat formateador = new DecimalFormat("####.####");

// Imprime esto con cuatro decimales, es decir: 7,1234

System.out.println (formateador.format (7.12342383));

Si utilizamos ceros en lugar de los #, los dígitos no existentes se rellenarán con ceros, un ejemplo:

DecimalFormat formateador = new DecimalFormat("0000.0000");

// Imprime con 4 cifras enteras y 4 decimales: 0001,8200

System.out.println (formateador.format (1.82));

También podemos utilizar el signo de porcentaje (%) en la máscara y así el número se multiplicará automáticamente por 100 al momento de Imprimir.

DecimalFormat formateador = new DecimalFormat("###.##%");

// Imprime: 68,44%

System.out.println (formateador.format(0.6844));

La clase DecimalFormat usa por defecto el formato para el lenguaje que tengamos instalado en el ordenador. Es decir, si nuestro sistema operativo está en español, se usará la coma para los decimales y el punto para los separadores de miles. Si estamos en inglés, se usará el punto decimal.
Una opción para cambiar esto, es utilizar la clase DecimalFormatSymbols, que vendrá rellena con lo del idioma por defecto, y cambiar en ella el símbolo que nos interese. Por ejemplo, si estamos en español y queremos usar el punto decimal en vez de la coma, podemos hacer lo siguiente:

import java.text.DecimalFormat;

import java.text.DecimalFormatSymbols;

DecimalFormatSymbols simbolos = new DecimalFormatSymbols();

simbolos.setDecimalSeparator('.');

DecimalFormat formateador = new DecimalFormat("####.####",simbolos);

// Imprime: 3.4324

System.out.println (formateador.format (3.43242383));

Reconstruyendo un Número:

Supongamos que leemos algún número desde consola o un JTextField y deseamos reconstruirlo con DecimalFormat, se hace de la siguente forma:

JTextField textField = new JTextField();

DecimalFormat formateador = new DecimalFormat("####.####");

String texto = textField.getText();

try

{

// parse() lanza una ParseException en caso de fallo que hay que capturar.

Number numero = formateador.parse(texto);

double valor = numero.doubleValue();

// Optimizando las Lineas anteriores:

// double valor = formateador.parse(texto).doubleValue();

}

catch (ParseException e)

{

// Error. El usuario ha escrito algo que no se puede convertir a número.

}

Descarga JDK - JRE

2010-09-15T00:00:00.002-05:00

JDK & JRE For Java Developers

El JDK (Java Development Kit), es un paquete para los Desarrolladores de Software, que se debe instalar antes de utilizar cualquier IDE (Integrated Development Environment), tales como Eclipe, o NetBeans, así que sin más a continuación el link Oficial de Oracle:

Oracle JDK - 6u21

En el link podrán encontrar distribuciones del JDK para distintas platarformas y en distintos lenguajes, por cierto el registro es OPCIONAL, ahora vamos con el JRE (Java Runtime Environment), es un paquete muy similar al JDK, pero a diferencia de este no es utilizado por los desarrolladores, el JRE permite la ejecución del código Java en un Computador, mientras que el JDK contiene utilidades y paquetes extras solo para Programadores, aquí los links:

Bibliotecas Gráficas de Java

2010-09-14T23:04:00.001-05:00

Bibliotecas Gráficas de Java

Swing es una biblioteca gráfica de java que contiene interfaces gráficas para el usuario como son barras de menús, botones desplegables y tablas.Las componentes Swing se identifican porque pertenecen al paquete javax.swing.

Swing existe desde la JDK 1.1 (como un agregado). Antes de la existencia de Swing, las interfaces gráficas con el usuario se realizaban a través de AWT (Abstract Window Toolkit), de quien Swing hereda todo el manejo de eventos.

Estructura básica de una aplicación Swing.

Una aplicación Swing se construye mezclando componentes con las siguientes reglas.

* Debe existir, al menos, un contenedor de alto nivel (Top-Level Container), que provee el soporte que las componentes Swing necesitan para el pintado y el manejo de eventos.

* Otras componentes colgando del contenedor de alto nivel (éstas pueden ser contenedores o componentes simples).

Contenedores en Java

2010-09-14T22:59:00.001-05:00

Contenedores en Java

Container es una clase abstracta derivada de Component, que representa a cualquier componente que pueda contener otros componentes.

Una interface gráfica está construida en base a elementos gráficos básicos, los Componentes. Ejemplos de estos Componentes son los botones, barras de desplazamiento, etiquetas, listas, cajas de selección o campos de texto. Los Componentes permiten al usuario interactuar con la aplicación y proporcionar información desde el programa al usuario sobre el estado del programa.

Los Componentes no se encuentran aislados, sino agrupados dentro de Contenedores. Los Contenedores contienen y organizan la situación de los Componentes; además, los Contenedores son en sí mismos Componentes y como tales pueden ser situados dentro de otros Contenedores. También contienen el código necesario para el control de eventos, cambiar la forma del cursor o modificar el icono de la aplicación.

Los Componentes deben circunscribirse dentro del Contenedor que los contiene. Esto hace que el anidamiento de Componentes en Contenedores crean árboles de elementos, comenzando con un Contenedor en la raíz del árbol y expandiéndolo en sus ramas.

Métodos de Ordenamiento

2010-06-17T23:58:00.001-05:00

Los 3 Métodos de Ordenamiento más populares

Hoy les comparto los métodos de ordenamiento de datos más populares que hay, unos más eficientes que otros pero todos conocidos, y de una vez les mostraré un poco de C# para que se den cuenta de la similitud con Java, los ejemplos en código están en ambos lenguajes.

1) Bubble Sort (Ordenamiento Burbuja):

Es el algoritmo de ordenamiento más sencillo de todos, conocido también como método del intercambio directo, el funcionamiento se basa en la revisión de cada elemento de la lista que va a ser ordenada con el elemento siguiente, intercambiando sus posiciones si están en el orden equivocado, para esto se requieren varias revisiones hasta que ya no se necesiten más intercambios, lo que indica que la lista ha sido ordenada.

El origen del nombre de este algoritmo proviene de la forma con la que suben por la lista los elementos durante los intercambios, tal y como si fueran "burbujas", el algoritmo fundamental de este método es la simple comparación de elementos siendo así el más fácil de implementar.

Codificación en Java:

public static int[] OrdenarBurbuja(int[] n)

{
    int temp;
    int t = n.length;
    for (int i = 1; i < t; i++)

    {
         for (int k = t- 1; k >= i; k--)

         {
                if(n[k] < n[k-1])

                {
                    temp = n[k];
                    n[k] = n[k-1];
                    n[k-1]=  temp;
                }
         }
    }
    return n;

Codificación en C#:

Public int[] OrdenarBurbuja(int[]x)
{

        int t= x.Length, temp;

        for(int i=1 ; i< t ; i++)
        {

                for(int j = t-1 ; j >= i; j--)

                        if(x[j] < x[j-1])

                                temp= x[j];

                                x[j]= x[j-1];

                                x[j-1]= temp;

Ejemplo del ordenamiento de burbuja ordenando una lista de números aleatorios.

2) Quick Sort (Ordenamiento Rápido):

Es el algoritmo de ordenamiento más eficiente de todos, se basa en la técnica de "Divide y Vencerás", que permite en promedio, ordenar n elementos en un tiempo proporcional a n*log(n).
Algoritmo Fundamental:

Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote.
Resituar los demás elementos de la lista a cada lado del pivote, de manera que a un lado queden todos los menores que él, y al otro los mayores. Los elementos iguales al pivote pueden ser colocados tanto a su derecha como a su izquierda, dependiendo de la implementación deseada. En este momento, el pivote ocupa exactamente el lugar que le corresponderá en la lista ordenada.
La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del pivote, y otra por los elementos a su derecha.
Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados.

Codificación en Java:

void Quicksort(int[] vector, int first, int last)

{
     int i=first, j=last;
     int pivote=vector[(first + last) / 2];
     int auxiliar;
 
     do

          while(vector[i]<pivote) i++;

          while(vector[j]>pivote) j--;

          if (i<=j)

               auxiliar=vector[j];

               vector[j]=vector[i];

               vector[i]=auxiliar;

               i++;

               j--;

     while (i<=j);
 
     if(first<j)

          Quicksort(vector,first, j);

     if(last>i)

          Quicksort(vector,i, last);

Codificación en C#:

void Quicksort(int[] v, int prim, int ult)
{
 if (prim < ult)
 {
  /*Selecciona 1 elemento del vector y coloca los menores
   que él a su izq y los mayores a su derech*/
  int p = Pivote(v, prim, ult, ult);
 
  /* Repite el proceso para c/u de las particiones

     generadas en el paso anterior */
  Quicksort(v, prim, p - 1);
  Quicksort(v, p + 1, ult);
 }
}
 
/* Implementación no clásica de la función Pivote. En lugar de
recorrer el vector simultáneamente desde ambos extremos hasta el
cruce de índices, se recorre desde el comienzo hasta el final */
int Pivote(int[] v, int prim, int ult, int piv)
{
 int p = v[piv];
 int j = prim;
 
 // Mueve el pivote a la última posición del vector
 Intercambia(v, piv, ult);
 
 /* Recorre el vector moviendo los elementos menores
  o iguales que el pivote al comienzo del mismo */
 for (int i = prim; i < ult; i++)
 {
  if (v[i] <= p)
  {
   Intercambia(v, i, j);
   j++;
  }
 }
 
 // Mueve el pivote a la posición que le corresponde
 Intercambia(v, j, ult);
 
 return j;
}
 
void Intercambia(int[] v, int a, int b)
{
 if (a != b)
 {
  int tmp = v[a];
  v[a] = v[b];
  v[b] = tmp;
 }
}

Quicksort en acción sobre una lista de números aleatorios. Las líneas horizontales son valores pivote.

3) Heap Sort (Ordenamiento por Montículos):

Es un algoritmo de ordenamiento no recursivo, no estable, consiste en almacenar todos los elementos del vector a ordenar en un montículo (heap), y luego extraer el nodo que queda como nodo raíz del montículo (cima) en sucesivas iteraciones obteniendo el conjunto ordenado. Basa su funcionamiento en una propiedad de los montículos, por la cual, la cima contiene siempre el menor elemento (o el mayor, según se haya definido el montículo) de todos los almacenados en él.

Codificación en Java:

public class heap_Sort
{
public static void main(String a[])
{
    int i;
      int arr[] = {1,3,4,5,2};
    System.out.println("Heap Sort");
    System.out.println("\n---------------\n");
    System.out.println("\nUnsorted array\n\n");
    for (i = 0; i < arr.length; i++)
    System.out.print(" "+arr[i]);
    for(i=arr.length; i>1; i--)
    {
    fnSortHeap(arr, i - 1);
    }
      System.out.println("Sorted array");
    System.out.println("\n---------------\n");
    for (i = 0; i < arr.length; i++)
    {
    System.out.print(" "+arr[i]);
    }
    public void fnSortHeap(int arr[], int arr2)
    {
    int i, o;
    int lCh, rCh, mCh, root, tmp;
    root = (arr2-1)/2;

        for(o = root; o >= 0; o--)
    {
    for(i=root;i>=0;i--)
    {
    lCh = (2*i)+1;
    rCh = (2*i)+2;
    if((lCh <= arr2) && (rCh <= arr2))
    {
    if(arr[rCh] >= arr[lCh])
    {
    mCh = rCh;
    }
    else
    {
    mCh = lCh;
    }
        }
    else
    {
    if(rCh > arr2)
    {
    mCh = lCh;
    }
    else
    {
    mCh = rCh;
    }
    }

        if(arr[i] < arr[mCh])
    {
    tmp = arr[i];
    arr[i] = arr[mCh];
    arr[mCh] = tmp;
        }
    }
    }
        tmp = arr[0];
    arr[0] = arr[arr2];
    arr[arr2] = tmp;
    return;
      }
  }
}

Funcionamiento del Heap Sort:

Sobrecarga de Métodos

2010-04-29T18:10:00.001-05:00

Sobrecarga de Métodos en Java

La Sobrecarga de Métodos en Java (Overloading), es una característica que permite la creación de varios métodos, los cuales tendrán el mismo nombre y serán válidos solamente si cumplen con las siguientes condiciones:

Tener diferente tipo de dato los parámetros.
Tener diferente número de parámetros.
Nunca se considera sobrecarga de métodos si solamente cambia el valor de retorno del método.

Un ejemplo muy simple de recordar es cuando declaramos el constructor, recuerdan que solamente uno podía ir vacío?, mientras que el resto de los constructores que definamos deberán tener de forma obligatoria parámetros, y cumplir con las condiciones anteriormente mencionadas.

Ejemplo de Sobrecarga en Constructores:

public class Automovil

{

//Atributos

private String velocidad;

private String modelo;

//Constructor Vacío

public Automovil()

{

modelo = "Andino";

velocidad = "50 Km/h";

}

//Constructor con Parámetros

public Automovil(String modelo, String velocidad)

{

this.modelo = modelo;

this.velocidad = velocidad;

}

}//Fin de Clase Automóvil

Ejemplo de Sobrecarga en Métodos de un Programa:

public class Numero

{

//Atributos

private static int numero1, numero2, numero3; //Atributos que serán los parámetros del método suma

private static double numero01, numero02;

//Metodos

public static int suma(int numero1, int numero2)//método suma, 2 parámetros tipo int

{

return numero1+numero2;

}

public static double suma(double numero1, double numero2)//método suma 2 parámetros tipo double

{

return numero1+numero2;

}

public static int suma(int numero1, int numero2, int numero3)//método suma 3 parámetros tipo int

{

return numero1+numero2+numero3;

}

}//Fin de Clase Número

Manejo de Caracteres

2010-04-29T17:50:00.001-05:00

Manejo de Caracteres en Java

El manejo de caracteres es un conjunto de métodos y sentencias del Lenguaje Java que nos permite operar(reconocer, transformar, verificar, comparar, etc.) con los caracteres de una cadena de texto, ciertos parámetros que señalamos, de todos, los más comunes e importantes los listo a continuación:

String toLowerCase();
Nos permite transformar todos los caracteres de una cadena en Minúsculas.

Ejm:
String sCadena = "CADENA DE PRUEBA GL";
System.out.println(sCadena.toLowerCase()); //cadena de prueba gl

String toUpperCase();
Nos permite transformar todos los caracteres de una cadena en Mayúsculas.

Ejm:
String sCadena = "Cadena de Prueba GL";
System.out.println(sCadena.toUpperCase()); //CADENA DE PRUEBA GL

String trim();
Método que elimina los espacios en blanco iniciales y finales de la cadena de caracteres, retornando una copia de la misma.

Ejm:
String sCadena = " Esto Es Una Cadena" ;
System.out.println(sCadena.trim()); //Devuelve "Esto Es Una Cadena"

String replace(char oldChar, char newChar)
Este método lo utilizamos siempre y cuando deseamos remplazar un carácter por otro. Se reemplazarán todos los caracteres encontrados.
Una implementación práctica de esto se encuentra en Microsoft Office Word, que nos permite buscar cierto caracter o cadena de caracteres y reemplazarlos automáticamente con otro, incluso lo podemos dejar en blanco.

Sintaxis a seguir:
public String replace(char caracter_antiguo, char caracter_nuevo)
public String replace(CharSequence target, CharSequence replacement)

Ejm:
String cadena = new String("Falta de sexo");
System.out.println(cadena.replace('x','s'); //Reemplaza todas las 'x' por 's' //Por tanto imprime: Falta de seso

String valueOf();
Este conjunto de métodos de la Clase String nos permite convertir cualquier tipo de dato básico (int, double, float,etc. ) a cadena; en el caso de que tengamos con arrary de caracteres para convertir en una cadena, podemos tener una excepción IndexOutOfBoundsException en el caso de que intentemos acceder a un elemento que no exista. , a continuación los método que nos permite utilizar valueOf :

String valueOf(boolean b);
String valueOf(int i);
String valueOf(long l);
String valueOf(float f);,
String valueOf(double d);
String valueOf(Object obj);

Detalles de los Parámetros para valueOf:

b, valor booleano a convertir en cadena.
c, caracter a convertir en cadena.
i, numero entero a convertir en cadena.
l, long a convertir en cadena.
f, decimal a convertir en cadena.
d, double a convertir en cadena.
data, array a convertir en cadena.
offset, desplazamiento a partir va a empezar la conversión.
count, número de caracteres a convertir de la cadena.
obj, objeto a convertir en cadena.

Excepción para ValueOf:
Indica que el índice pasado como parámetro está fuera de rango (que no existe). Esto aplica a elementos como Array, Vector, String, etc.

Sintaxis a seguir:
public IndexOutOfBoundsException()

Constructores:

IndexOutOfBoundsException()

IndexOutOfBoundsException(String s)

Ejm:

String cadena = new String("Mi cadena");//Aquí solo hay 9 elementos

char caracter = ;

try{

caracter = cadena.charAt('40');//Al tratar de acceder al elemento 40 de nuestra cadena, nos da error ya que no existe.

} catch (IndexOutOfBoundsException ioobe){

System.out.println("No existe un carácter en esa posición");
}

Qué es un Paquete en Java?

2010-04-13T01:08:00.000-05:00

Java Package

Package: Como hemos visto para todo proyecto en Java tenemos que crear un paquete, pero qué es realidad este paquete?, para qué sirve?, y físicamente en el computador dónde se nos genera?

Bueno técnicamente un paquete es un espacio de nombres "namespace" que organiza un conjunto de clases e interfaces relacionadas. Físicamente en el equipo se crean carpetas y estos son los paquetes con los que trabajamos en Java. Como el software escrito en el lenguaje de programación Java puede estar compuesta de cientos o miles de clases individuales, tiene sentido mantener las cosas organizadas, colocando relacionados clases e interfaces en paquetes.

Creación de un Nuevo Paquete en NetBeans:

Ejemplos de eventos y sus escuchadores
Acción que activa un evento	Tipo de escuchador
El usario hace un click, presiona Return en un área de texto o selecciona un menú	`ActionListener(Acciones Sobre Componentes)`
El usuario escoje un frame (ventana principal)	`WindowListener`
El usuario hace un click sobre una componente	`MouseListener`
El usuario pasa el mouse sobre una componente	`MouseMotionListener`
Una componente se hace visible	`ComponentListener`
Una componente adquiere el foco del teclado	`FocusListener`
Cambia la selección en una lista o tabla	`ListSelectionListener`