diciembre 01, 2012

Introducción a las interfaces gráficas

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:

octubre 16, 2012

Convertir de String a char

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.

octubre 15, 2012

Operaciones con caracteres en matrices

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)

septiembre 21, 2012

Switch con cadenas (String)

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.

agosto 23, 2012

Introducción a los métodos

¡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:

agosto 20, 2012

Sucesión de Fibonacci

En matemáticas la Sucesión de Fibonacci es una serie de números, esta serie inicia con 0 y 1, después de estos los siguientes elementos están dados por la suma de los dos anteriores:
     0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89... 
La serie Fibonacci debe tener 2 estados básicos iniciales (el 0 y 1). Se presenta la siguiente tabla para ilustrar mejor el comportamiento de los números de Fibonacci:


El siguiente es un programa que muestra la sucesión de Fibonacci, solo hay que introducirle un numero entero de cuantos números queramos visualizar:
/**
 * http://www.buenasintencions.blogspot.mx/
 * @author Anibal Clavel
 */

import java.util.*;

public class Fibonacci{
    
    public static void main (String[] args){
        
        Scanner entrada = new Scanner(System.in);
        
        System.out.println("¿Cuantos numeros desea ver?:");
        int limite = entrada.nextInt();
        int a=0,b=1,c;
        
        for(int contador=0; contador < limite; contador++){
            c = a+b;
            a = b;
            b = c;
            System.out.print(a+", ");
        }
    }
}

julio 20, 2012

String y char, Un análisis detallado

Esta ocasión hablaremos de letras y números. Haremos un análisis detallado del comportamiento de las cadenas de caracteres String y los caracteres char. Como ya sabemos una cadena de caracteres String en java es manejado como un objeto, una cadena de caracteres va entre comillas dobles, como: "Buenas Intenciones", a diferencia de un char (que no es un objeto) es un tipo de dato primitivo y este va entre comillas simples, como 'B'.

Una cadena de caracteres al ser un objeto, tiene metodos que podemos invocar, por ejemplo en una instruccion para mostrar un mensaje en consola:
System.out.println("buenas intenciones".toUpperCase());
La cadena de caracteres "buenas intenciones" esta llamando a su método toUpperCase() que hace que el mensaje se muestre en mayúsculas.

Los char en cambio aunque se escriben literales, en realidad son valores numéricos enteros, basados en el código ASCII (pronunciado "Asqui"); Por ejemplo el char 'B' en realidad es el numero: 66 (Al final del post dejo la tabla del código ASCII para su apoyo). Entendiendo las diferencias entre String "A" y char 'A' podemos sacar provecho de esto y jugar con ambos... ¡Hagamos código!.
//Archivo: DemoCaracteres.java

public class DemoCaracteres {
    
    public static void main(String args[]){
        
        //Concatenando un int y un string
        System.out.println("Usando un String:");
        for(int contador=0; contador < 5; contador++)
            System.out.println(contador+"A");
        
        System.out.println("\nUsando un char:");
        //Otra prueba; Concatenando char y string
        for(int contador=0; contador < 5; contador++)
            System.out.println(contador+'A');
    }
}
En el programa anterior, hacemos dos experimentos, uno para ver el comportamiento de los String y el otro para mostrar como se comporta un char.

julio 13, 2012

Leer un archivo linea por linea

Esta semana empezamos con nuevas cosas y a emplear nuevas estrategias para hacer mejores publicaciones, en este vídeo tutorial veremos como hacer una clase la cual, al ser implementada podrá leer un archivo .txt linea por linea, el tutorial esta dividido en dos vídeos, a continuación les dejo la primera parte del tutorial, que trata sobre la creación de la clase Archivo.



Esta es la clase Archivo por si quieren implementarla en su computadora.


package TutorialArchivo;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
 * Archivo: Archivo.jva
 * @author Bello Cerecero
 */
public class Archivo 
{
    private File archivo;
    private FileReader archivoLector;
    private BufferedReader buferLector;
    private String linea;
    
    public Archivo(String rutaArchivo)
    {
      archivo = new File(rutaArchivo);
      try 
      {
        archivoLector = new FileReader(archivo);
      } catch (FileNotFoundException error) 
       {
         System.out.println(error.getMessage());
       }
      buferLector = new BufferedReader(archivoLector);
    }
    
    public String leerLinea() throws IOException
    {
      while(buferLector.ready())
      {
        if(!(linea = buferLector.readLine()).equals("\000"))
        return linea;
      }
      buferLector.close();
      return null;
    }
}
Y este es la segunda parte del vídeo tutorial, aquí veremos como implementar la clase Archivo.


Esta es la clase PruebaArchivo.

package TutorialArchivo;
import java.io.IOException;
/**
 * Archivo: PruebaArchivo.java
 * @author Bello Cerecero
 * @since 11/07/2012
 */
public class PruebaArchivo 
{
    public static void main(String[] args) throws IOException 
    {
      Archivo archivo = new Archivo("BI.txt");
      System.out.println(archivo.leerLinea());
      System.out.println(archivo.leerLinea());
      System.out.println(archivo.leerLinea());
    }
}

marzo 12, 2012

Manejo de Cadenas: Subcadenas con substring()

Otro método de la clase String es substring(), este método retorna una parte especifica de una cadena de caracteres. Es útil, si por ejemplo, en la cadena "Buenas Intenciones" queremos obtener solo una parte de esa cadena, como "Buenas" ó "Intenciones" ó "tencion", etc.

A este método podemos pasarle 2 parámetros de tipo entero, en estos 2 números enteros debemos especificar la posición de la letra donde queremos que comience la subcadena y la posición donde queremos que termine esta. También podemos ingresar solo un parámetro al método, cuando hagamos esto, el método tomará como referencia el único numero entero que hemos ingresado como posición inicial de la subcadena y como posición final tomará el ultimo caracter de la cadena.
//Archivo: ManejoDeCadenas4.java

public class ManejoDeCadenas4 {

    public static void main(String args[]){
        
        String cadena = "Java y tus Buenas Intenciones";
        
        String subCadena1 = cadena.substring(0,4);
        String subCadena2 = cadena.substring(5,10);
        String subCadena3 = cadena.substring(4);
        
        System.out.println(subCadena1);
        System.out.println(subCadena2);
        System.out.println(subCadena3);
    }
}
En la linea 7 declaramos una variable que contiene una cadena de caracteres. En la linea 9 declaramos otra variable tipo String donde almacenaremos una subcadena de la cadena original declarada en la linea 9, a String subCadena1 le asignamos lo que retorne el método cadena.substring, a la que le pasamos 2 parámetros: 0 y 4, el método substring() toma como indice inicial de la subcadena la posición 0 y como indice final la posición 4; los caracteres que se encuentren entre la posición 0 y 4 serán parte de esa subcadena y se almacenarán en String subCadena1.

La linea 10 hace una operación similar a la descrita para la linea 9. En esta linea toma como referencia la posición 5 y 10, así que los caracteres que se encuentren entre esos indices serán parte de una subcadena y se almacenarán en String subCadena2.

marzo 09, 2012

Manejo de Cadenas: Ocurrencias de Caracteres con indexOf y lastIndexOf

La clase String también cuenta con los métodos indexOf() y lastIndexOf(), estos métodos sirven para ubicar la posición de un caracter dentro de una cadena de caracteres. Nos sirven, si por ejemplo, queremos ubicar la posición de la letra "c" en la cadena "Buenas Intenciones".

indexOf() es un método que retorna la posición de la primera ocurrencia de la letra que queramos ubicar en la cadena de caracteres. Por ejemplo: en la cadena "Buenas Intenciones", la letra "e" ocurre (se repite) varias veces, pero la primera ocurrencia de la letra "e" es la que esta resaltada en negritas y de un tamaño más grande; la letra "B" por ejemplo, solo tiene una ocurrencia en esa cadena. Si ocupamos el método indexOf() para ubicar la posición de la letra "e" en esa cadena, nos retornara un valor entero que indicara la posición de la primera ocurrencia de esta letra, en este caso, retornará: 2.

lastIndexOf(), este método nos retorna la posición de la ultima ocurrencia de la letra que queramos ubicar. Nuevamente un ejemplo: en la cadena de caracteres "Buenas intenciones", la ultima ocurrencia de la letra "e" es la que esta resaltada en negritas y un tamaño más grande. Si usamos lastIndexOf() para ubicar la posición de la letra "e" en esa cadena de caracteres, nos retornará: 16.

Si le pasamos de parámetro una letra que no existe en la cadena de caracteres a los métodos indexOf() y lastIndexOf(), nos retornará un valor negativo.

¡Hagamos código!
//Archivo: ManejoDeCadenas3.java

public class ManejoDeCadenas3{
    
    public static void main(String args[]){
        
        String cadena = "Buenas Intenciones";
        
        int posicion1 = cadena.indexOf('c');
        int posicion2 = cadena.indexOf('i');
        int posicion3 = cadena.indexOf('I');
        int posicion4 = cadena.indexOf('e');
        
        System.out.println("Usando indexOf:");
        System.out.println(posicion1);
        System.out.println(posicion2);
        System.out.println(posicion3);
        System.out.println(posicion4);
        
        int posicion5 = cadena.lastIndexOf('n');
        int posicion6 = cadena.lastIndexOf('e');
        
        System.out.println("Usando lastIndexOf:");
        System.out.println(posicion5);
        System.out.println(posicion6);
        
        int posicion7 = cadena.indexOf('x');
        System.out.println("Para caracteres que no existen en\n"
                + "la cadena de caracteres:");
        System.out.println(posicion7);
    }
}

marzo 08, 2012

Convertir a Mayúsculas y Minúsculas con toUpperCase y toLowerCase

toUpperCase() y toLowerCase() son métodos de la clase String, el primero es un método que permite convertir las letras a mayúsculas de una cadena de caracteres, el segundo es un método que convierte las letras a minúsculas de una cadena. Estos métodos son sencillos de implementar, veamos:
//Archivo: ManejoDeCadenas2.java

public class ManejoDeCadenas2 {
    
    public static void main(String args[]){
        
        String cadena = "Buenas Intenciones";
        String mayus = cadena.toUpperCase();
        String minus = cadena.toLowerCase();
        
        System.out.println("Texto inicial: "+cadena);
        System.out.println("Texto en Mayusculas: "+mayus);
        System.out.println("Texto en Minusculas: "+minus);
    }
}
En la linea 7 declaramos String cadena que contiene la cadena "Buenas Intenciones". En la linea 8 declaramos String mayus que se le asigna lo que retorne el método toUpperCase() que es mandado a traer por String cadena, este método retornara la cadena contenida en String cadena pero en mayúsculas. En la linea 9 declaramos String minus que se le asigna lo que retorne el método toLowerCase() que es llamado por String cadena, este método retornara la cadena contenida en String cadena pero en minúsculas.

Ya en las lineas 10 a la 13 imprimimos por separado lo que contiene las variables cadena, mayus y minus que son de tipo String, para comparar su comportamiento.

marzo 07, 2012

Manejo de Cadenas: charAt()

Como sabemos el tipo de dato String es para cadenas de caracteres, por tanto una variable de tipo String almacena una cadena. Estas cadena de caracteres puede ser de 0 caracteres (cadena en blanco) o más caracteres; Y los caracteres de una cadena tienen un indice, es decir, tienen un numero de orden. Los elementos (caracteres) de una cadena se enumeran de una forma muy parecida a la que se enumeran los elementos de un arreglo, desde la posición 0 hasta la posición "n".

Por ejemplo la cadena de caracteres: "Buenas intenciones" contiene 18 caracteres, y estos están enumerados del 0 al 17, es decir:


0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
B
U
E
N
A
S

I
N
T
E
N
C
I
O
N
E
S


Cada caracter que compone esta cadena de caracteres se puede guardar en una variable de tipo char.
charAt() es un método de la clase String que retorna el caracter (tipo char) que se encuentra en la posición indicada. El metodo length() de la clase String también, retorna la cantidad total de caracteres contenidos en la cadena.

Ahora se presenta el siguiente programa para entender mejor la teoría anterior:
//Archivo: ManejoDeCadenas.java

public class MenejoDeCadenas {
    
    public static void main(String args[]){
        
        String cadena = "Buenas Intenciones";
        
        System.out.println(cadena.charAt(0));
        System.out.println(cadena.charAt(7));
        System.out.println(cadena.charAt(cadena.length()-1));
        
        char letra;
        for(int cont=0; cont < cadena.length(); cont++){
            letra=cadena.charAt(cont);
            System.out.println(cont+" --> "+letra);
        }
    }
}

marzo 04, 2012

Mostrar Una Imagen

En esta ocasión veremos como visualizar una imagen en java, para ejemplificar realice una pequeña clase llamada "Imagen" y quedo de la siguiente manera:

/**
* Archivo: Imagen.java
* @author Bello Cerecero
* @version 1.00 2012/3/4
*/

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.ImageIcon;

public class Imagen
{
 private JFrame ventana;
 private JPanel contenedor;
 private JLabel etiqueta;
 
  public Imagen()
  {
   ventana = new JFrame("Mostrar una imagen");
   contenedor = new JPanel();
   etiqueta = new JLabel(new ImageIcon("homero.gif"));
  }

  public void mostrarVentana()
  {
   contenedor.add(etiqueta);
   ventana.getContentPane().add(contenedor);
   ventana.pack();
   ventana.setResizable(false);
   ventana.setVisible(true);
   ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }

  public static void main (String[] args)
  {
   Imagen mostrar = new Imagen();
   mostrar.mostrarVentana();
 }
}


Como se puede observar de la linea 1 a la 5 solo son comentarios, despues de los comentarios importamos lo que se va a ocupar (lineas 7 a la 10), ya dentro de la clase en las lineas 20,21 y 22 declaramos nuestras variables, un JFrame al que llamaremos "ventana", un JPanel que se llamara "contenedor" y un JLabel que se llamara "etiqueta".

En el constructor (linea 18), inicializamos nuestras variables, a la variable ventana le pasamos como parámetro una String, esta String aparecerá en la ventana de titulo(linea 20) observe la imagen para descripción gráfica.



En la linea 21 inicializamos un JPanel llamado contenedor, y como lo dice el nombre, va a contener, en la linea 22 inicalizamos un JLabel llamado etiqueta a la que le pasamos como parametro el nombre de la imagen que deseamos que se visualice en la ventana, esto es importante, como la imagen que utilice se encontraba en la carpeta en la que esta mi código no es necesario colocar la ruta completa solo con colocar el nombre de la imagen y el tipo es suficiente ("homero.gif"), pero si la imagen que quieren visualizar esta en otra carpeta tienen que espesificar la ruta por ejemplo: ("C:\\Users\\user\\Desktop\\Nueva carpeta (2)\\homero.gif").

febrero 09, 2012

Calculo de Áreas usando POO

Usando Programación Orientada a Objetos realizaremos 4 programas que realicen el calculo de área de 4 figuras geométricas, cada programa realizara el calculo de área de una figura diferente, cada programa constara de una clase con sus métodos para poder usarlos en el calculo del área, y un main.

La clase Cuadrado.
//Archivo: Cuadrado.java

public class Cuadrado{
    
    double lado;
    
    Cuadrado(){
        
    }
    
    public void setLado(double l){
        lado=l;
    }
    
    public double gedLado(){
        return lado;
    }
    
    public double calcularArea(){
        return l*l;
    }
}
En esta clase solo declaramos un atributo, porque es el unico que necesitamos para calcular el area de esta figura. Declaramos el constructor por deafult, de claramos el metodo setLado() para establecer la longitud del lado del cuadrado, getLado() lo establecemos para que nos retorne el valor del lado y calcularArea() es el metodo que realizara la operacion matematica para obtener el area del cuadrado con las medidas establecidas, y este método retornara el resultado del calculo al programa principal.

Main para la clase Cuadrado.
//Archivo: EjemploCuadrado.java

import javax.swing.JOptionPane;

public class EjemploCuadrado{
    
    public static void main(String args[]){
        
        JOptionPane.showMessageDialog(null, "Bienbenido al calculador de\narea para un Cuadrado");
        
        double tamaño=Double.parseDouble(JOptionPane.showInputDialog("Tamaño del lado del cuadrado:"));
        
        Cuadrado cuadrado1 = new Cuadrado();
        cuadrado1.setLado(tamaño);
        
        System.out.println("Usted ha introducido: "+cuadrado1.gedLado()+"\ncomo tamaño del lado del cuadrado\n");
        
        System.out.println("El area del cuadrado es:\n"+cuadrado1.calcularArea());
    }
}
Pediremos la medida del lado del cuadrado y lo guardaremos en double tamaño. En la linea 13 creamos nuestro objeto cuadrado1 de la clase Cuadrado. En la linea 14 asignamos la longitud del lado del cuadrado para nuestra variable double lado en la clase Cuadrado, esto lo hacemos mediante el método setLado() que es invocado por nuestro objeto cuadrado1 y a este método se le pasa de parámetro la variable tamaño (que es de tipo double).

En la linea 16 se imprime en pantalla el mensaje "Usted ha introducido:" concatenado con lo que retorne el método getLado() (en este caso retornara el tamaño del lado que haya introducido el usuario). Y en la linea 18 se imprime el mensaje en pantalla: "El área del cuadrado es:" concatenado con lo que retorne el método calcularArea() (que retornara el resultado del calculo del área, dependiendo del tamaño del lado del cuadrado que haya introducido el usuario).

febrero 08, 2012

Clases, Métodos y Objetos: Un análisis mas detallado.

Clase.
Pensemos en una Película como una clase de objeto. Las películas tienen características tales como: titulo, director, duración, etc. También tiene funciones, cosas que puede realizar, como: reproducirse, eliminarse, saber sus datos, etc. A partir de esta analogía podemos crear una clase que lleve por nombre "Película", a la cual le implementaremos sus atributos basándonos en sus características, y métodos basándonos en las funciones que puede realizar esta película.

La clase Película:
//Archivo: Pelicula.java

public class Pelicula{
    
    //Declarando los atributos de la clase
    //(las caracteristicas de una pelicula)
    String titulo;
    String director;
    String duracion;
    
    //Creando los metodos de la clase Pelicula
    //(cosas que se pueden hacer con una pelicula)
    
    Pelicula(){ //Metodo constructor por default
        
    }
    
    //Metodo para establecer el titulo:
    public void setTitulo(String t){
        titulo=t;
    }
    
    //Metodo para establecer el director:
    public void setDirector(String dir){
        director=dir;
    }
    
    //Metodo para establecer la duracion:
    public void setDuracion(String dur){
        duracion=dur;
    }
    
    //Metodo para devolver el titulo:
    public String getTitulo(){
        return titulo;
    }
    
    //Metodo para devolver el director:
    public String getDirector(){
        return director;
    }
    
    //Metodo para devolver la duracion:
    public String getDuracion(){
        return duracion;
    }
    
    //Metodo para reproducir pelicula:
    public void reproducirPeli(){
        System.out.println("Reproduciendo");
    }
    
    //Metodo para eliminar pelicula:
    public void eliminarPeli(){
        System.out.println("Pelicula eliminada");
    }
}
Se creo esta clase con sus atributos y sus metodos, basandonos en sus caracteristicas y funciones.


Métodos.

febrero 04, 2012

Introducción a la Programación Orientada a Objetos en Java

La programación orientada a objetos (POO) es una innovadora forma de programar, que facilita las tareas a los programadores, ya que se trata de hacer código expresándolo de una manera mas parecida a la vida real. Algunas ventajas de la POO son que facilita la creación de software de calidad, potencia el mantenimiento y la extensión, y permite la reutilización de código. Dentro de este tipo de programación resuenan muchos conceptos, entre los mas populares son: clase, métodos, herencia, superclase y objetos, entre otros. Para entender mejor el panorama de la programación orientada a objetos, prestemos atención al siguiente ejemplo.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EJEMPLO:
Estoy en mi oficina y envió chocolates a mi novia. Para esto tengo las siguientes alternativas:
  1. Lo hago directamente enviando un mensaje a Roberto (el señor de la tienda de chocolates).
  2. Usando un objeto intermedio; se pido a María la secretaria.
El objeto Roberto y el objeto María tienen métodos que entienden mi mensaje.
El objeto Roberto tiene métodos que le permiten realizar la acción que pido.

Si le pido a mi jefe Gabriel que mande los chocolates, seguramente no va a hacerlo porque no tiene el método.

Si hubiese ido a otra tienda de chocolates donde atienda la Sra. Alejandra habría sido el mismo resultado, porque Roberto y Alejandra pertenecen a la misma clase. A esta clase la podríamos llamar Chocolatero.

Probablemente Roberto me pedirá dinero y me entregara un ticket, porque ese método lo usan todos los comerciantes, osea que la clase Chocolatero pertenece a una clase mayor (superclase) llamada Comerciante. Y por esto la clase Chocolatero hereda los métodos de la clase Comerciante.

El hecho de que yo no conozca con exactitud los métodos que usara Roberto, se conoce como ocultamiento de la información.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

En general todas las propiedades y métodos de un objeto se conjuntan en una clase. La clase es un prototipo para crear un objeto (sin clase, no hay objeto), por ello se dice que un objeto es una instancia de clases.

Las partes básicas de un objeto son: el nombre del objeto, sus atributos y sus métodos. En la composición de un objeto el tiempo de vida es la duración de dicho objeto en el programa, el estado de un objeto esta definido por sus atributos y su comportamiento se define por sus métodos. Cuando se crea un objeto se ha de especificar de que clase es, para que el compilador comprenda sus características.

enero 31, 2012

Epsilon

En esta ocasión dejo el aporte del Epsilon que se ocupa en la materia de Métodos Numéricos, en si solo evalua la capacidad de tu maquina espero que les sirva, sin mas que decir aquí esta el código.

/**
 * Archivo: Epsilon.java
 */
public class Epsilon 
{
 public static void main(String[] args) 
 {
  double epsilon = 1;
  while(epsilon + 1 > 1)
  {
   epsilon = epsilon/2;
  }
  epsilon = epsilon *2;
  System.out.println(epsilon);
 
 }
}

El programa no lo realice yo, un compañero me paso el programa espero que les sirva.

enero 24, 2012

Scanner parte 2

Bueno después de leer el comentario, me di a la tarea de leer un poco y pues esto fue lo que me pareció los mas apegado a lo que pides, utilizando el método useDelimiter(), bueno chequen el código (explicación al final).

/**
* Archivo: CaracterPorCaracterScanner.java
* @author Bello Cerecero
* @version 1.0
* @since 24/01/2012
*/
import java.util.Scanner;
public class CaracterPorCaracterScanner
{
  public static void main(String[] args)
  {
    Scanner entrada = new Scanner(System.in);
    entrada.useDelimiter(",");
 
    System.out.println("Escribe un nombre");
    System.out.println(entrada.next());
  }
}


Empezamos en la linea 12 vemos que creamos un objeto de la clase Scanner, en la linea 13 utilizamos el método useDelimiter(), esto significa que al leer la entrada solo leerá hasta donde aparezca el delimitador en este caso es una ",".
la salida del programa es la siguiente:

Utilizar Scanner

En esta ocasión hablare sobre la utilización del Scanner, esto nos sirve para poder pedirle al usuario que introduzca datos que le pedimos pero estos serán introducidos por medio de la consola, para hacer un poco mas claro esto hice este pequeño programa que muestra como utilizar el Scanner, échenle un vistazo (al final esta la explicación del código).

/**
* Archivo: EntradaTeclado.java
* @author Bello Cerecero
* @version 1.0
* @since 23/01/2012
*/
import java.util.Scanner;
public class EntradaTeclado
{
  public static void main(String[] args)
  {
    Scanner entrada = new Scanner(System.in);
    String nombre;
    int numero;
    double numeroDecimal;

    System.out.println("Introduce un nombre: ");
    nombre = entrada.next();

    System.out.println("Introduce un numero entero: ");
    numero = entrada.nextInt();

    System.out.println("Introduce un numero decimal: ");
    numeroDecimal = entrada.nextDouble();

    System.out.println("El nombres es: " + nombre);
    System.out.println("El entero es: " + numero);
    System.out.println("El numero decimal es: " + numeroDecimal);
  }
}


Empecemos en la linea 7 aquí importamos la librería para poder utilizar el Sacnner, después en la linea 12 declaramos e inicializamos el objeto de tipo Sacnner al que llamaremos "entrada", de las lineas 13 a la 15 declaramos variables que utilizaremos para guardar los datos que sean introducidos por el usuario, como había dicho que el Scanner utiliza la consola para poder pedir datos al usuario debemos imprimir, para estos utilizaremos "System.out.println()" así el usuario podrá leer lo que le pedimos y ahí mismo el introducirá el dato requerido.
Entonces el la linea 17 utilizamos un "System.out.println()" donde pondremos lo que queremos que introduzca el usuario, en este caso yo puse que coloque un nombre, como un nombre es de tipo String vemos que en la linea 18 a la variable "nombre" (que es de tipo String) se le asigna lo que tenga "entrada.next()" ahora "entrada" es el objeto de tipo Scanner y "next()" es un método para leer datos tipo String. lo mismo pasa en la linea 20 y 21 solo que en la linea 20 imprimo en consola que introduzca un numero entero como pueden ver en la linea 21 pasa algo similar a lo que ocurre en la linea 18, solo que en la linea 21 utilizamos la variable "numero" (que es de tipo int) para asignarle lo que tenga "entrada.nextInt()" como pueden darse cuenta que para cada tipo de dato que se requiere el método "next()" se va modificando, en este caso para poder leer un numero entero es "nextInt()" para el caso siguiente en el que se desea leer un numero decimal (lineas 26 y 27) seria "nextDouble()".

En la siguiente figura se muestra como queda en consola después de haber ejecutado el programa (lo que se encuentra en tono verde, son los datos que el usuario introdujo).

enero 17, 2012

Arreglo 2x2 (Básico)

En esta ocasion veremos un poco de como funcionan los arreglos de dos dimensiones, en este caso para ejemplificar utilizare un arreglo de 2x2 el arreglo (en este caso seria ya una matriz) queda de la siguiente manera:

de esta forma como se puede observar, existen 4 espacios y para poner llenar la matriz se forman 4 diferentes combinaciones de indices, seria 00,01,10 y 11. Bueno vallamos al código para aclarar esto.

/**
* Archivo: ArregloBidimensional.java
* @author Bello Cerecero
* @version 1.0
* @since 14/01/2012
*/
public class ArregloBidimensional
{
public static void main(String[] args)
{
  //inicializamos el arreglo.
  int arreglo[][] = new int [2][2];
  
  //introducimos valores.
  arreglo[0][0] = 5;
  arreglo[0][1] = 10;
  arreglo[1][0] = 15;
  arreglo[1][1] = 20;
  
  //imprimimos.
  System.out.println(arreglo[0][0]);
  System.out.println(arreglo[0][1]);
  System.out.println(arreglo[1][0]);
  System.out.println(arreglo[1][1]);
}
}

En la linea 12 inicializamos el arreglo, como pueden ver es casi lo mismo que inicializar un arreglo de una sola dimensión solo que para el de dos dimensiones utilizamos dos pares de corchetes [][], al escribir "int arreglo[][]" estamos diciendo que que sera de tipo entero se llamara arreglo y sera de dos dimensiones, al escribir "new int [2][2]" estamos diciendo que creemos el arreglo de de 2x2.
De la linea 15 a la 18 estamos introduciendo enteros al arreglo como vemos indicamos el indice en el que queremos que se introduzca cada entero, en la posición 00 se encontrara el valor 5, en la posición 01 se encontrara el valor 10, etc. (si no necesitamos llenar por completo el arreglo pueden quedar espacios libres).
De la linea 21 a la 24 imprimimos el contenido del arreglo como vemos lo unico que tenemos que hacer es especificar que posición queremos imprimir en este caso imprimí todas las posiciones.(si en un dado caso la posición que queramos imprimir se encontrara vacía lo que se imprimiría seria "null").
Eso es todo por hoy espero que les sea de utilidad, este solo fue una pequeña introducción próximamente hablare de los arreglos de dos dimensiones mas ampliamente.
Loading...