Buenas intenciones

Juego del ahorcado en Java

2013-10-02T20:07:00.001-05:00

El semestre pasado lleve la materia de graficación, y me pidieron que realizara este juego; en si no tiene una gran interfaz, aparte que solo lo hice en un día, lo comparto con ustedes para que si llegan a hacerlo, no comiencen de cero como yo, y se les haga mas fácil.

El juego esta dividido en tres clases. La clase Palabra es la encargada del manejo de las palabras que pueden ser elejidas para que el jugador trate de adivinar cual es (las palabras son nombres de animes), también esta clase hace las comparaciones de letras para ver si la letra que escriba el usuario se encuentra dentro de la palabra que el programa eligió.

La clase Pintar es la encargada de pintar el "muñeco" con ayuda de los métodos paint y repaint.

Y por ultimo la clase Ahorcado es donde esta toda la interfaz gráfica del juego.

Si tienen alguna duda sobre alguna parte del código comenten en nuestro Facebook para una pronta respuesta. .facebook.com/BuenasIntencions

Descarga el proyecto AQUI

NOTA: El proyecto fue creado utilizando NetBeans 7.1

Operaciones básicas en java

2013-07-10T21:14:00.002-05:00

Últimamente descuidamos el blog un poco (por las vacaciones de verano), hace algunos días una seguidora del blog nos contacto para resolver algunas dudas, lamentablemente por falta de tiempo resolvimos sus dudas un poco después de tiempo. Pero ella logro terminar su programa y quiere compartirlo con nosotros y ustedes también.

Es un programa que pide una entrada (un numero entero) y realiza las 4 operaciones basicas. El programa usa JOptionPane para pedir y mostrar los datos, también otra cosa que debo mencionar es que el programa implementa el uso de funciones.

Les dejo el código aquí:

Ahora solo les queda probar el programa en sus computadoras. ¡Hagamos código! Pueden descargarlo de aquí: Operaciones.java

Inicio en java Ejemplo 3

2013-07-10T20:41:00.000-05:00

Siguiendo con el tercer ejercicio de Inicio en java, se plantea el siguiente problema:

Hacer un programa en java que solicite al usuario el monto de los dolares a convertir en pesos mexicanos y solicite también la tasa actual de cambio por dolar. El programa visualizara el resultado de conversión de dolares a pesos mexicanos.

CÓDIGO


/**
 * Archivo: Conversion.java
 * @autor BelloCerecero
 * @since 10-jul-2013
 **/

import java.util.Scanner;

public class Conversion
{
  public static void main(String[] args) 
  {
    //Creamos el objeto teclado
    //Para interactuar con el usuario por consola
    Scanner teclado = new Scanner(System.in);

    //Solicitamos el monto a convertir 
    System.out.println("Ingrese el monto: ");

    //Guardamos el monto a convertir
    double dolares = teclado.nextDouble();

    //Solicitamos la tasa actual de cambio
    System.out.println("Ingrese tasa actual de cambio: ");

    //Guardamos la tasa actual de cambio
    double tasa = teclado.nextDouble();

    //Hacemos la conversion
    double conversion = tasa * dolares;

    //Imprimimos
    System.out.println(dolares + " dolares es igual a " + conversion + " pesos");
  }
}

Comenzaremos en la linea 7, aquí estamos importando la clase Scanner para poder interactuar con el usuario por medio de la consola.

En la linea 9 creamos la clase Conversion y en la linea 11 creamos el main.

Ahora en la linea 15 instanciamos Scanner para poder usar sus métodos; En la linea 18 imprimimos en consola "Ingrese el monto" el usuario tendrá que ingresar el monto en dolares que quiere convertir a pesos. Para esto en la linea 21 guardamos esa cantidad que ingresara.

En la linea 24 imprimimos en consola "Ingrese tasa actual de cambio" en esta parte el usuario tendrá que ingresar la tasa de cambio vigente, ahora guardamos ese valor (linea 27).

En esta pagina pueden encontrar la tasa de cambio actual: http://www.cambiodolar.mx/

En la linea 30 solo estamos haciendo la conversión de dolares a pesos con una simple multiplicación.

Y por ultimo en la linea 33 imprimimos la conversión.

La salida del programa es la siguiente:

Descarga el código: Conversion.java

Inicio en java Ejemplo 2

2013-07-10T18:04:00.001-05:00

Este es el segundo ejercicio que va enfocado a personas que estén en su primer curso de java, como les había comentado anteriormente estos programas los realice yo en mi primer curso de java, sin mas que decir aquí el ejercicio:

Solicite el total a pagar de medicamentos en una farmacia. El programa debe de calcular el descuento obtenido del 8% en la venta y el total a pagar por el cliente menos el descuento, imprima el total que se pago según la venta , el descuento que se realizo y el pago de la venta menos el descuento.

CÓDIGO

/**
 * Archivo: Farmacia.java
 * @autor BelloCerecero
 * @since 10-jul-2013
 **/

import java.util.Scanner;

public class Farmacia
{
  public static void main(String args[])
  {
    //Creamos el objeto teclado
    //Para interactuar con el usuario por consola
    Scanner teclado = new Scanner(System.in);

    //Le solicitamos el total a pagar
    System.out.println("Ingrese el total a pagar: ");

    //Guardamos el total a pagar
    double totalPagar = teclado.nextDouble();

    //Obtenemos el 8% de descuento
    double descuento = (8*100)/totalPagar;

    //Obtenemos el total menos el descuento
    double venta = totalPagar - descuento;

    //Imprimimos todo lo que se nos pide
    System.out.println("Pago de la venta: " + totalPagar);
    System.out.println("Descuento: " + descuento);
    System.out.println("Total: " + venta);
  }
}

Bien, entonces nos ubicamos en la linea 7, aquí estamos importando la clase Scanner para poder interactuar con el usuario por medio de la consola. En la linea 9 creamos nuestra clase a la que llamaremos "Farmacia" y en la linea 11 creamos el main para que el programa pueda ejecutarse.

En la linea 15 estamos instanciando la clase Scanner para poder usar sus métodos En la linea 18 imprimimos en consola un mensaje para que el usuario introduzca el total a pagar.

En la linea 21 declaramos una variable de tipo double (Por si hay centavos) y en ella guardaremos lo que el usuario halla introducido (para eso se usa "teclado.nextDouble()").

En la linea 24 declaramos una variable de tipo double (por si hay decimales), en esta variable guardaremos el resultado de la siguiente operación: (8*100)/totalPagar

Que no es mas que una regla de tres para obtener el 8% del total a pagar.

En la linea 27 declaramos una ultima variable de tipo double (por si hay decimales), aquí guardaremos la resta del total a pagar menos el ocho por ciento de descuento.

Ya por ultimo hacemos las impresiones.

En la linea 30 imprimimos el total a pagar (sin el descuento), en la linea 31 imprimimos el descuento que se aplicara y en la linea 32 imprimimos el total a pagar pero ya con el descuento.

La salida del programa es:

Descarga el código: Farmacia.java

Inicio en java Ejemplo 1

2013-07-10T01:07:00.001-05:00

Este sera el primero de varios programas que estaré publicando, estos programas están dirigidos para personas que están llevando su primer curso de java o estén interesados en aprender lo básico de este lenguaje. Estos programas que estaré publicando, podría decirse que son los clásicos ejercicios que tu profesor les explicara o dejara de tarea. Sin mas preámbulos comenzamos con el primero, bien, el planteamiento del ejercicio es el siguiente:

Hacer un programa en java de una lista de 5 calificaciones, que calcule y almacene el promedio, y posteriormente que lo visualice en la pantalla. La lista de calificaciones son:

77
83
85
72
88

CÓDIGO

/**
 * Archivo: Calificicaciones.java
 * @Autor BelloCerecero
 * @Since 9-jul-2013
 **/

public class Calificaciones
{
  public static void main(String args[])
  { 
    //Declaración y asignacion de variables
    int calif1 = 77;
    int calif2 = 83;
    int calif3 = 85;
    int calif4 = 72;
    int calif5 = 88;
  
    //variable para almacenar el promedio
    double promedio;
  
    //Proceso para calcular el promedio
    promedio = (calif1 + calif2 + calif3 + calif4 + calif5)/5;
  
    //Imprimimos en consola
    System.out.println("El promedio es: " + promedio);
   }
}

Bien, comenzamos en la linea 1 a la 5 estos son solo comentarios, en la linea 7 inicia nuestra clase a la que llamaremos "Calificaciones", en la linea 9 iniciamos el "main", en la linea 12 estamos declarando e inicializando las variables en donde guardaremos las 5 calificaciones, en la linea 19 declaramos una variable donde guardaremos el promedio de las 5 calificaciones. En la linea 22 hacemos la operación para obtener el promedio (sumamos las 5 calificaciones y las dividimos entre 5 y por ultimo en la linea 25 imprimimos en consola "El promedio es: " concatenando a la variable promedio. La salida del programa es la siguiente:

Nota: El programa esta ejecutado en la terminal de Ubuntu 12.04 LTS, pero es 100% funcional en Windows, se puede usar la consola de windows para su ejecución o algún IDE como NetBeans o Eclipse. O en su defecto se puede usar también JCreator.

Descarga el programa: Calificaciones.java

Números Perfectos

2013-06-29T21:21:00.001-05:00

Hola amigos de Buenas Intenciones hoy les traigo a petición de un seguidor de buenas intenciones un programa de Números Perfectos.

Bueno lo primero que debemos saber es ¿QUE ES UN NÚMERO PERFECTO?.

Un número es perfecto si es igual a la suma de todos sus divisores positivos sin incluir el propio número.

Por ejemplo, el número 6 es perfecto.

El 6 tiene como divisores: 1, 2, 3 y 6 pero el 6 no se cuenta como divisor para comprobar si es perfecto.

Si sumamos 1 + 2 + 3 = 6

Los siguientes números perfectos después del 6 son 28, 496, 8128, 33550336, 8589869056.

Una vez explicado este punto pasamos al código de nuestro programa.

package buenasintenciones;
/**
 * @author Ivan
 */
import javax.swing.JOptionPane;

public class NumerosPerfectos {
    public static void main(String[] args) {
        int i, suma= 0, numero;
         String numero1 = JOptionPane.showInputDialog("Ingrese el numero del 1 al 10000");
         numero= Integer.parseInt(numero1);
        for (i = 1; i < numero; i++) { 
            if (numero % i == 0) {
                suma = suma + i;   
            }
        }
        if (suma == numero) {  
            JOptionPane.showMessageDialog(null, "El numero es perfecto");
        } else {
            JOptionPane.showMessageDialog(null, "El numero no es perfecto");

        }
    }
}

Bueno lo primero que tenemos que hacer es declarar la libreria JOptionPane para poder insertar nuestros datos más adelante, declaramos el nombre de nuestra clase en este caso es NumerosPerfectos, declaramos nuestro metodo main. En la linea 10 declaramos tres variables de tipo int con su nombre i, suma(esta con un valor inicial de 0) y numero. En la linea 11 declaramos una variable de tipo String con nombre numero1 y la igualamos con nuestro JOptionPane que sirve para insertar datos y colocamos el comentario entre comillas que queremos que nos muestre. En la 12 tenemos que convertir nuestro valor anterior a un valor entero que es igual a un valor de tipo int, esto ya que nuestro JOptionPane recibio un valor de tipo String. en nuestra linea 13 declaramos un ciclo for con las condiciones i=1, donde este valor i van a ser los divisores y los dividira hasta de 1 hasta n-1, en la linea 14 solo declaramos que si el valor de la suma es un un divisor se sume.

En la 18 declaramos nuestra condicion if diciendo que si es el valor de suma es igual a numero sera un valor perfecto y por ultimo nuestras salidas con un JOption de mensajes.

Herencia

2013-06-23T13:30:00.003-05:00

Cuando hablamos de la programación orientada a objetos es inevitable tratar con el tema de la Herencia, ya que es una de la principales características de este enfoque. La herencia es una característica que nos permite la creación de clases (subclase) a partir de una clase ya creada (superclase); de modo que cuando estemos creando una clase y decidimos que va a heredar de otra clase ya existente, lo la clase que estamos creando podrá hacer uno de los métodos y atributos de la clase que ya existe (de la cual heredamos).

Ejemplo:

Creamos una clase Persona y una clase Estudiante, distintas una de la otra:

Bien estas son dos diferentes clases por separado, independientes.

Pero pensemos que un estudiante también tiene los mismos atributos y los mismos métodos que una persona, pero una persona no necesita los mismos atributos y métodos que un estudiante. Entonces pensemos en que la clase estudiante puede heredar los métodos y atributos de la clase Persona, de tal modo que podríamos visualizar algo más o menos así:

La clase Estudiante HEREDA de la clase Persona:

El ejemplo anterior es una analogía con personas (un caso cotidiano) para dejar en claro la esencia de la Herencia. Ahora procederé a mostrarles un código de como se maneja la herencia en Java:

/**
 *Archivo: Persona.java
 * @author Anibal Clavel
 * http://www.buenasintencions.blogspot.mx
 */

public class Persona {
    
    //Declaracion de atributos:
    String nombre;
    int edad;
    
    //Constructor:
    public Persona(){
        
    }
    
    //Metodo dormir:
    public String domir(){
        return "zZzzZ";
    }
    
    //Metodo comer:
    public String comer(){
        return "comiendo...";
    }
    
    //Setters y Getters.
    public void setNombre(String n){
        nombre = n;
    }
    
    public void setEdad(int e){
        edad = e;
    }
    
    public String getNombre(){
        return nombre;
    }
    
    public int getEdad(){
        return edad;
    }
}// fin de la clase Persona.

Creada la clase Persona con sus respectivos métodos, atributos, setters y getters. Esto como siempre hemos planteado la clase Persona, y debido a que es simple de entender, solo voy a decirles que a partir de esta clase vamos a crea una clase nueva, la clase Estudiante. La clase Estudiante va a ser hija (va a heredar) de la clase Persona, por lo tanto un objeto de la clase Estudiante podrá hacer uso de los métodos de la clase Persona también.

Ahora el código de la clase Estudiante, con sus métodos y atributos propios y con una linea de código donde indicamos que hereda de otra clase:

/**
 *Archivo: Estudiante.java
 * @author Anibal Clavel
 * http://www.buenasintencions.blogspot.mx
 */

public class Estudiante extends Persona{
    
    //Declaracion de atributos:
    String carrera, matricula;
    
    //Metodo estudiar:
    public String estudiar(String materia){
        return "estudiando... "+materia;
    }
    
    //Metodo hacer examen:
    public String hacerExamen(){
        return "haciendo exmane";
    }
    
    //Setters y Getters
    public void setCarrera(String c){
        carrera = c;
    }
    
    public void setMatricula(String m){
        matricula = m;
    }
    
    public String getCarrera(){
        return carrera;
    }
    
    public String getMatricula(){
        return matricula;
    }
}//fin de la clase Estudiante.

Como ven la creación de esta clase es de la forma tradicional que siempre lo hacemos, a excepción de que en la linea 7 al momento de definir la clase Estudiante, mediante la palabra reservada extends le indicamos que esa clase va a heredar de otra clase, en este caso de Persona.

Para este momento ya tenemos creadas 2 clases diferentes, Persona y Estudiante (que hereda de la primera), creare una clase principal para hacer objetos de la clase estudiante y probar nuestra herencia:

/**
 *Archivo: Prueba.java
 * @author Anibal Clavel
 * http://www.buenasintencions.blogspot.mx
 */

import javax.swing.JOptionPane;

public class Prueba{
    
    public static void main(String args[]){
        
        String dato1;
        int dato2;
        Estudiante e = new Estudiante();
        
        dato1=JOptionPane.showInputDialog("Nombre:");
        e.setNombre(dato1);
        dato2=Integer.parseInt(JOptionPane.showInputDialog("Edad:"));
        e.setEdad(dato2);
        dato1=JOptionPane.showInputDialog("Carrera:");
        e.setCarrera(dato1);
        dato1=JOptionPane.showInputDialog("Matricula:");
        e.setMatricula(dato1);
        
        System.out.println("El nombre de la persona es:");
        System.out.println(e.getNombre());
        System.out.println("\n...y su edad es: "+e.getEdad());
        System.out.println("Estudia: "+e.getCarrera());
        System.out.println("con matricula: "+e.getMatricula());
        
        System.out.println("Tiene la capacidad de hacer estos metodos:");
        System.out.println(e.domir());
        System.out.println(e.comer());
        System.out.println(e.estudiar("Matematicas"));
        System.out.println(e.hacerExamen());
    }
}

Bien, en esta clase principal se crea un objeto e de la clase Estudiante y se hace uso de sus métodos, y también se hace uso de los métodos de la clase Persona ya que puede utilizarlos.

De este modo es como funciona la herencia en la programación orientada a objetos en Java, permite que clases hijas puedan usar los métodos o atributos de clases padres, ahora podemos correr nuestro programa y observar los resultados obtenidos para un mejor entendimiento del tema y para probar como es que realmente ha sucedido la herencia.

Números aleatorios

2013-06-21T16:16:00.002-05:00

Los números aleatorios son de mucha utilidad en ciertas ocasiones, ya que, los podemos usar para ciertos programas que necesiten tomar decisiones sin la intervención del usuario. En fin, hoy hablaremos mas concretamente sobre como generar números aleatorios de tipo entero, para esto, hemos realizado el siguiente ejemplo:

//Archivo: NumerosAleatorios.java

import java.util.Random;

public class NumerosAleatorios
{
  public static void main(String args[])
  {
    //Instanciamos la clase Random
    Random num = new Random();
    System.out.println("Numeros aleatorios generados:");
    System.out.println(num.nextInt(10));
    System.out.println(num.nextInt(10));
    System.out.println(num.nextInt(10));
    System.out.println(num.nextInt(10));
  }
}

Bien, ya dentro del main (linea 9) hemos puesto un comentario, en la linea 10 es donde ya instanciamos la clase Random, para poder utilizarla. En la linea 11 hemos puesto una impresión solo para que salga "Numeros aleatorios generados:", en la linea 12 hasta la 15, con ayuda de un System.out.println(); y usando la siguiente instrucción (dentro del System) num.nextInt(10); (num es el nombre de la instancia linea 10). Ahora algo importante, se preguntaran por que hemos puesto un 10 dentro, bueno ese 10 quiere decir, que, nos va a generar números aleatorios del 0.... al 10, si yo quisiera que me generara del 0... al 6 (por ejemplo), solo tendría que poner un 6 ejemplo:

    System.out.println(num.nextInt(6));

Entonces ya solo generaría números aleatorios del 0... al 6.

La salida del programa es la siguiente:

NOTA: Si ejecutan el programa en sus computadoras, la salida sera diferente en cada ejecución puesto que son NÚMEROS ALEATORIOS.

Setters y Getters

2013-06-19T01:20:00.001-05:00

Los setter y getters, son métodos de acceso en una clase, estos sirven para establecer y obtener datos de los atributos de nuestra clase, estos dos métodos deben ser públicos:

El método set (traducción al español: "establecer"): nos sirve para asignar un valor (inicializar) a un atributo de nuestra clase, esto se hace de manera directa con este método, como este método no retorna nada, el nombre de este debe ser precedido por void, y siempre debe recibir un parámetro de entrada.

El método get (traducción al español: "obtener"): este tipo de método accede a la clase para retornarnos el valor de algún atributo que queramos, y como ya mencioné, el método get si debe retornar un valor por lo cual el nombre de este método debe ser precedido por el tipo de valor que vamos a retornar con ese método.

A estos métodos se les suele hacer referencia en plural (como el titulo de este post) porque generalmente son más de un método set y get en una clase, y de este modo nos referimos a todo ese tipo de métodos de establecimiento y obtención de información. Bien, estos métodos se ven así en una clase:

/**
 *Archivo: Persona.java
 * @author Anibal Clavel
 * http://www.buenasintencions.blogspot.mx
 */

public class Persona {
    
    //Declaracion de atributos:
    String nombre;
    int edad;
    
    //Constructor:
    public Persona(){
        
    }
    
    //Metodo dormir:
    public String domir(){
        return "zZzzZ";
    }
    
    //Metodo comer:
    public String comer(){
        return "comiendo...";
    }
    
    //Setters y Getters.
    public void setNombre(String n){
        nombre = n;
    }
    
    public void setEdad(int e){
        edad = e;
    }
    
    public String getNombre(){
        return nombre;
    }
    
    public int getEdad(){
        return edad;
    }
}// fin de la clase Persona.

Acá creamos la clase Persona con 2 atributos, 1 constructor, 2 metodos, 2 setters y 2 getters. Los setters y getters comienzan en la linea 29 y como se puede observar el primer set es para establecer un nombre (String) a nuestro atributo nombre de la clase.

El método setNombre(), pide como parámetro un String (el nombre de la persona), el cual asigna a nuestro atributo nombre de la clase. Este método no retorna ningún valor. Solo establecimos un dato en un atributo de esta clase.

El método getNombre(), no necesita de parámetros de entrada, solo devuelve al programa que lo este invocando (mediante un objeto de la clase Persona) el valor que contenga alojado el atributo nombre, retorna un valor String.

Una vez que creamos nuestros métodos set y get y hayamos terminado la creación de nuestra clase, hacemos unos de estos métodos en la clase principal (o en otra clase que lo requiera), y se vera más o menos así:

/**
 *Archivo: Prueba.java
 * @author Anibal Clavel
 * http://www.buenasintencions.blogspot.mx
 */

import javax.swing.JOptionPane;

public class Prueba{
    
    public static void main(String args[]){
        
        String dato1;
        int dato2;
        Persona p = new Persona();
        
        dato1=JOptionPane.showInputDialog("Nombre:");
        p.setNombre(dato1);
        dato2=Integer.parseInt(JOptionPane.showInputDialog("Edad:"));
        p.setEdad(dato2);
        
        System.out.println("El nombre de la persona es:");
        System.out.println(p.getNombre());
        System.out.println("\n...y su edad es: "+p.getEdad());
    }
}

Cubo de Rubik en JAVA

2013-06-16T17:57:00.000-05:00

Hola amigos de "Buenas Intenciones", en esta le explicare como hacer el cubo de Rubik utilizando las libreria de OpenGL, que es una libreria para graficos por computadora un poco mas avanzada donde utilizaremos codigo en java 3D, con textura, movimientos de cámara, traslación, rotación.

Primero veamos que es OpenGL proporciona una biblioteca básica de funciones para especificar primitivas gráficas, atributos, transformaciones geométricas, transformaciones de visualización y muchas otras operaciones.

Los nombres de las funciones de la biblioteca básica de OpenGL (también llamada de biblioteca del núcleo

de OpenGL) utilizan como prefijo g l , y cada palabra que forma parte del nombre de una función tiene su

primera letra en mayúscula. Los siguientes ejemplos ilustran este convenio de denominación.

glBegin, glClear, glCopyPixels, glPolygonMode

Bueno sin mas que decir empezamos analizando el codigo linea por linea.

NOTA: Todo el codigo es en una sola clase y esta dividido en fragmentos para facilitar el entendimiento.

//Archivo: Rubik.java
//Autor: Ivan Gallardo
import com.sun.opengl.util.Animator;
import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
import com.sun.opengl.util.GLUT;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.File;
import com.sun.opengl.util.texture.Texture;
import com.sun.opengl.util.texture.TextureIO;
import java.io.IOException;

public class Rubik extends JFrame implements KeyListener{
    static GL gl;
    static GLU glu;
    static GLUT glut;
    static GLCanvas canvas;
    private static float rotarX=0;
    private static float rotarY=0;
    private static float rotarZ=0;
    private static float trasladaX=0;
    private static float trasladaY=0;
    private static float trasladaZ=0;
    private Texture cara1, cara2,cara3,cara4, cara5,cara6;
    private static float EscaX=1.0f;
    private static float EscaY=1.0f;
    private static float EscaZ=1.0f;
    private static float EscaXm=1.0f;
    private static float EscaYm=1.0f;
    private static float EscaZm=1.0f;
    static float rojo=0.0f;
    static float verde=0.0f;
    static float azul=0.0f;

Bueno de la linea de comando 3 a la 16 son las librerias necesarias para los diferentes metodos que
utilizaremos en nuestro programa que en Netbeans se originan automaticamente cuando insertamos una sentencia que las necesite asi que con eso no tendremos mayor problema. Bien en nuestra linea 18 esta el nombre de nuestra clase con la extencion de JFrame para nuestro frame de la clase tenemos implementado KeyListener para poder utilizar nuestro teclado y asignarle funciones. De la linea 19 a 38 son nuestras variables que ocuparemos en todo nuestro pragrama ya ire mencionando cada una de ellas conforme vayamos haciendo uso de ellas.

public Rubik(){
        setSize(700, 600);
        setTitle("Cubo De Rubik");
        setResizable(true);
        GraphicListener listener = new GraphicListener();
        canvas = new GLCanvas();
        gl = canvas.getGL();
        glu = new GLU();
        glut = new GLUT();
        canvas.addGLEventListener(listener);    
        getContentPane().add(canvas);
        Animator animator = new Animator(canvas);
        animator.start();
        addKeyListener(this);
        
    }

Bien continuando con nuestro programa en la siguiente linea creamos nuestro constructor con el nombre de nuestra clase que es como se identifica. en la linea 2 asignamos el tamaño de la ventana donde mostraremos nuestra figura, en la linea 3 el titulo de la ventana en este caso es "Cubo de Rubik", la sentencia setResizable puede ser false o true como se muestra en nuestro código y esto sirve para los que no sabemos para maximizar o o minimizar el tamaño de la ventana, en la linea 5 invocamos a la clase GraphicListener con el nombre listener para inicializar o convocar la clase. En la linea 6 utilizaremos nuestra primer variable asignada en el fragmento anterior (linea 22) que es GLCanvas con el nombre canvas para poder utilizar todos los métodos que esa clase contiene, para que nos sirve el canvas para visualizar básicamente nuestras figura de OpenGL en una forma animada,de las linea 7 a la 9 Utilizaremos las otras 3 variables de OpenGL donde en la variable gl asignamos la clase canvas con sus métodos, las variables glu y glut son variables que contienen una clase de figuras predefinidas que veremos mas adelante, en las tres ultimas lineas de codigo lo unico que se hace es invocar la clase animator e introducir dentro de ella la clase canvas para dar la animacion y procedemos a darle inicio con star(), la ultima es para nuestro teclado y las teclas que seran asignadas mas adelante con su respectiva función.

public static void main(String args[]){
        Rubik r = new Rubik();
        r.setVisible(true);
        r.setDefaultCloseOperation(EXIT_ON_CLOSE);
        r.setLocationRelativeTo(null);
    }

Se podria decir que es la parte mas importante del programa porque es donde esta nuestro main, que es el metodo que inicializa a nuestra clase completa y hace que nuestro programa corra.

public class GraphicListener implements GLEventListener{
        public void display(GLAutoDrawable arg0) {
            gl = arg0.getGL();
            gl.glClear(GL.GL_COLOR_BUFFER_BIT|GL.GL_DEPTH_BUFFER_BIT);                      
            gl.glMatrixMode(GL.GL_PROJECTION);
            gl.glLoadIdentity();
            glu.gluPerspective(50, 2, 0.1, 30);
            gl.glMatrixMode(GL.GL_MODELVIEW);
            gl.glDepthFunc(GL.GL_LEQUAL); 
            gl.glEnable(GL.GL_DEPTH_TEST);
            gl.glClearDepth(1.0);
            gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_DECAL);
            gl.glLoadIdentity();
            glu.gluLookAt(0.1 + trasladaX, .1 + trasladaY, .5 + trasladaZ, 0.5 + trasladaX,0, -5.5 + trasladaZ, 0.0, 1.0, 0.0);

En esta parte del codigo iniciamos una nueva clase que se llama GraphicListener y le implementamos la libreria de OpenGL con eventos, enseguida creamos un metodo llamado display que es como su nombre lo dice nos permite mostrar nuestro cubo, en la siguiente linea utilizamos nuestra variable gl y le asignamos el argumento arg0 con la libreria de OpenGL, en las proximas lineas utilizamos las libreria de OpenGL para crear la perspectiva, proyeccion, textura, traslacion y las inicializamos como se muestran.

            cara1.enable();
            cara1.bind();
            gl.glScalef(EscaX,EscaY,EscaZ);
            gl.glScalef(EscaXm,EscaYm,EscaZm);
            gl.glRotatef(rotarX, 1f, 1f, 0f);
            gl.glRotatef(rotarY, 0f, 1f, 1f);
            gl.glRotatef(rotarZ, 0f, 0f, 1f);
            gl.glBegin(gl.GL_QUADS);                                            
            gl.glTexCoord2f(1, 1);                
            gl.glVertex3f(0, 0, 0);     
            gl.glTexCoord2f(0, 1);
            gl.glVertex3f(0.2f, 0f, 0);
            gl.glTexCoord2f(0, 0);
            gl.glVertex3f(.2f, .2f, 0);
            gl.glTexCoord2f(1, 0);
            gl.glVertex3f(0f, .2f, 0);
            gl.glEnd();
            cara1.disable();

Atención en esta parte del codigo ya que es una de las partes mas importantes de nuestro programa, bien en la linea 1 utilizamos nuestra primer variable de tipo textura llamada cara1 con el metodo permitir mostrar la primer cara del cubo, en la linea 2 obligamos a nuestro programa a mostrar cara1, de la linea 3 a la 7 utilizimaos las libreria OpenGL de escalacion y rotacion cada uno de estos metodos tiene tres valores booleano dentro del primer metodo que es el glScalef(), colocamos nuestras variables de escalacion positivas y en la linea siguiente mismo metodo pero con variables negativas (en la parte de las teclas veran porque positivo(+) y negativo(-)), el metodo glRotatef() al igual que el glSalef() contiene valores booleanos y en el primero tenemos valores positivos y en el segundo tenemos valores negativos. En la linea de 8 utilizamos la libreria de primitivas de OpenGL del cuadrado para formar nuestra cara principal osea la cara 1, de la linea de codigo 9 a la 16 ponemos la ubicacion de los puntos de coordenadas 3D y los vertices, por ultimo en la 17 y 18 terminamos nuestro muestre de la cara1 y deshabilitamos nuestra cara 1 para poder activar las 5 caras restantes utilizando el mismo codigo.

public void init(GLAutoDrawable arg0){    
            
            try {               
            cara1 = TextureIO.newTexture(new File("Rubik.jpg"), true);            
            cara2 = TextureIO.newTexture(new File("Rubik1.jpg"), true);            
            cara3 = TextureIO.newTexture(new File("Rubik2.jpg"), true);       
            cara4 = TextureIO.newTexture(new File("Rubik3.jpg"), true);       
            cara5 = TextureIO.newTexture(new File("Rubik4.jpg"), true);       
            cara6 = TextureIO.newTexture(new File("Rubik5.jpg"), true);       
            } catch (IOException e) {
                System.exit(1);
            }
            
        }

En este metodo es donde mandaremos a traer a nuestra textura como podemos observar son 6 caras lo que quiere decir que para cada cara necesitamos una textura y finalizamos con un true para que la muestre.

public void keyPressed(KeyEvent arg0){
       if(arg0.getKeyCode()==KeyEvent.VK_ESCAPE){
            rotarX=0;
            rotarY=0;
            rotarZ=0;
            trasladaX=0;
            trasladaY=0;
            trasladaZ=0;
            EscaX=1.0f;
            EscaY=1.0f;
            EscaZ=1.0f;
            EscaXm=1.0f;
            EscaYm=1.0f;
            EscaZm=1.0f;
            rojo=0.0f;
            verde=0.0f;
            azul=0.0f;
        }
        if(arg0.getKeyCode()==KeyEvent.VK_X){
            rotarX+=1.0f;
        }

        if(arg0.getKeyCode()==KeyEvent.VK_A){
            rotarX-=1.0f;
        }

        if(arg0.getKeyCode()==KeyEvent.VK_Y){
            rotarY+=1.0f;
        }

        if(arg0.getKeyCode()==KeyEvent.VK_B){
            rotarY-=1.0f;
        }

        if(arg0.getKeyCode()==KeyEvent.VK_Z){
            rotarZ+=1.0f;
        }

        if(arg0.getKeyCode()==KeyEvent.VK_C){
            rotarZ-=1.0f;
        }

        if(arg0.getKeyCode()==KeyEvent.VK_RIGHT){
            trasladaX+=.10f;
        }

          if(arg0.getKeyCode()==KeyEvent.VK_LEFT){
            trasladaX-=.10f;
        }

         if(arg0.getKeyCode()==KeyEvent.VK_UP){
            trasladaY+=.10f;
        }

          if(arg0.getKeyCode()==KeyEvent.VK_DOWN){
            trasladaY-=.10f;
          }

        if(arg0.getKeyCode()==KeyEvent.VK_1){
            trasladaZ+=.1;
          }

        if(arg0.getKeyCode()==KeyEvent.VK_2){
            trasladaZ-=.10f;
          }
        if(arg0.getKeyCode()==KeyEvent.VK_3){
            rotarY+=1.0;
        }

        if(arg0.getKeyCode()==KeyEvent.VK_4){
            rotarY-=1.0;
        }
        else if (arg0.getKeyCode()== KeyEvent.VK_I){
            EscaX +=0.1f;
        }
        else if (arg0.getKeyCode()== KeyEvent.VK_O){
            EscaY +=0.1f;
        }
        else if (arg0.getKeyCode()== KeyEvent.VK_P){
            EscaZ +=0.1f;
        }
        else if (arg0.getKeyCode()== KeyEvent.VK_J){
            EscaXm -=0.1f;
        }
        else if (arg0.getKeyCode()== KeyEvent.VK_K){
            EscaYm -=0.1f;
        }
        else if (arg0.getKeyCode()== KeyEvent.VK_L){
            EscaZm -=0.1f;
        }
        else if (arg0.getKeyCode()== KeyEvent.VK_E){
            rojo +=0.1f;
        }
        else if (arg0.getKeyCode()== KeyEvent.VK_R){
            verde +=0.1f;
        }
        else if (arg0.getKeyCode()== KeyEvent.VK_T){
            azul +=0.1f;
        }
    }

    public void keyReleased(KeyEvent arg0){}
    public void keyTyped(KeyEvent arg0){}

Estamos en la ultima parte de nuestro programa es la parte donde asignamos a cada tecla una funcion o una variable con un valor ya sea en aumento o disminución para darle valores a los metodos donde fueron colocadas la unica q sirve con un reset es la tecla escape que esa es restaurar todos los valores de las variables como estaban al inicio.

Bueno sin mas que decir aqui esta una imagen de nuestro cubo y mas abajo el codigo java del programa espero y les haya servido suerte.

Descarga el código aquí:

CuboRubik.java

Concatenar cadenas

2013-06-11T01:01:00.000-05:00

En java para se puede hacer de dos formas, utilizando el método concat o con el operador +.

Para dar una idea mas clara hemos realizado este pequeño programa:

/**
 * @Archivo: Cadenas.java
 * @author Cerecero 
 * @since 11/junio/2013
 */
public class Cadenas 
{
  public static void main(String[] args) 
  {
    String cadena1 = "Bienvenido a ";
    String cadena2 = "Buenas Intenciones";
        
    String cadena3 = cadena1.concat(cadena2);
    String cadena4 = cadena1 + cadena2;
        
    System.out.println(cadena3);
    System.out.println(cadena4);
  }
}

En la linea 11 y 12 hemos declarado e inicializado dos variables de tipo String, en la linea 14 usaremos el método concat, para concatenar (unir) la cadena1 y cadena2, como se puede observar para hacer esto, se declaro una tercera variable (cadena3), en donde se guardara la nueva String, en otras palabras, lo que estamos diciendo en esta linea es: A cadena3 le vas a asignar la cadena1 concatenada con la cadena2.

En la linea 15 estamos haciendo lo mismo, solo que en vez de usar el método concat, estamos usando el signo +. El resultado es el siguiente:

Instalación de Java en Ubuntu

2013-05-14T19:57:00.000-05:00

Para instalar java en ubuntu existen diferentes métodos, pero la manera mas fácil y sencilla, es usando la terminal. Lo único que necesitamos hacer es lo siguiente:

1.- Abrimos una terminal.

2.- Actualizamos repositorios con sudo apt-get update y presionamos enter.

3.- Escribimos sudo apt-get install openjdk-7-jre y presionamos enter.

4.- Nos preguntara ¿Desea continuar [s/n]? Para instalar colamos una s y para cancelar una n, después presionamos enter.

Esperamos a que haga la descarga y después realice la instalación...

5.- Escribimos sudo apt-get install openjdk-7-jdk y presionamos enter.

El paso 4 se repite de nuevo.

6.- Para comprobar que todo se ha instalado correctamente escribiremos java -version

El resultado debe ser el siguiente:

Y eso es todo, ahora ya esta instalado Java.

Pilas (Stack)

2013-04-26T00:25:00.001-05:00

Una pila o stack es una lista de elementos a la cual se le pueden insertar o extraer elementos solo por uno de sus extremos. Las pilas son estructuras de datos en las que la inserción de datos se hace por el frente y la eliminación de los datos de igual manera se hace por el frente, se elimina un dato por el mismo lado de donde se inserta; debido a esta característica de inserción y eliminación de datos también se le conoce como estructura LIFO (Last-In, First-Out: Ultimo en entrar, primero en salir).

Una representación analógica de una pila con objetos cotidianos, podría ser una pila de platos: En una mesa se colocan muchos platos uno encima del otro (una pila de platos), para colocar un nuevo plato en la pila se coloca el plato en la cima de la pila. Para sacar un plato de la pila es necesario sacar el plato que esta encima de la pila (el ultimo plato que fue colocado en la pila de platos).

(a) Una pila de libros. (b) Una pila de CD's. (c) Una pila de platos.

Al igual que en en la analogía de la pila de platos, en las pilas de datos la información se almacena de la misma manera y se inserta nueva información y se elimina un dato del mismo modo. Ahora, para comodidad del lector vamos a representar una pila de datos de la siguiente manera:

En la figura anterior podemos observar una pila de datos con 4 elementos apilados. Podrían ser 4 elementos de cualquier tipo, hablando de programación en Java podrían ser: int, string o incluso objetos.

Las pilas son estructuras de datos generalmente estáticas ya que regularmente se crean usando la implementación de arreglos, y como se sabe: su tamaño no puede crecer en memoria en tiempo de ejecución es decir, debemos establecer un tamaño fijo de elementos que se guardaran en la pila. Las Stack tienen 2 operaciones básicas: push (apilar, insertar) y pop (desapilar o eliminar), aunque se puede implementar más métodos a una pila para obtener alguna otra información que se requiera.

➮ Pila vacía y llena.

En la siguiente figura se representan 2 pilas de tamaño de 5 elementos: la primera pila esta vacía (Empty Stack) y la segunda pila esta llena (Full Stack).

En la figura anterior se representa una pila vacía cuando no tiene ningún elemento insertado; y la pila llena cuando tiene la capacidad máxima de elementos que le hemos asignado para insertar. La pila vacía no tiene ningún elemento, sin embargo tiene espacio para almacenar 5 elementos como máximo, como no tiene ningún elemento insertado no es posible eliminar algún elemento de la pila, sin embargo en Java si se intentara eliminar algún elemento de una pila vacía generaría un error de subdesordenamiento; mientras la pila llena tiene espacio para almacenar 5 elementos, los cuales ya están insertados en la pila y ya no puede insertarse ningún elemento más; en Java si se intentara insertar otro elemento más a la pila arrojaría un error de desbordamiento.

➮ El tope de la pila.

El tope de la pila es el elemento que se encuentra en la cima de la pila. Aquí se representan 4 pilas con sus respectivos topes en diferente posición cada uno:

Cuando se crea una pila por medio de arreglos es importante recalcar que tiene las características del arreglo mismo (Un arreglo tiene un nombre propio y para acceder a cada uno de sus datos es necesario hacer mención del nombre de arreglo y del subíndice [posición] donde esta el dato que queremos obtener).

Para obtener información sobres el tope de una pila solo se tiene que escribir una instrucción donde hagamos referencia al nombre del arreglo y el subíndice que contenga el ultimo elemento insertado en la pila.

Por ejemplo, para la Pila A el tope es -1 debido a que es una pila vacía y no contiene ningún elemento insertado. En la Pila B el tope esta en el subíndice 2 y contiene el elemento [3 verde]. En la Stack C el tope esta situado en el subíndice 4 que contiene al elemento [5 rojo] y es el tamaño máximo de la pila. En la Pila D el tope esta en la posición 0 y contiene [1 Lila].

➮ Push & Pop.

Las operaciones básicas de la pila son: insertar un elemento (push) y quitar un elemento (pop).

PUSH: cuando se ejecuta la instrucción Push en una Pila, se ejecuta un algoritmo que inserta un elemento dentro de la pila de datos. Suponga que queremos insertar el numero 5 en una pila de números:

En la imagen anterior hay una pila de números de tamaño 5 (osea que se pueden insertar hasta 5 números). En la pila solo existen 4 números insertados (1,2,3 y 4) que ocupan desde la posición 0 hasta la posición 3 de la pila. Cuando ejecutamos la instrucción Push(5); indicamos que se va a inserta el numero 5 en nuestra pila, de este modo el numero 5 que sera insertado quedara ocupando la posición 4 de nuestra pila.

POP: cuando se ejecuta la instrucción Pop en una pila se esta indicando que queremos borrar el elemento que se encuentre en la cima de nuestra pila:

Para este ejemplo se tiene una pila con 5 elementos insertados (1,2,3,4 y 5), estos van desde la posición 0 hasta la posición 4; Cuando indicamos una instrucción Pop() se elimina el ultimo elemento insertado (el elemento de la cima de la pila), de este modo el ultimo elemento insertado en la pila (el numero 5, en la posición 4) se elimina de la pila.

➮ Hagamos código.

Este programa esta orientado a objetos y cuenta con 2 clases: La clase Pila y la clase Principal. Es necesario mencionar que en esta ocasión programaremos una pila tradicional, una pila en su modo mas sencillo que solo insertara y eliminara datos en la pila; En la clase pila declararemos los atributos que contiene una pila y programaremos sus métodos a utilizar (push y pop); mientras que en la clase principal crearemos objetos de la clase pila y crearemos una sencilla interfaz en consola para poder utilizar la pila.

La clase Pila:
Primero creamos la clase Pila, que contendrá como atributos: MAXIMO: que es un numero entero el cual indica el tamaño de la pila (para este caso le asignaremos: 5); stack: sera un arreglo de enteros donde se almacenaran los elementos de la pila; y tope: que sera nuestro apuntador para saber cuando la pila esta llena o vacía o en que espacio del arreglo insertar un elemento, este deberá ser de tipo entero, a tope lo inicializaremos en -1, debido a que cuando iniciemos la pila esta sera vacía.

/**
 * Archivo: Pila.java
 * @author Anibal Clavel
 * www.buenasintencions.blogspot.mx
 */

//Inicia la clase pila.
public class Pila {
    
    //Declaracion de atributos a utilizar.
    private final int MAXIMO = 5;
    private int stack[];
    private int tope;
    
    //Constructor.
    public Pila(){
        stack = new int[MAXIMO];
        tope = -1;
    } //Fin del constructor.
    
    //Metodo para insertar.
    public void push(int numero){
        if(tope < MAXIMO-1){
            ++tope;
            stack[tope] = numero;
        }
        else
            System.out.println("Desbordamiento");
    } //Fin de Push.
    
    //Metodo para eliminar.
    public void pop(){
        if(tope >= 0)
            tope = tope-1;
        else
            System.out.println("Subdesordenamiento");
    } //Fin de Pop.
} //Fin de la clase Pila.

Analicemos nuestra clase Pila: De la linea 11 a la 13 se están declarando los atributos tal como lo mencionamos anteriormente. Posterior a eso armaremos nuestros métodos que son solo 2 (push y pop), de tal modo que podamos realizar las operaciones de la pila con estos.

Constructor:

En la linea 16 iniciamos la codificación de nuestro constructor el cual de primer tarea inicializa nuestro arreglo stack y le asigna de tamaño lo que contiene MAXIMO, en otras palabras: se crea un arreglo stack de tamaño 5.

Push:

Bien, pasemos a nuestro método push para insertar un elemento en la pila, iniciamos en la linea 22, donde establecemos que es un método publico con public, después con void indicamos que es un método que no retorna nada, push es el nombre del método, (int numero) es una variable que declaramos para ese método y que nos sirve como un parámetro de entrada (el dato que se insertara).

En la linea 23 iniciando el cuerpo del método (lo que el método realiza), hacemos una validación con un if para verificar si tope es menor que MAXIMO-1; recordemos que tope es un apuntador del arreglo stack, tope indica la posición o subíndice donde nos encontramos situados en el arreglo stack. MAXIMO es el tamaño de nuestro arreglo y este valor es 5 (para este ejemplo), entonces, al indicar MAXIMO-1 lo que hacemos realmente es indicar 5-1, esto resulta 4, ya que 4 es el ultimo subíndice de el arreglo stack. Entonces el algoritmo evalúa y si la condición resulta true entonces deducimos que el arreglo (la pila) tiene espacio e inserta el elemento que le proporcionemos. Para cuando sea la primera inserción de datos la pila estará vacía y el tope sera igual a -1, en la linea 24 tope hace un pre incremento de tal modo que tope obtenga el valor de 0. En la linea 25 insertamos en el arreglo en la posición tope (para entonces tope ya vale 0) ya que esta el la primera posición dentro de nuestro arreglo stack; para simplificar la linea 25 decimos que el elemento (el parámetro del método push) es insertado en el arreglo stack en la posición tope.

Cuando ya haya un elemento insertado se realiza la misma validación con if: "¿tope es menor que MAXIMO-1?" y arrojara un true, entonces se ejecutara nuevamente la linea 24 haciendo un pre incremento a tope y entonces tope ya valdrá 1 y en esa posición del arreglo se insertara el nuevo elemento, y así sucederá hasta que la pila este llena.

Si la validación con el if en la linea 23 resulta false, esto significara que tope ya tendrá el valor de 4 (cuatro es la ultima posición de nuestro arreglo stack) por tal motivo tope no sera menor que MAXIMO-1, entonces el método solo mandara un mensaje que indique que hay un desbordamiento porque la pila esta llena y ya no se pueden insertar mas elementos.

Pop:

Para el método pop que inicia en la linea 32, es un método publico que no retornará ningún valor, también es un método que no recibe ningún parámetro, debido a que no insertara nada y no necesitara ningún valor porque solo eliminará un dato de la pila. Ya en la linea 33 realizamos una validación con if para saber si la pila contiene elementos o esta vacía, de este modo la función del if es preguntar: "¿tope es mayor igual que 0?", si la respuesta es un true significara que la pila contiene elementos debido a que tope que es el apuntador del indice donde nos encontramos situados en nuestro arreglo stack es mayor o igual a 0 y la posición del arreglo sera valida, así que se pasara a la linea 34 donde a tope se le asignara el valor que tenga tope en ese momento menos 1 (tope-1). De este modo se hace una re-asignación del apuntador tope.

Ejemplo: si en la pila tenemos insertados 3 elementos, tope contendrá el valor de 2 que es el subíndice del arreglo stack donde estamos posicionados, cuando hagamos pop, a tope se le resta 1, de tal modo que después tope valdrá 1 y en ese subíndice del arreglo estaremos ubicados ahora, para cuando se haga un push con base en su algoritmo: tope incrementara en uno y volverá a tener el valor de 2 y en ese subíndice del arreglo se posicionara y sobrescribirá el nuevo valor en esa posición de tal modo que borra el valor contenido ahí y escribe el nuevo valor a insertar.

Si en la linea 33 la validación del if arroja un false entonces entenderemos que el valor de tope es menor a 0 y tope tendrá el valor de -1, esto querrá decir que la pila esta vacía y que no hay datos para borrar, de tal modo que el método enviara un mensaje que informe que la pila esta vacía y que hay un error de subdesordenamiento.

La clase Principal:

Bien, una vez terminado la clase Pila, crearemos objetos de dicha clase en nuestra clase principal para hacer uso de sus métodos y así manipular una pila.

/**
 * Archivo: Principal.java
 * @author Anibal Clavel
 * www.buenasintencions.blogspot.mx
 */

import java.util.Scanner;

public class Principal {
    
    public static void main (String args[]){
        
        Pila pila = new Pila();
        Scanner scanner = new Scanner(System.in);
        String respuesta = "Si";
        int valor = 0;
        
        System.out.println("*** Bienvenido al programa Pila ***"
                + "\n\npila de enteros, tamaño: 5...\n"
                + "se ha creado la pila.\n");
        
        while(respuesta.equalsIgnoreCase("Si")){
            
            System.out.println("¿Que Operacion desea realizar?"
                    + "\n1. Push.\n2. Pop.\n");
            valor = scanner.nextInt();
            
            switch(valor){
                case 1:
                    System.out.println("Selecciono: Push");
                    System.out.println("Ingrese un numero a insertar: ");
                    valor = scanner.nextInt();
                    pila.push(valor);
                    System.out.println();
                break;
                case 2:
                    System.out.println("Selecciono: Pop");
                    pila.pop();
                    System.out.println();
                break;
                default:
                    System.out.println("Opcion no valida");
                    System.out.println();
            }
            
            System.out.println("¿Desea continuar?"
                    + "\nEscriba << si >> para continuar"
                    + "\nEscriba << no >> para salir");
            respuesta = scanner.next();
            System.out.println();
        }
    }
}

Este es un programa que contiene un menú con algunos adornos, usando un ciclo while, un switch, métodos de la clase String como el .equalsIgnorecase() a los cuales no les prestaremos mucha atención. Solo daremos una explicación muy general sobre esto: El while y el método .equalsIgnoreCase() los usamos para que el programa termine hasta que el usuario lo indique; El switch lo usamos como apoyo a un menú para que el usuario pueda elegir que operación (push o pop) desea realizar a su pila.

En este programa usamos la clase Scanner y sus métodos para obtener respuestas del usuario. Así que crearemos un objeto Scanner para usarlo a conveniencia del programa; También creamos un objeto de nuestra clase Pila (que es la que definimos anteriormente) y a nuestro objeto le asignamos el nombre de "pila" para poder usar sus métodos.

De la linea 24 a la 28 el programa preguntara al usuario que operación desea realizar, si el usuario responde insertando el valor de 1, entonces en la linea 29 se ejecutara el case 1 del switch y aquí enviamos un mensaje al usuario pidiendo que ingrese el numero que desea insertar en la pila, cuando el usuario introduce el valor haremos uso de nuestro objeto pila de la clase Pila y llamaremos a su método push (esto sucede en la linea 33) y le pasamos de parámetro el valor que el usuario nos ha proporcionado y de este modo se ejecutara el algoritmo del meto push que escribimos en la clase Pila y quedara insertado el valor en la pila.

De la linea 24 a la 28 si el programa hubiese recibido de respuesta el valor de 2, entonces se pasaría hasta la linea 36 donde entraría al case 2 del switch y ahí solo se hace de nuestro objeto pila de la clase Pila, quien manda a llamar a su método pop que no recibe parámetros esto pasa en la linea 38, cuando el objeto pila manda a llamar al meto pop, este ejecuta el algoritmo que codificamos en la clase Pila y "elimina" el ultimo elemento que fue insertado.

Esto es todo el funcionamiento general de una pila de datos.

Longitud de un arreglo

2013-04-24T20:47:00.000-05:00

Al manejar arreglos, nos es de mucha ayuda mucho saber su longitud. Pero no solo su longitud de capacidad nos puede ser de ayuda, hay ciertos casos en los que podríamos llegar a necesitar saber la longitud de cada elemento que se encuentra dentro de nuestro arreglo. Para esto, el siguiente programa te muestra una forma de hacerlo.

/**
 * Archivo: LongitudDeUnArreglo.java
 * @author Bello Cerecero
 * @since 24/04/2013
 * @version 1.0
 */
public class LongitudDeUnArreglo 
{
  public static void main(String[] args) 
  {
    String[] arreglo = new String[10];
    arreglo[0] = "Hola";
    arreglo[1] = "Tarde";
        
    System.out.print("La longitud del arreglo es: ");
    System.out.println(arreglo.length);       
    System.out.print("La long. del dato en la posicion 0 es: ");
    System.out.println(arreglo[0].length());
    System.out.print("La long. del dato en la posicion 1 es: ");
    System.out.println(arreglo[1].length());
  }
}

El programa lo que haces es: crear un arreglo de tipo String con una longitud de 10 (linea 11).

Después, al arreglo en la posición 0 le asignamos la String "Hola" y en la posición 1 le asignamos la String "Tarde" (lineas 12 y 13).

Ahora en la linea 15 imprimimos en consola solamente, en la linea 16 colocando el nombre de nuestro array que para este ejemplo es: "arreglo" y llamando al método "length", nos imprimirá en consola la longitud del arreglo, que para este ejemplo es 10.

En la linea 16 imprimimos en consola solamente. En la linea 17 haciendo referencia al elemento que se encuentra en la posición 0 dentro del arreglo y llamando al método "length()" (la diferencia con el anterior método son los paréntesis), esto nos retornara la longitud del elemento "Hola" que es 4.

Lo mismo pasa en la linea 18.

La salida del programa es la siguiente:

Conversión de grados a radianes

2013-04-23T19:45:00.000-05:00

Este método te ayudara a resolver tu conversión de grados a radianes, solo tienes que pasarle el angulo al que quieres hacer la conversión.

public double conversionGaR(double angulo)
{
  double radianes = (angulo*3.14169)/180;
  return radianes;
}

Bien, como vemos es un método muy simple, con un solo parámetro (el angulo) y al hacer la operación retornara la conversión (double).

Uso de la palabra THIS

2013-04-18T23:55:00.000-05:00

La palabra this es una referencia al propio objeto en el que estamos. Supongamos que en un método un parámetro tiene el mismo nombre que alguna de nuestra variable de clase, entonces para poder distinguir la sentencia sería de la siguiente manera: this.nombreVariable = nombreParametro

Existen otros tres posibles usos para la palabra this, estos son:

- this.atributo. Para acceder a una propiedad del objeto actual.

- this.método(parámetros). Permite llamara un método del objeto actual con los parámetros indicados.

- this(parámetros). Permite llamar a un constructor del objeto actual. Esta llamada sólo puede ser empleada en la primera línea de un constructor.

Estos tres usos serán vistos en otras publicaciones, por ahora solo veremos como se hace la referencia al objeto actual. Para esto se realizo el siguiente programa:

/**
 * Archivo: PalabraThis.java
 * @author BelloCerecero
 * @version 1.0
 * @since 18-abril-2013
 */

public class PalabraThis 
{
   private int puntoX;
   private int puntoY;

   public void actualizar(int puntoX, int puntoY)
   {
      this.puntoX = puntoX;
      this.puntoY = puntoY;
   }
}

Bien, como vemos tenemos dos variables atributos, que son "puntoX" y "puntoY" y creamos un método al que llamamos "actualizar" que recibe dos parámetros que tienen el mismo nombre que nuestras variables atributo, entonces en la linea 15 a la variable "puntoX" le agregamos la palabra reservada "this" así que queda de la siguiente manera "this.puntoX", al hacer esto estamos dejando en claro que hacemos referencia a la variable atributo y no al parámetro. Así que a la variable atributo se le asignara el parámetro "puntoX" (sin la palabra reservada this) lo mismo pasa en la linea 16.

Método split

2013-03-03T22:27:00.000-06:00

Supongamos que tenemos la siguiente String: "1,2,3,4,5,6"

Ahora, lo que queremos es "meterla" en un arreglo. Pero de forma independiente cada uno de los valores, es decir, que en cada indice quede un elemento.

indice[0] = 1

indice[1] = 2

indice[2] = 3

indice[3] = 4

indice[4] = 5

indice[5] = 6

Entonces este método nos es de mucha ayuda, ya que solo le tenemos que pasar de parámetro un delimitador (en este caso seria la coma ","), esto quiere decir que al llamar al método quedaría de la siguiente forma:

aquiVaLaCadena.split(",");

Bien para ejemplificar mejor veamos el siguiente código que implementa este método.

/**
 * @author BelloCerecero
 * @since 3-marzo-2012
 */

public class MetodoSplit 
{
    public static void main(String [] args)
    {
        String cadena = "1,2,3,4,5,6,7,8,9";
        String[] arreglo = cadena.split(",");
        
        for(int i = 0; i < arreglo.length; i++)
        {
            System.out.println("indice " + i +" = "+arreglo[i]);
        }
    }
}

Comencemos en la linea 10, aquí estamos declarando e inicializando una variable de tipo String que tiene: "1,2,3,4,5,6,7,8,9". En la linea 11 viene la utilización del método split, pero ¿Que estamos haciendo realmente? Pues bien primero estamos declarando un arreglo de tipo String y le asignaremos lo que tiene cadena pero con una particularidad, ya que al agregar el método split estamos diciendo que cada vez que se encuentre un limitador (que en este caso es una "coma")se guardara en un indice diferente.

La salida del programa es la siguiente:

Limitar el número de decimales

2013-02-28T22:33:00.000-06:00

En ciertas ocasiones al manejar números con decimales, al imprimirlos en consola o al mostrarlos en un JTextField salen números con demasiados decimales. Por ejemplo 9.78863242729

Y si solo necesitamos que muestre tres decimales? (Que imprima: 9.788)

Bueno, con este pequeño código podemos solucionar este tipo de inconvenientes pero algo importante que tengo que recalcar, es que NO CAMBIA EL VALOR DEL NUMERO, es decir, que solo le da formato para que lo muestre, ya sea en consola o en un JTextField.

package ejemplos;
import java.text.DecimalFormat;
/**
 * Archivo: MostrarDecimales.java
 * @author BelloCerecero
 * @since 28-02-2013
 */
public class MostrarDecimales 
{
    public static void main(String[] args) 
    {
      DecimalFormat decimales = new DecimalFormat("0.0000");
      double numero = 7.936427373645;

      System.out.println(decimales.format(numero));
    }
}

Bien, comenzamos en la linea 2, para poder hacer uso de la clase DecimalFormat que es la que nos permitirá hacer nuestro formato de decimales, debemos importarla.

Ya estando en el main, instanciamos la clase DecimalFormat (linea 12).

Y como se puede observar le estamos pasando como parámetro una String "0.0000" este sera el formato que tendrá nuestro numero al imprimirlo, es decir, que si yo quiero que solo muestre dos decimales, entonces debo de poner como parámetro una String "0.00".

Ahora declaramos e inicializamos una variable de tipo double con el valor de 7.936427373645 (Linea 13). Entonces al imprimir deberá de mostrar en consola: 7.9364

Para probar que esto es cierto en la linea 15 utilizando un System.out.println ponemos nuestro instancia de clase "decimales" y usando el método format(), que recibe de parámetro el numero al que dará formato.

Manejo De Imagenes

2013-01-21T23:54:00.000-06:00

Para el manejo de imágenes en java, utilizamos dos clases de la librería swing, que seria JLabel y ImageIcon, con estas podemos realizar una clase con la cual iremos actualizando la imagen cada vez que queramos. Definimos nuestra clase de la siguiente manera:

import javax.swing.ImageIcon;
/**
 * Archivo: ManejoImagen.java
 * @author BelloCerecero
 * @since 6/09/2011
 */
public class ManejoImagen 
{
    private String nombreImagen;
    private ImageIcon imagen;
    
    public ManejoImagen(String nombreImagen)
    {
 this.nombreImagen = nombreImagen;
 imagen = new ImageIcon(nombreImagen + ".gif");
    }
    
    public ImageIcon getImagen()
    {
 return imagen;
    }
    
    public void setImagen(String nuevaImagen)
    {
 imagen = new ImageIcon(nuevaImagen + ".gif");
    }
    
    public String getNombreImagen()
    {
 return nombreImagen;
    }
    
    public void setNombreImagen(String nuevoNombre)
    {
 nombreImagen = nuevoNombre;
    }
}

En la linea uno importamos la clase ImagenIcon, ya dentro de la clase definimos nuestras variables privadas, en este caso sería el nombre de la imagen que es de tipo String y la imagen que es de tipo ImageIcon. El constructor recibirá de parámetro el nombre de la imagen para que así podamos pasársela de parámetro a nuestra imagen (linea 15). Ahora ya solo hacemos los getters y setters de nuestras variables de clase, que actualizaran la imagen y la retornaran. Esta es un simple prueba de como funciona la clase ManejoImagen:

 /**
  * Archivo: PruebaImagen.java
  * @autor BelloCerecero
  * @since 21-01-2013
  */
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class PruebaImagen 
{
    public static void main(String[] args) 
    {
 JFrame ventana = new JFrame("Imagenes");
 JPanel contenedor = new JPanel();
 JLabel etiquetaImagen = new JLabel();
 ManejoImagen imagen = new ManejoImagen("+");
 
 etiquetaImagen.setIcon(imagen.getImagen());
 contenedor.add(etiquetaImagen);
 ventana.add(contenedor);
 ventana.pack();
 ventana.setVisible(true);
 
 imagen.setImagen("-");
 etiquetaImagen.setIcon(imagen.getImagen());
    }
}

Para esto utilizamos un JFrame (una ventana), un JPanel (un contenedor) y un JLabel (una etiqueta). Instanciamos cada uno de ellos (lineas de la 14 a la 16) y también instanciamos nuestra clase ManejoImagen (recuerden que aquí le deben de poner el nombre de la imagen). En la linea 19 a la etiqueta le vamos a actualizar el icon (la imagen) pasando le de parámetro el getter de la imagen. ya solo agregamos la etiqueta al contenedor (linea 20) después agregamos el contenedor a la ventana (linea 21) y con el método "pack" le estamos diciendo a la ventana que tome el tamaño de la imagen. El método "setVisible" es para mostrar la ventana. Ya después solo tendremos que ir actualizando la imagen.

Así queda:

*** NOTA: En este programa no se vera como se realiza el cambio de imagen ya que no estamos manejando Timer o Threads.

Estructura básica de un programa orientado a objetos

2013-01-21T22:41:00.001-06:00

Al utilizar POO hacemos que los problemas sean mas sencillos de resolver, ya que lo dividimos en partes. Ahora estas divisiones (por así llamarlos) son los objetos, pero no podemos utilizarlos sin antes haber creado la clase y así poder hacer la instancia de clase. Bien para aclarar esto haremos el muy utilizado ejemplo de una persona. Primero que nada debemos pensar el nombre que llevara la clase, en este caso no hay necesidad de tanto pensarle ya que "Persona" es mas que claro. Ahora tenemos que identificar todos los atributos de una persona, los cuales pueden ser: la edad, estatura y color de pelo.

Solo usaremos esas, bien ya que tenemos definidos los atributos de la clase tendremos que asignarle el tipo de dato mas conveniente, en el caso de la edad sería de tipo int, la estatura sería double y el color de pelo sería String.

Ya bien definidas nuestras variables de clase, continuamos a programar. El programa tendrá una estructura, que es la siguiente:

1) Declaración de variables.
2)Constructor.
3) Métodos.

Entonces declaramos las variables de clase, dependiendo el caso pueden llevar la palabra reservada: public, protected o private.

private int edad;
private double estatura;
private String colorPelo;

El constructor recibirá de parámetros la edad, la estatura y el color de pelo. Y utilizando la palabra reservada "this" (para hacer referencia a la variable de clase) asignaremos a cada variable de clase el parámetro correspondiente.

public Persona(int edad, double estatura, String colorPelo)
{
  this.edad = edad;
  this.estatura = estatura;
  this.colorPelo = colorPelo;
}

Algo muy importante que siempre se tiene que tener en cuenta, son los métodos para actualizar y obtener nuestras variables de clase, estos son los llamados getters y setters. Los métodos que lleven la palabra "get" es para retornar lo que tiene la variable de clase y los métodos que llevan la palabra "set" es para actualizar la variable de clase.

public String getColorPelo() 
{
  return colorPelo;
}

public void setColorPelo(String colorPelo) 
{
  this.colorPelo = colorPelo;
}

public int getEdad() 
{
  return edad;
}

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

public double getEstatura() 
{
  return estatura;
}

public void setEstatura(double estatura) 
{
  this.estatura = estatura;
}

El programa completo quedaría de la siguiente forma:

/**
 * Archivo: Persona.java
 * @author Bello Cerecero
 * @since 25/01/2012
 */
public class Persona 
{
    private String colorPelo;
    private int edad;
    private double estatura;
    
    public Persona(String colorPelo, int edad, double estatura)
    {
      this.colorPelo = colorPelo;
      this.edad = edad;
      this.estatura = estatura;
    }

    public String getColorPelo() 
    {
        return colorPelo;
    }

    public void setColorPelo(String colorPelo) 
    {
        this.colorPelo = colorPelo;
    }

    public int getEdad() 
    {
        return edad;
    }

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

    public double getEstatura() 
    {
        return estatura;
    }

    public void setEstatura(double estatura) 
    {
        this.estatura = estatura;
    } 
}

Introducción a las interfaces gráficas

2012-12-01T18:05:00.000-06:00

A medida que vamos adquiriendo mas conocimientos en el mundo de Java, nos damos cuenta que es indispensable hacer nuestros programas "bonitos" y para eso necesitamos implementar gráficos, imágenes, audio, etc. Por ahora solo verán una pequeñisima y austera parte de como se puede hacer una interfaz sencilla. Este programa es una ayuda para un compañero que recurrió a Buenas Intenciones para despejar ciertas dudas.

Sin mas preámbulos esta es la interfaz que realice:

(El sistema operativo en el que trabaje fue Linux Mint 13 maya)

El código es el siguiente:

/**
 * @author Bello Cerecero
 * @since 1-dic-2012
 */
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Principal extends JFrame implements ActionListener
{
 private JPanel contenedor;
 private JLabel etiquetaToken;
 private JLabel etiquetaResultado;
 private JTextField cajaToken;
 private JTextField cajaResultado;
 private JButton botonAceptar;
 private JButton botonCancelar;

 
 public Principal()
 {
  super("Interfaz");
  getContentPane().setLayout(null);
  setLocation(100,100);
        setSize(380,330);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(false);
        contenedor();
        setVisible(true);
 }
 
 public void contenedor()
 {
  contenedor = new JPanel();
  contenedor.setLayout(null);
  
  etiquetaToken = new JLabel("Tokens");
  etiquetaToken.setBounds(30,30,116,16);
  contenedor.add(etiquetaToken);
  
  cajaToken = new JTextField();
  cajaToken.setBounds(100,25,200,30);
  contenedor.add(cajaToken);
  
  botonAceptar = new JButton("Aceptar");
  botonAceptar.setBounds(30,100,100,30);
  botonAceptar.addActionListener(this);
  contenedor.add(botonAceptar);
  
  botonCancelar = new JButton("Cancelar");
  botonCancelar.setBounds(220,100,100,30);
  botonCancelar.addActionListener(this);
  contenedor.add(botonCancelar);
  
  etiquetaResultado = new JLabel("Resultado");
  etiquetaResultado.setBounds(30,180,116,16);
  contenedor.add(etiquetaResultado);
  
  cajaResultado = new JTextField();
  cajaResultado.setBounds(120,175,200,30);
  contenedor.add(cajaResultado);
  
  setContentPane(contenedor);
 }
 
 public void actionPerformed(ActionEvent evento) 
 {
  if(evento.getSource() == botonAceptar)
  {
   //codigo a ejecutarse al dar clic en aceptar
  }
  else if(evento.getSource() == botonCancelar)
  {
   //codigo a ejecutarse al dar clic en cancelar
  }
 }
 
 public static void main(String args [])
 {
  Principal ejemplo = new Principal();
 }
}

Análisis: Comenzamos en la linea 5, aquí importamos todas las librerías que ocuparemos para la realización de nuestra interfaz (que son la swing y la awt), en la linea 14 comenzara nuestra clase la cual se llama "Principal" que hereda de la clase "JFrame" e implementa "ActionListener".

Aquí haremos un pequeños paréntesis para explicar esto un poco mejor, al decir que nuestra clase "Principal" hereda de la clase "JFrame" estamos diciendo que nuestra clase hereda todos los métodos de la clase "JFrame", así no habrá necesidad de declarar un objeto. Al implementar "ActionListener" estamos diciendo que usaremos su método (que ya se encuentra declarado en esta interface) el cual se llama "actionPerformed", esté método nos servirá para poder manejar los eventos al dar clic en los botones (ya sea en el botón "aceptar" o en el botón "cancelar").

Continuando con el análisis, en la linea 16 comenzaremos con la declaración de nuestras variables, como vemos ocuparemos un "JPanel" (linea 16) que tomara el papel de un "contenedor" donde estarán los botones, las etiquetas y los cuadros de texto (En la siguiente imagen se describe lo que vendría siendo el JPanel (color rojo)).

Se ocuparan dos etiquetas "JLabel" una que es la que dice "Token" y la otra es la que dice "Resultado" (La siguiente imagen muestra cuales son las etiquetas (color azul)).

También usaremos dos cajas de texto (linea 19 y 20) y dos botones (linea 21 y 22).

En la linea 25 declaramos nuestro constructor, en la linea 27 con "super" pondremos el titulo que tendrá nuestra ventana en este caso "Interfaz", en la linea 28 lo que se esta haciendo es decirle que la ventana no tendrá diseño, en la linea 29 se usa para dar la localización que tendrá la ventana en nuestra pantalla, en la linea 30 definimos el tamaño de la ventana, en la linea 31 estamos configurando en botón "cerrar" (la "x" que tienen las ventanas en la barra de titulo) para que al dar clic en ella el programa se detenga, en la linea 32 estamos configurando la ventana para que no pueda cambiar su tamaño, en la linea 33 estamos llamando al método contenedor y en la linea 34 hacemos que la ventana se visible.

En el método "contenedor" (linea 37) configuramos todos los componentes (posición y tamaño), primero creamos un objeto de tipo JPanel (linea 39), este panel no tendrá diseño (linea 40).

Comenzaremos a configurar la etiqueta token:

Primero declaramos un objeto de la clase "JLabel" al cual le pasaremos de parámetro como queremos que se visualice en la ventana, en este caso sera "Tokens" (linea 42), después definimos la posición y las dimensiones que tendrá la etiqueta (linea 43) y por ultimo lo agregamos al contenedor (linea 44).

Ahora va la caja de texto de la etiqueta Tokens:

Primero creamos el objeto del tipo JTextFiel el cual no recibe parámetros (linea 46), después le damos la posición y las dimensiones (linea 47) y por ultimo lo agregamos al contenedor (linea 48).

Ahora configuramos el botón Aceptar:

Primero creamos el objeto de tipo JButton pasando-le de parámetro el nombre que llevara el botón en este caso "Aceptar" (linea 50), después definimos la posición y dimensiones que tendrá (linea 51), ahora le añadiremos la acción para poder "reconocer" cuando hagan clic en este botón (linea 52) y por ultimo lo añadimos al contenedor.

Para los objetos restantes se hace lo mismo. al terminar de configurar todo, ahora agregamos el contenedor a la ventana (linea 68).

Como ya les había mencionado al inicio, al implementar ActionListener tendremos que usar el método "actionPerformed" (linea 71) que recibe de parámetro el evento, que este caso seria cuando le demos clic a cualquier botón, y para poder distinguir cual fue el botón que recibió el clic usamos un if (linea 73). Y ya para poder probar el programa hacemos un main (linea 83).

Convertir de String a char

2012-10-16T19:13:00.001-05:00

Para convertir de String a char deberemos tomar en cuenta que las variables char solo almacenan una solo carácter así que si tenemos una String que contiene mas de un caracteres deberos convertirlos a char e ir guardándolo los caracteres en un arreglo char. Para que quede mas claro todo esto hice un programa que ejemplifica todo lo anterior.

package Conversiones;
/**
 * Archivo: Conversiones.java
 * @author BelloCerecero
 * @since 16/10/2012
 */
public class Conversiones
{
  public static void main(String [] args)
  {
    //Cuando leemos una sola letra.
    String cadena = "A";
    char letra = cadena.charAt(0);
    System.out.println(letra);
    System.out.println("");
 
    //Cuando leemos una serie de letras.
    String cadena_de_caracteres = "ndnpsituylznchsp";
    char array_caracteres [] = cadena_de_caracteres.toCharArray();

    //imprimimos el arreglo
    for(int i = 0; i < array_caracteres.length; i++)
    {
      System.out.print(array_caracteres[i]);
    }
  }
}

Como vemos en la linea 12 tenemos una variable de tipo String que tiene almacenada la letra "A" en este caso, como es solo un carácter, con el método charAt de la clase String podemos hacer la conversión, pasando-le de parámetro el numero 0 por que es el indice en el que se encuentra la letra "A" en la String. En la linea 18 tenemos una variable de tipo String que tiene almacenado una serie de caracteres y como las variables char solo pueden almacenar un solo caracter, lo que haremos sera guardar todos los caracteres en un arreglo de tipo char. Para poder realizar esto tendremos que usar el método toCharAt de la clase String, este método lo que hace es convertir toda la cadena a char pero lo almacena en un arreglo. Así que solo se lo asignamos a nuestro arreglo.

Operaciones con caracteres en matrices

2012-10-15T21:22:00.002-05:00

El manejo de caracteres siempre es de mucha utilidad, sobre todo cuando trabajan con Autómatas. En este programa que hice, define algunos métodos para hacer operaciones con cierta cantidad de caracteres que los guarde en una matriz de 5x5. El programa es estructurado, muy bien comencemos.

    private static char arregloB[][];
    private static int filas = 5;
    private static int columnas = 5;

Pues como les había mencionado que el programa es estructurado, las variables son estáticas para que las pueda utilizar en el main sin necesidad de instancias, la primera variable es arreglo bidimensional de tipo char (solo esta declarado), la segunda es una variable de tipo entero y la llame fila (guarda las filas que tendrá la matriz) y por ultimo la tercera variable que también es de tipo entero y la llame columnas (guarda las columnas que tendrá la matriz).

public static boolean llenarArregloB(String cadena)
{
   //Checamos que los caracteres quepan en la matriz
   if(cadena.length() > (filas*columnas))
      return false;
   else
   {
      arregloB = new char [filas][columnas];
      int contador = 0;
   
      for(int i = 0; i < filas; i++)
      {
         for(int j = 0; j < columnas; j++)
         {
            if(contador < cadena.length())
            {
               arregloB[i][j] = cadena.charAt(contador);
               contador += 1;
            }
            else 
               break;
         }
      }
      return true;
   }
}

Define un método al que que llame llenarArregloB y este recibe de parámetro una cadena (en la que vienen todos los caracteres que el usuario introdujo), aquí en este método también inicializamos la matriz, y con dos for anidados procedemos a rellenar la matriz, pero como todos los caracteres viene en una sola cadena, utilizaremos el método charAt para pasarlos a tipo char.

public static void imprimir()
{
   for(int i = 0; i < filas; i++)
   {
      for(int j = 0; j < columnas; j++)
      {
         System.out.print(arregloB[i][j] + "\t");
      }
      System.out.println("");
   }
}

Con este método imprimiré la información de la matriz.

public static void ordenar()
{
   for( int i=0; i < filas; i++)
   {
      for( int j=0;j< columnas; j++)
      {
         for(int x=0; x < filas; x++)
         {
            for(int y=0; y < columnas; y++)
            {
               if(arregloB[i][j] < arregloB[x][y])
               {
                  char t = arregloB[i][j];
                  arregloB[i][j] = arregloB[x][y];
                  arregloB[x][y] = t;
               }
            }
         }
      }
   }
}

El método de ordenar lo que hace es ordenar los caracteres de forma ascendente (con base al codigo ASCII)

public static void ordenarAlReves()
{
   for( int i=0; i < filas; i++)
   {
      for( int j=0;j< columnas; j++)
      {
         for(int x=0; x < filas; x++)
         {
            for(int y=0; y < columnas; y++)
            {
               if(arregloB[i][j] > arregloB[x][y])
               {
                  char t = arregloB[i][j];
                  arregloB[i][j] = arregloB[x][y];
                  arregloB[x][y] = t;
               }
             }
          }
       }
   }
}

El método ordenarAlReves ordena los caracteres de la matriz de forma descendente (con respecto al código ASCII)

public static void contarMayusculas()
{
   Character c = null;
   int contador = 0;
   for(int i = 0; i < filas; i++)
   {
      for(int j = 0; j < columnas; j++)
      {
         if(c.isUpperCase(arregloB[i][j]))
            contador++;
      }
   }
   System.out.println("Hay " + contador + "Mayusculas\n");
}

El método contarMayuscula va a hacer un recorrido por la matriz y contara las mayúsculas que encuentre para imprimirlas en consola (solo imprimirá en numero de letras).

public static void contarMinusculas()
{
   Character c = null;
   int contador = 0;
   for(int i = 0; i < filas; i++)
   {
      for(int j = 0; j < columnas; j++)
      {
         if(c.isLowerCase(arregloB[i][j]))
           contador++;
      }
   }
   System.out.println("Hay " + contador + "Minusculas\n");
}

El método contarMinusculas va a hacer un recorrido por la matriz y contara las minúsculas que encuentre para imprimirlas en consola (solo imprimirá en numero de letras).

public static void convertirAMayusculas()
{
   Character c = null;
   char aux;
      for(int i = 0; i < filas; i++)
      {
         for(int j = 0; j < columnas; j++)
         { 
            aux = arregloB[i][j];
            arregloB[i][j] = c.toUpperCase(aux);
         }
      }
}

El método contarMayuculas va a hacer un recorrido por la matriz y contara todas las mayúsculas que encuentre (solo imprimirá el numero de mayúsculas).

public static void convertirAMinusculas()
{
   Character c = null;
   char aux;
   for(int i = 0; i < filas; i++)
   {
      for(int j = 0; j < columnas; j++)
      {
         aux = arregloB[i][j];
         arregloB[i][j] = c.toLowerCase(aux);
      }
   }
}

El método contarMinusculas va a hacer un recorrido por la matriz y contara todas las minúsculas que encuentre (solo imprimirá el numero de minúsculas).

public static void main(String[] args) 
{
  String cadena = JOptionPane.showInputDialog("Introduce los" 
                   + " caracteres a evaluar: ");
  llenarArregloB(cadena);
  System.out.println("La matriz queda de la sigueinte manera:");
  imprimir();
  System.out.println("\n Ordenamiento Ascendente: ");
  ordenar();
  imprimir();
  System.out.println("\n Ordenamiento Decendente: ");
  ordenarAlReves();
  imprimir();
  System.out.println("");
  contarMayusculas();
  contarMinusculas();
}

Ahora ya en en main, aquí le pediremos al usuario que introduzca los caracteres con un JOptionPane y mandaremos llamar al método llenarArregloB pasando le como parámetro la cadena y ya después solo tendremos que mandar llamar el método que queramos e imprimir.

código completo:

import javax.swing.JOptionPane;
/**
 * Archivo: Principal.java
 * @author BelloCercero
 * @since 13/10/2012
 */
public class Principal 
{
    private static char arregloB[][];
    private static int filas = 5;
    private static int columnas = 5;
    
    public static boolean llenarArregloB(String cadena)
    {
 if(cadena.length() > (filas*columnas))
     return false;

 else
 {
     arregloB = new char [filas][columnas];
     int contador = 0;
     
     for(int i = 0; i < filas; i++)
     {
  for(int j = 0; j < columnas; j++)
  {
      if(contador < cadena.length())
      {
   arregloB[i][j] = cadena.charAt(contador);
   contador += 1;
      }
      else 
   break;
  }
   }
     return true;
 }
 
    }
    
    public static void imprimir()
    {
 for(int i = 0; i < filas; i++)
 {
     for(int j = 0; j < columnas; j++)
     {
  System.out.print(arregloB[i][j] + "\t");
     }
     System.out.println("");
 }
    }
    
    public static void ordenar()
    {
 for( int i=0; i < filas; i++)
 {
     for( int j=0;j< columnas; j++)
     {
  for(int x=0; x < filas; x++)
  {
      for(int y=0; y < columnas; y++)
      {
   if(arregloB[i][j] < arregloB[x][y])
   {
       char t = arregloB[i][j];
       arregloB[i][j] = arregloB[x][y];
       arregloB[x][y] = t;
   }
      }
  }
     }
 }
    }
    
    public static void ordenarAlReves()
    {
 for( int i=0; i < filas; i++)
 {
     for( int j=0;j< columnas; j++)
     {
  for(int x=0; x < filas; x++)
  {
      for(int y=0; y < columnas; y++)
      {
   if(arregloB[i][j] > arregloB[x][y])
   {
       char t = arregloB[i][j];
       arregloB[i][j] = arregloB[x][y];
       arregloB[x][y] = t;
   }
      }
  }
     }
 }
    }
    
    public static void contarMayusculas()
    {
 Character c = null;
 int contador = 0;
 for(int i = 0; i < filas; i++)
 {
     for(int j = 0; j < columnas; j++)
     {
  if(c.isUpperCase(arregloB[i][j]))
      contador++;
     }
 }
 System.out.println("Hay " + contador + "Mayusculas\n");
    }
    
    public static void contarMinusculas()
    {
 Character c = null;
 int contador = 0;
 for(int i = 0; i < filas; i++)
 {
     for(int j = 0; j < columnas; j++)
     {
  if(c.isLowerCase(arregloB[i][j]))
      contador++;
     }
 }
 System.out.println("Hay " + contador + "Minusculas\n");
    }
    
    public static void convertirAMayusculas()
    {
 Character c = null;
 char aux;
 for(int i = 0; i < filas; i++)
 {
     for(int j = 0; j < columnas; j++)
     {
  aux = arregloB[i][j];
  arregloB[i][j] = c.toUpperCase(aux);
     }
 }
    }
    
    public static void convertirAMinusculas()
    {
 Character c = null;
 char aux;
 for(int i = 0; i < filas; i++)
 {
     for(int j = 0; j < columnas; j++)
     {
  aux = arregloB[i][j];
  arregloB[i][j] = c.toLowerCase(aux);
     }
 }
    }
    public static void main(String[] args) 
    {
 String cadena = JOptionPane.showInputDialog("Introduce los caracteres a evaluar: ");
 llenarArregloB(cadena);
 System.out.println("La matriz queda de la sigueinte manera:");
 imprimir();
 System.out.println("\n Ordenamiento Ascendente: ");
 ordenar();
 imprimir();
 System.out.println("\n Ordenamiento Decendente: ");
 ordenarAlReves();
 imprimir();
 System.out.println("");
 contarMayusculas();
 contarMinusculas();
    }
}

Cualquier duda dejen su comentario.

Switch con cadenas (String)

2012-09-21T17:58:00.004-05:00

Ayer en la noche estaba checando algunos blogs, y me encontré con unos comentarios sobre las novedades de java 7. Y pues son varias cosas que mejoraron, pero hoy solo les dire sobre el switch con cadenas, ya que de por si, con el simple echo de que solo se podía con números y nos era y sigue siendo de gran utilidad, ahora que incluye el manejo de String esta mucho que mejor \(._.)/

En fin sin mas que decir aquí les dejo un ejemplo. Es un programa muy sencillo que solo pide el nombre de un alumno y entra al switch para ver si el nombre que escribimos esta en los casos.

import java.util.Scanner;
/**
 * Archivo: PruebaS.java
 * @author BelloCerecero
 * @sinse 21/09/2012
 */
public class PruebaS 
{
    public static void main(String[] args) 
    {
 Scanner entrada = new Scanner(System.in);
 System.out.println("Introduce el nombre del alumno:\t");
 String alumno = entrada.next();
 
 switch(alumno)
 {
  case "Juan":
      System.out.println("Selecciono al alumno juan...");
      break;
  
  case "Luis":
      System.out.println("Selecciono al alumno luis...");
      break;  
      
  default:
      System.out.println("No selecciono a ningun alumno...");
      break;
 }
    }
}

En la linea 1 como vamos a usar el Scanner lo importamos, de ahí en las lineas 2 a 6 son comentarios simplemente, entonces ya habiendo echo la clase(linea 7) y el main (linea 9) entramos a realizar una pequeña prueba para ver como funciona el Switch con cadenas.

Entonces vamos a la linea 11 donde creamos un objeto de Scanner para poder leer datos que el usuario introduzca por medio de la consola. Ahora en la linea 12 con un System.out.println le pedimos al usuario que introduzca algún nombre y este nombre lo guardamos en una variable de tipo String (linea 13).

Nuestra variable String que en este caso le puse de nombre "alumno" la voy a utilizar para que el Switch la evalue con los case.

Entonces vemos en la linea 15 en el Switch le pasamos la variable alumno y ya dentro del switch solo puse dos case uno donde evaluara si lo que tiene la variable alumno es igual a "Juan" si esto es correcto entrara al case y solo imprimirá en consola "Selecciono al alumno juan..." es lo mismo en el case "Luis" si lo que tiene la variable alumno es igual a "Luis" entonces entrara al case e imprimirá en consola "Selecciono al alumno luis...", si el usuario introdujo otro nombre a "Juan" o "Luis" se ejecutara el "default".

Debemos tener muy en cuenta de que el switch toma en cuenta minúsculas y mayúsculas, así que si escribimos "juan" se ejecutar el default, tenemos que escribir tal y como este en el case en este caso tenemos que escribir "Juan" para que entre correctamente.

Introducción a los métodos

2012-08-23T22:56:00.000-05:00

¡Que tal amigos!, en esta ocasión les hablare acerca del uso de los métodos en java, pero de una forma muy simple, solo para que tengan la idea de como es que funcionan estos; Para ejemplificar esto, hice un programa que verifica si un numero es par o impar.

Para esto hice una clase llamada "NumeroPar.java" esta clase tiene un método llamado "esPar" este método recibe de parámetro un número que sera evaluado para verificar si es par o impar, y si este número mencionado antes es par el método retornara "true" y si el número es impar retornara "false", sin mas preámbulos aquí les dejo el código de la clase "NumeroPar.java" (la descripción del funcionamiento de la clase esta abajo de la misma).

/**
 * Archivo: NumeroPar.java
 * @author @BelloCerecero
 */
public class NumeroPar 
{
    //Constructor.
    public NumeroPar()
    {
    }
    
    public boolean esPar(int numero)
    {
 if((numero % 2) == 0)
     return true;
 
 return false;
    }
}

Comencemos con el análisis linea por linea.

Como se puede observar de la linea 1 a la linea 4 son comentarios que nos sirven solo como referencia, ahora nos ubicamos en la linea 7 (ya dentro de la clase) aquí es nuestro constructor que en esta ocación no tiene nada dentro de el, así quedara ya que a nosotros nos interesa por ahora es el método, muy bien ahora vamos a la linea 11 aquí se encuentra nuestro método.

El método esPar tiene las siguientes características:

es publico (public), retornara un "verdadero" (true) o un "falso" (false) y recibe como parámetro un número.

En la siguiente imagen se describe con mas detalles las partes que llevan los métodos:

Ahora, siguiendo con la clase. Nos vamos a la linea 13 aquí es donde hacemos la operación para saber si el método es par, para esto utilizamos una condición (if) dentro de esta condición hacemos una operación por módulo, que como ya sabemos la operación por modulo lo que hace es una división pero solo retorna el residuo, y como sabemos una de las características de los números pares es que son múltiplos de 2. Así que por lógica al ser divididos entre dos el residuo debe de ser 0, por ende en otras palabras lo que estamos haciendo en la linea 13 es lo siguiente:

"Si residuo de la división de numero entre 2 es igual a cero entonces.... "

En la linea 14 retornamos true si la condición se cumple y en la linea 16 si no se cumple la condición.

Muy bien ahora ya tenemos nuestra clase NumeroPar.java con un método llamado "esPar" el cual recibe de parámetro el cual es evaluado y retorna true si es par de lo contrario retorna false (que no es par). Ahora haremos una clase aparte para probar nuestra clase NumeroPar.java, esta clase de que llamaremos "PruebaNumeroPar.java" lo que hará es pedirle al usuario un numero entero y mostrar un mensaje diciendo si es par o impar, La clase quedaría de la siguiente manera:

import javax.swing.JOptionPane;
/**
 * Archivo: PruebaNumeroPar.java
 * @author @BelloCerecero
 *
 */
public class PruebaNumeroPar 
{
    public static void main(String[] args) 
    {
 String valor;
 int numero;
 NumeroPar numeroPar = new NumeroPar();
 valor = JOptionPane.showInputDialog("Introduce un numero:");
 numero = Integer.parseInt(valor);
 
 if(numeroPar.esPar(numero))
     JOptionPane.showMessageDialog(null,
           "Es un numero par :)");
 else 
     JOptionPane.showMessageDialog(null,
           "No es un numero par :(");
    }
}

Empecemos, en la linea 1 lo que hacemos es importar la librería "JOptionPane" que la utilizaremos para interactuar con el usuario (ventanas), de la linea 2 a la 6 son comentarios de referencia solamente, ya dentro de la clase y el main (linea 11) declaramos una variable de tipo "String" a la que llamaremos valor, esta nos servirá para guardar el numero que introduzca el usuario (pero se guardara como "String" así que lo tendremos que convertir a "int"), en la linea 12 declaramos una variable de tipo "int" que la ocuparemos para hacer la conversión de la variable "String" (valor).

En la linea 13 declaramos e inicializamos el objeto "numeroPar" que es de nuestra clase "NumeroPar". Ahora en la linea 14 a la variable "valor" le vamos a asignar el número que introduzca el usuario (con el "JOptionPane.showInputDialog" que no es mas que una ventanita), pero como el numero que introdujo el usuario lo guardamos en una variable de tipo "String" no podemos hacer la operación por modulo, así que tenemos convertir lo que tenga la variable "valor" a int, eso es lo que hacemos en la linea 15 como vemos a la variable numero (que es de tipo int) le asignamos lo que tenga la variable "valor" (que es de tipo "String") pero convertido a entero (para eso se una esto "Integer.parseInt(valor)") con el Integer.parseInt podemos convertir cualquier String a entero.

Muy bien, ahora nos ubicamos en la linea 17 aquí es donde mandamos traer nuestro método "esPar" para poder describir mejor el como debemos llamar nuestros métodos échenle un vistazo a la imagen siguiente:

Seguimos en la linea 17 aquí usamos un "if" dentro de este mandamos traer nuestro método (ver la imagen de arriba) y como sabemos nos va a retorna un true o un false si es true entramos a la linea 18 donde usaremos un "JOptionPane.showMessageDialog" para mostrar un mensaje en una ventana que diga: "Es un numero par :)", si el método retorna un false entonces se ejecutara el else (linea 20) y entraremos a la linea 21 donde con un "JOptionPane.showMessageDialog" mostraremos un mensaje en una ventana que diga: "No es un numero par :(". Pues eso seria todo amigos, a continuación les dejo una serie de imagines que mostraran como se ejecuta el programa que es de la siguiente manera:

Primero lo ejecute e introduje un numero par (el numero2).

1.- Pide un numero al usuario.

2.- Evalúa el numero y nos dice si es par o impar.

Después lo ejecute y introduje un numero impar (el numero 3).

1.- Pide un numero al usuario.

2.- Evalúa el numero y nos dice si es par o impar.

Eso es todo gracias por visitar nuestro blog.