Días y Meses (For anidados)

¡Buenas tardes lectores! Acá mi profesor de Física 2 de mi ingeniería me trae algo atareado con algunas ejercicios de electromagnetismo, pero a petición de un lector escribo este breve post para aclarar un poco más el tema de los for anidados.

Como ya habíamos mencionado los for anidados no son más que un (o más) for dentro de otro for, y para explicarlo mejor escribí un pequeño programa que imprime el numero de meses de un año y en cada mes imprime el numero de los días del mes. Aquí el código:

//Archivo: ForAnidados.java

public class ForAnidados{
    
    public static void main(String args[]){
        
        for(int mes=1; mes<=12; mes++){
            System.out.println("Mes "+mes);
            
            for(int dia=1; dia<=30; dia++)
                System.out.println("\tDia "+dia);
        }
    }
}

Para este programa usamos 2 for, anidados. Hacemos nuestro main, y en la linea 7 hacemos un for que se encargara de la impresión de los meses, en la linea 10 anidamos otro for que se encargara de la impresión de los días.

En el primer for declaramos nuestra variable int mes que sera nuestro contador para ese for, y le establecemos la condición de que debe iterar mientras mes valga menos o igual a 12 (ya que son 12 los meses del año) y después le indicamos que nuestra variable mes debe incrementar en uno (++).

Cuando se entra al primer for, mes vale 1 e imprime el mensaje "Mes 1", después de imprimir ese mensaje en la linea 8 se pasa a la linea 10 donde se declara el segundo for, para este declaramos int dia (esta variable sera nuestro contador para este for) y le establecemos la condición de que siga iterando mientras dia sea menor o igual a 30 (ya que son los días que contiene un mes, le puse 30 por dafault, pero recuerde que hay meses que contienen mas o menos de 30 días) y después le damos un incremento a nuestra variable día. Después en la linea 11, imprimimos un mensaje en pantalla "Dia" y se le concatena lo que contenga nuestra variable día.

Tabular función: f(x) = x+1

No se espanten, esto será muy sencillo, le pediremos al usuario que introduzca un limite inferior y un limite superior, y dados estos limites haremos un programa que tabule la función f(x)=x+1 verán que fácil es:

//Archivo: Funcion.java

import javax.swing.JOptionPane;

public class Funcion{

 public static void main(String args[]){
 
  String valor=JOptionPane.showInputDialog("Limite inferior");
  int inferior=Integer.parseInt(valor);
  valor=JOptionPane.showInputDialog("Limite superior");
  int superior=Integer.parseInt(valor);
  int contador;
  
  for(contador=inferior ; contador>=inferior&&contador<=superior ; contador++)
   System.out.println("f("+contador+") = "+(contador+1));
 }
}

Como ven, pedimos 2 datos al usuario con el uso de JOptionPane y esos dos datos, que son los limites, los convertimos a formato int (o double) para poder operar con ellos. Una vez convertidos estos números  hacemos un for en el cual asignamos a contador lo que contiene nuestro limite inferior (esto es para que for empiece a contar desde el limite inferior que haya introducido el usuario), después daremos la condición para que siga iterando el for, y sera que contador debe ser mayor o igual a nuestro limite inferior y también contador debe ser menor o igual a nuestro limite superior (de modo que deja de iterar cuando el contador llegue hasta el limite superior que el usuario introdujo). En cada iteracion del for mostrará un mensaje que constara de la "f" de función, dentro del paréntesis el numero que valga la variable contador (las "x"), este numero irá variando de uno en uno desde el numero del limite inferior hasta el del numero superior, y posteriormente "=" seguido de la operación "x+1" osea lo que contenga nuestra variable contador más 1.

Cuidado al no usar parentesis

Analicen el siguiente código:

/**
* Archivo: Parentesis.java
* @author BelloCerecero
* @version 1.00
* @since 2011/11/17
*/
public class Parentesis
{
 public static void main (String[] args)
 {
  //declaramos dos variables de tipo int
  int resultado;
  int resultado2;
  
  //le asignamos una operacion sin parentesis
  resultado = 8 + 4 / 2;
  
  //le asignamos una operacion con parentesis
  resultado2 = (8 + 4)/2;
  
  System.out.println(resultado);
  System.out.println(resultado2);
 }  
}

Ola mejor algunos pensaran que las dos variables deberán de tener el mismo valor puesto que se les asigna lo mismo matemáticamente hablando sumar 8 + 4 y dividir entre dos, pero en java hay jerarquía de operaciones si no utilizamos paréntesis java lo que hace es dividir primero y luego sumar, dado que la división es de mayor prioridad que la suma.

Operador ? ( y no es pregunta )

Al operador cuando lo conocí me decían que se le decía el "if de una linea" y esto como que me generaba algunas dudas y pues después de unos ejercicio me di cuenta de que no es muy difícil este operador es como el if pero el ? devuelve un valor dado no una expresión correcta, asi en pocas palabras la declaración de este operador seria así:

variableQueSeLeAsignaraElValorDevuelto = condicion?valorSiEsVerdadera:valorSiEsFalsa;

Para dejar esto mas en claro hice este pequeño programa que es prácticamente igual al de mi publicación anterior solo le agregue unas cositas casi nada chequenlo:

public class IfDeUnaLinea
{
 public static void main (String[] args)
 {
  //declaramos dos variables de tipo boolean
  boolean esMayorDeEdad, esMenorDeEdad;
  
  //declaramos e inicializamos una variable de tipo int
  int edad = 17;
  
  esMayorDeEdad = (edad >= 18)? true:false;
  esMenorDeEdad = !esMayorDeEdad;
  
  System.out.println(esMayorDeEdad);
  System.out.println(esMenorDeEdad);
 }
}

como vemos en la linea 17 esta la utilización del ? si la condición se cumple a "esMayorDeEdad" se le asignara true, de lo contrario se le asignara falsa, no solo puede devolver valores booleanos si no que también int o cualquier otro tipo.

Tu primer menú en JAVA y Calculador de Áreas

Hace tiempo (el 30/07/11) en el post Calcular Áreas con Datos Preestablecidos explicamos programas muy sencillos que calculaban el área de varias figuras, un programa para calcular el área de una figura. En esta ocasion con el uso de switch les mostrare como hacer un programa que calcule el area de cualquier figura, así el mismo programa podrá calcular el área de un rombo circulo, rectángulo, triangulo, trapecio; Para lo anterior crearemos un sencillo menú en el cual el usuario pueda elegir la figura de la que desea calcular su área. Posteriormente a que el usuario haya elegido la figura, nuestro programa pedirá al usuario los datos necesarios para calcular el área de la figura elegida. En java esto es así:

//Archivo: Areas.java

import javax.swing.JOptionPane;

public class Areas{

 public static void main(String args[]){
 
  String valor=JOptionPane.showInputDialog("Elija el numero de la figura\n1.-Circulo\n2.-Rectangulo\n3.-Triangulo\n4.-Trapecio");
  int opcion=Integer.parseInt(valor);
  
  switch(opcion){
  
   case 1:{
    valor=JOptionPane.showInputDialog("Radio");
    double radio=Double.parseDouble(valor);
    double area=3.1416*(radio*radio);
    System.out.println("El area es: "+area);
   }
   break;
   
   case 2:{
    valor=JOptionPane.showInputDialog("Base");
    double base=Double.parseDouble(valor);
    valor=JOptionPane.showInputDialog("Altura");
    double altura=Double.parseDouble(valor);
    double area=base*altura;
    System.out.println("El area es: "+area);
   }
   break;
   
   case 3:{
    valor=JOptionPane.showInputDialog("Base");
    double base=Double.parseDouble(valor);
    valor=JOptionPane.showInputDialog("Altura");
    double altura=Double.parseDouble(valor);
    double area=(base*altura)/2;
    System.out.println("El area es: "+area);
   }
   break;
   
   case 4:{
    valor=JOptionPane.showInputDialog("Base mayor");
    double base1=Double.parseDouble(valor);
    valor=JOptionPane.showInputDialog("Base menor");
    double base2=Double.parseDouble(valor);
    valor=JOptionPane.showInputDialog("Altura");
    double altura=Double.parseDouble(valor);
    double area=(base1+base2)*altura/2;
    System.out.println("El area es: "+area);
   }
   break;
   
   default:
    System.out.println("Opcion no validad");
  }
 }
}

Operadores Lógicos parte III (NOT)

En matemáticas discretas vemos que NOT es la negación, por ejemplo si tenemos 1 y a este lo negamos el valor que tendrá sera 0, para dejar esto mas claro hice un pequeño programa para ver como funciona el NOT ( ! en java).

/**
* Archivo: Not.java
* @author BelloCerecero
* @version 1.00
* @since 2011/11/17
*/
public class Not
{
 public static void main (String[] args)
 {
  //declaramos dos variables de tipo boolean
  boolean esMayorDeEdad, esMenorDeEdad;
  
  //declaramos e inicializamos una variable de tipo int
  int edad = 20;
  
  esMayorDeEdad = (edad >= 18);
  esMenorDeEdad = !esMayorDeEdad;
  
  System.out.println(esMayorDeEdad);
  System.out.println(esMenorDeEdad);
 }
}

En la linea 17 a la variable "esMenorDeEdad" se le asignara lo que de como resultado la condición "edad >= 18" (edad es mayor o igual a 18?), si esto es cierto a "esMayorDeEdad" se le asignara true (verdadero) si es la condición no se cumple se le asignara false (falso), en la linea 18 a "esMenorDeEdad" se le asignara lo que tenga "esMayorDeEdad" pero como observamos tiene el signo "!" esto es por que con este sigo niega lo que contenga la variable "esMayorDeEdad" (si es true lo cambiara a false, si es false lo cambiara a true), ya en la linea 20 y 21 imprimimos en consola lo que contengan "esMayorDeEdad" y "esMenorDeEdad".

Arreglos en JAVA

Los arreglos en JAVA están catalogados como estructuras de datos y son objetos, estos no son mas que una colección de datos del mismo tipo; de otro modo podríamos decir que es un conjunto de variables de un solo tipo. Como los arreglos tienen varios elementos, a cada elemento se le llama "indice" y estos van enumerados desde el 0 hasta n-1 (donde n es la cantidad de elementos que nosotros establecemos para nuestro arreglo); los arreglos son de tamaños fijos (el tamaño que nosotros le indiquemos). Por ejemplo supongamos que tenemos 5 números: 10, 20, 30, 40 y 50, esta es una colección de datos de un mismo tipo, por tanto es un arreglo y se representa así:

numeros [ 0 ]	10
numeros [ 1 ]	20
numeros [ 2 ]	30
numeros [ 3 ]	40
numeros [ 4 ]	50

La representación anterior es un arreglo de nombre "numeros" de tamaño 5 (osea que contiene 5 variables, 5 elementos), los números que están entre corchetes son los subíndices (como dijimos, los subíndices se empiezan a enumerar desde el numero 0) y los números que están en letras amarillas son los elementos del arreglo, son el conjunto de variables de tipo int. Entonces, la manera de representar en java a un arreglo es mediante los corchetes, para representar el esquema anterior en java, basta con indicar el tipo de elementos que contiene, el nombre del arreglo y los corchete para indicar que es un arreglo, de tal modo que seria algo asi: int numeros[].

Llevando esto a la programación, los arreglos se declaran o crean así:

//Archivo: Arreglo.java

public class Arreglo{
 
 public static void main(String args[]){
  
  int numeros[];
  numeros = new int[5];
 }
}

En el codigo anterior estamos creando un arreglo de 5 elementos tipo int. En la linea 7 se declara el arreglo int numeros[] y en la linea 8 creamos el objeto y le damos el tamaño a nuestro arreglo. En el simple código anterior solo creamos nuestro arreglo con 5 elementos, pero todos esos elementos tienen valor de 0, ya que 0 es el valor predeterminado para las variables int; y no podemos ver esos elementos, solo sabemos que están ahi y los imaginamos.

Un programa que te sea leal .equals()

¿Alguna ves han pensado en un programa que te sea leal? un programa que solo te responda a ti. Pues con el la función .equal() podemos hacer posible esto, ya que esta función compara cadenas de caracteres; hasta ahora solo hemos trabajado condiciones comparando numero, pero con la función mencionada empezaremos a comparar cadenas de texto en nuestras condicionales, así que echando a volar nuestra imaginación hagamos un programa que sea leal solo a nosotros:

//Archivo: Acceso.java

import javax.swing.JOptionPane;

public class Acceso{
 
 public static void main(String args[]){
  
  String nombre=JOptionPane.showInputDialog("¿Cual es tu nombre?");
  
  if(nombre.equals("Pedro")){
   System.out.println("Acceso concedido");
   System.out.println("¡Bienvenido Sr. "+nombre+"!");
   System.out.println("¡Que tenga buen dia!");
  }
  else
   System.out.println("Acceso denegado");
 }
}

La funcion .equals() recibe como parametro una cadena de caracteres, obviamente, así que dentro de los paréntesis de esta función escribimos entre comillas algún texto que queramos comparar, en este caso escribimos la cadena de caracteres "Pedro". Este programa sencillo solo indica si usted a accedido al programa, si accede le dará un mensaje de bienvenida y le saludara; si no accede al programa solo le mostrara un mensaje que diga: "Acceso denegado".

Cuando salga la ventana del JOptionPane para preguntarnos el nombre -supongamos que usted se llama Luis-, usted introducirá su nombre en la caja de texto creada por JOptionPane y al dar "Aceptar" la variable String nombre contendrá una cadena de caracteres con su nombre (Luis). Cuando el programa llegue a la linea 11 donde usamos un if, ocupando .equals(), decimos que el nombre que el usuario introdujo debe ser igual a "Pedro", y como en nuestro ejemplo usted se llama "Luis" la condición del if no se cumplirá y se pasara al else donde le enviara un mensaje que diga "Acceso denegado". De este modo, el programa solo accesará y solo saludara a la persona cuyo nombre sea "Pedro".

Calificaciones (Rangos condicionales)

En muchas ocasiones necesitamos establecer un rango condicional para que se evalué un valor, por ejemplo si queremos saber si una persona es mayor de edad o no, es muy fácil saberlo, ya que para que sea mayor de edad debe tener 18 o más, entonces, a pesar de que hay un rango de edad: de 0 a 18 años no es mayor de edad, solo se necesita establecer una sola condición para evaluar lo anterior, por ejemplo:

                                              int edad=14;
                                              if(edad>=18)
                                                   System.out.println("Mayor de edad");
                                              else
                                                   System.out.println("Menor de edad");

Basto con solo una condición (la que esta en letras rojas) para poder validar si es mayor o no, pero no hay un rango condicional (un rango que se sitúe en medio de 2 condiciones) y en ocasiones para algunos otros problemas se necesitan que haya dos condiciones para poder evaluar un valor, para esto Java cuenta con los operadores lógicos. Para entenderlo mejor se plantea el siguiente ejercicio:

Haremos un programa que pida al usuario su promedio final de semestre y que nuestro programa muestre los siguientes mensajes de acuerdo a su calificación (la calificación va desde 1 a 100). Si su promedio es de 100 a 95 debe mostrar "Excelente", si es de 94 a 85 "Muy bien", de 84 a 75 "Bien", de 74 a 70 "Regular" y de 70 a 0 "No acreditado".

// Archivo: Promedio.java

import javax.swing.JOptionPane;

 public class Promedio {
 
  public static void main(String args[]){
  
  String cal="";
  cal=JOptionPane.showInputDialog("Introduce tu calificacion");
  
  if(cal==null)
   System.out.println("Usted ha cancelado la operacion");
  else{
   int calif=Integer.parseInt(cal);
   
   if(calif>=95&&calif<=100)
    System.out.println("Excelente");
   else
    if(calif>=85&&calif<=94)
     System.out.println("Muy Bien");
    else
     if(calif>=75&&calif<=84)
      System.out.println("Bien");
     else
      if(calif>=70&&calif<=74)
       System.out.println("Regular");
      else
       if(calif<70&&calif>=0)
        System.out.println("No Acreditado");
       else
        System.out.println("Esa calificacion no es valida");
  }
 }
}

Promedio (for)

Se realizara un programa con el uso de for, que pida al usuario varios números y que promedie estos. Haciendo un análisis del problema, solo vamos a sumar todos los números que el usuario introduzca y los vamos a dividir entre la cantidad de números que haya introducido.

//Archivo: Promediofor.java

import javax.swing.JOptionPane;

public class Promediofor{

 public static void main(String args[]){
 
  String valor=JOptionPane.showInputDialog("¿Cuantas calificaciones desea evaluar?");
  int num=Integer.parseInt(valor);
  int contador;
  int suma=0;
  
  for(contador=1 ; contador<=num ; contador++){
   valor=JOptionPane.showInputDialog("Introduce calificacion"+contador);
   int cal=Integer.parseInt(valor);
   suma+=cal;
  }
  
  int prom = suma/num;
  System.out.println("El resultado es: "+prom);
 }
}

Pedimos al usuario la cantidad de números que desea promediar, esto a nosotros nos servirá para establecer la condición de los ciclos de repetición. Declaramos un contador para el for y una variable int suma, que nos servirá como recipiente para ir almacenando la suma de los numero que el usuario vaya introduciendo para promediarlos.

Dentro del for establecemos que los ciclos se repetirán hasta cuando contador deje de ser igual o menor que el numero de elementos que el usuario especifico en la linea 9. Dentro del cuerpo del for reutilizamos la variable valor para pedir el primer numero a promediar, después lo convertimos a int y se almacena en int cal, acto seguido se sumara lo que contiene la variable suma mas cal y el resultado de esto se guardara en la misma variable int suma.

Después vienen la siguientes vueltas en el ciclo hasta que se rompa la condición, para cuando esto suceda, la variable suma ya tendrá almacenado la suma de todos los números que el usuario introdujo, por tanto, ya fuera del for, declaramos int prom y le asignamos lo que resulte de lo que contiene suma dividido entre num (el numero de calificaciones que se iban a evaluar introducido por el usuario). Y para finalizar solo le mostramos el resultado al usuario con un System.out.println("El resultado es: "+prom); O si lo prefiere también puede mostrar el resultado usando JOptionPane.showMessageDialog().

Operadores Lógicos en Java parte2 ( || )

Ahora hablaremos del operador lógico || al cual se le conoce como OR, bueno da como resultado false si al evaluar cada uno de los operandos el resultado es false. Si uno de ellos es t r u e , el resultado es true . Para que esta definición quede un poco mas claro lo ejemplificare con este sencillo programa que no hace otra cosa mas que imprimir en consola la operación realizada por el operador OR y así darnos cuenta en que circunstancia podremos entrar al if utilizándolo.

/**
* Archivo: Or.java
* @author Bello Cerecero
* @version 1.0
* @since 11/11/2011
*/
public class Or
{
   public static void main(String[] args)
   {
     int operador1 = 1;
     int operador2 = 1;

     //Si el operador1 es falso o el operador2 es verdadero
     if(operador1 == 2 || operador2 == 1)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");

     //Si el operador1 es falso o el operador2 es falso
     if(operador1 == 2 || operador2 == 2)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");

     //Si el operador1 es veradadero o el operador2 es falso
     if(operador1 == 1 || operador2 == 2)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");

     //Si el operador1 es verdadero o el operador2 es verdadero
     if(operador1 == 1 || operador2 == 1)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");
   }
}

La salida del programa seria la siguiente:


Todas las definiciones del AND y OR fueron obtenidas del libro "Java 2, Manual de Programación, Joyanes Aguilar Luis"

JOptionPane.showMessageDialog();

El showMessageDialog() es un método mas de la clase JOptionPane, este método realiza una tarea muy sencilla cuando se manda a llamar: JOptionPane.showMessageDialog() solo muestra un mensaje en un cuadro de dialogo en la pantalla; Hace una función similar al System.out.println(), pero System.out.println imprime el mensaje que le indiquemos en consola y JOptionPane.showMessageDialog muestra el mensaje en el cuadro de dialogo con un botón de "Aceptar" para cuando el usuario termine de leer el mensaje:.

El siguiente es un programa que pide al usuario 2 números, los suma y muestra su resultado en pantalla, pero en lugar de mostrar el resultado en consola con el System.out.println, lo haremos en un cuadro de dialogo con el JOptionPane.

//Archivo: PruebaMessage.java

import javax.swing.JOptionPane;

public class PruebaMessaje{
 
 public static void main(String args[]){
  
  String nombre=JOptionPane.showInputDialog("¿Como te llamas?");
  String valor;
  valor=JOptionPane.showInputDialog("Introduzca un numero:");
  int num1=Integer.parseInt(valor);
  valor=JOptionPane.showInputDialog("Introduzca otro numero:");
  int num2=Integer.parseInt(valor);
  
  JOptionPane.showMessageDialog(null,"El programa sumara los numeros");
  
  int suma=num1+num2;
  
  JOptionPane.showMessageDialog(null, "Hola "+nombre+", tu suma es: "+suma);
 }
}

Para este programa importamos la libreria JOptionPane en la linea 3, ya que haremos usos de algunos metodos ahi contenidos. En la linea nueve declaramos String nombre que va a contener lo que reciba del JOptionpane.showInputDialog(), en la linea 10 declaramos String valor, esta variable servirá de soporte para crear otras, por eso solo la declaramos. En la linea 11 hacemos el primer uso de la variable valor y en esa variable guardamos lo que reciba el JOptionPane, después en la linea 12 asignamos a int num1 lo que resulte de la conversión de String valor. En la linea 13 reutilizaremos la variable String valor, por tanto, al principio String valor contenía lo que se le ingreso en el JOptionPane en la linea 11, pero como se vuelve a reutilizar con otro JOptionPane, se borra lo que tenia con anterioridad y se escribe el nuevo valor obtenido por el JOptionPane de la linea 13 y en la linea 14 se declara int num2 y se le asigna lo que resulte de la conversión de String valor.

En la linea 16 hacemos uso de nuestro primer JOptionPane.showMessageDialog(), estableciendo en el parámetro primero null y después el mensaje que mostraremos, en este caso: "El programa sumara los números" y aparecerá un cuadro de dialogo en pantalla así:

Operadores Lógicos en Java parte1 (&&)

Los operadores lógicos o booleanos actúan sobre operandos de tipo lógico para

devolver un resultado también de tipo lógico.

La regla del funcionamiento del && es la siguiente: si el primer operando es false, el segundo no es evaluado. Esta propiedad se denomina evaluación en cortocircuito. Por ejemplo, la siguiente expresión evitaría calcular la raíz cuadrada de números negativos:

(X >= O) && (Math.sqrt(x) >= 2)

Para dejar mas en claro el funcionamiento del &&, con el siguiente programa se ejemplifica.

/**
* Archivo: And.java
* @author Bello Cerecero
* @version 1.0
* @since 11/11/2011
*/
public class And
{
   public static void main(String[] args)
   {
     int operador1 = 1;
     int operador2 = 1;
 
     //Si el operador1 es falso y el operador2 es verdadero
     if(operador1 == 2 && operador2 == 1)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");
 
     //Si el operador1 es falso y el operador2 es falso
     if(operador1 == 2 && operador2 == 2)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");
 
     //Si el operador1 es veradadero y el operador2 es falso
     if(operador1 == 1 && operador2 == 2)
       System.out.println("Si entra al if.");
     else
       System.out.println("No entra al if.");
 
    //Si el operador1 es verdadero y el operador2 es verdadero
    if(operador1 == 1 && operador2 == 1)
      System.out.println("Si entra al if.");
    else
      System.out.println("No entra al if.");
   }
}

Break y Continue

Las instrucciones break y continue son instrucciones que sirven para interrumpir al flujo de ejecución de las instrucciones de repetición (bucles). Estas instrucciones siempre deben de ir dentro de un bucle ya sea for o while, porque de caso contrario Java nos botara un error de compilación; usualmente estas instrucciones van después de un if para que si la condición se cumple se ejecuten estas instrucciones, pero no necesariamente deben ir después de un if. Como ya mencionamos debemos situar estas instrucciones dentro de un bucle, pero en el caso del break también puede ser utilizado dentro de un switch como ya lo hemos estudiado con anterioridad.

break

La instrucción break sera fácil de entender puesto que ya la hemos estudiado con el uso del switch; tiene la misma función que en el switch, cuando el programa encuentra nuestra instrucción break dentro del ciclo, interrumpe el ciclo, se sale del ciclo y se empieza a ejecutar la primera linea fuera del for o while.

//Archivo: Break.java

public class Break{
 
 public static void main(String args[]){
  
  int contador;
  
  for(contador=1; contador<=5; contador++){
   
   if(contador==3)
    break;
   
   //esta linea no se ejecutara despues
   //de la tercera iteracion:
   System.out.println("Contando iteracion: "+contador);
  }
  
  System.out.println("Ha salido del for");
 }
}

En este programa haremos uso de un for, declaramos un contador en la linea 7 y en la linea 9 nuestro for, inicializando el contador en 1, estableciendo que para que se cicle contador debe ser menor o igual a 5 (osea que tendrá 5 iteraciones), y dentro del cuerpo del for en la linea 11 establecemos un if con la condición de que cuando contador valga 3 se ejecute la instrucción break (osea que se saldrá del for). Y entonce se brincara hasta la linea 19 donde se imprime un mensaje en consola que dirá: "Ha salido del for".

Al momento de que el programa ejecute el for, entrará, después pasara al condición y como contador vale 1 no se cumple la condición y no se ejecuta el break, y se imprime en consola "Contando iteracion: 1". Para la segunda vuelta se cumple la condición del for y contador vale 2, tampoco se cumple la condición del if y se ejecuta otra impresión en pantalla: "Contando iteracion: 2". Pero para la tercera vuelta (iteracion) pasa el for y contador valdrá 3, por tanto se cumple la condición del if y se ejecuta el break y nos saca del ciclo y ejecuta la primera linea después del cuerpo del for, osea que ejecutara el mensaje en pantalla: "Ha salido del for".

continue

Método de la Burbuja en JAVA

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.

Descripción:

Una manera simple de expresar el ordenamiento de burbuja en pseudocódigo es la siguiente:

Este algoritmo realiza el ordenamiento de una lista a de n valores, en este caso de n términos numerados del 0 al n-1, consta de dos bucles anidados uno con el índice i, que da un tamaño menor al recorrido de la burbuja en sentido inverso de 2 a n, y un segundo bucle con el índice j, con un recorrido desde 0 hasta n-i, para cada iteración del primer bucle, que indica el lugar de la burbuja.

La burbuja son dos términos de la lista seguidos, j y j+1, que se comparan, si el primero es menor que el segundo sus valores se intercambian.

Esta comparación se repite en el centro de los dos bucles, dando lugar a la postre a una lista ordenada, puede verse que el número de repeticiones sola depende de n, y no del orden de los términos, esto es, si pasamos al algoritmo una lista ya ordenada, realizara todas las comparaciones exactamente igual que para una lista no ordenada, esta es una característica de este algoritmo.

El algoritmo del método es el siguiente:

/**
 * Archivo: MetodoDeLaBurbuja.java
 * @author Bello Cerecero
 * @version 1.0
 * @since 10/11/2011
 */
public class MetodoDeLaBurbuja 
{
    public static int[] burbuja(int[] arreglo)
    {
      int auxiliar;
      int[] arregloOrdenado;
      for(int i = 2; i < arreglo.length; i++)
      {
        for(int j = 0;j < arreglo.length-i;j++)
        {
          if(arreglo[j] > arreglo[j+1])
          {
            auxiliar = arreglo[j];
            arreglo[j] = arreglo[j+1];
            arreglo[j+1] = auxiliar;
          }   
        }
      }
      arregloOrdenado = arreglo;
      return arregloOrdenado;
    }
    
    public static void main(String[] args) 
    {
      //Valores que tiene el arreglo desordenado.
      int arreglo[] = {8,6,7,2,1,8,6,8,7,1,9,7,7,10};
      int arregloOrdenado[] = burbuja(arreglo);
 
      //imprimimos el arreglo ordenado.
      for(int i = 0; i < arregloOrdenado.length;i++)
        System.out.println(arregloOrdenado[i]);
    }
}

Estaciones de Año

Usando switch haremos un programa que pida al usuario un numero de mes y que se muestre en pantalla la estación del año a la que pertenece ese mes; Para lo anterior vamos a enumerar los meses del 1 al 12 (enero=1, febrero=2... diciembre=12) y vamos a considerar la siguiente tabla:

Numero de mes	Mes	Estación del año
1	Enero	Invierno
2	Febrero	Invierno
3	Marzo	Primavera
4	Abril	Primavera
5	Mayo	Primavera
6	Junio	Verano
7	Julio	Verano
8	Agosto	Verano
9	Septiembre	Otoño
10	Octubre	Otoño
11	Noviembre	Otoño
12	Diciembre	Invierno

Código:

// Archivo: Estaciones.java

import javax.swing.JOptionPane;

public class Estaciones{

 public static void main(String args[]){
 
  String valor=JOptionPane.showInputDialog("Introduce un numero de mes");
  int mes=Integer.parseInt(valor);
 
  switch(mes){
  
   case 3:
   case 4:
   case 5:
    System.out.println("Estas en Primavera");
   break;
   
   case 6:
   case 7:
   case 8:
    System.out.println("Estas en Verano");
   break;
   
   case 9:
   case 10:
   case 11:
    System.out.println("Estas en Otoño");
   break;
   
   case 12:
   case 1:
   case 2:
    System.out.println("Estas en Invierno");
   break;
   
   default:
    System.out.println("Mes y estacion no existen");
  }
 }
}

Tabla en Java

El siguiente programa esta basado en el siguiente planteamiento:

Entonces siguiendo con las condiciones propuestas el programa quedaría de la siguiente manera(sin usar arreglos):

/**
 * Archivo: Tabla.java
 * @author Bello Cerecero
 * @version 1.0
 * @since 07/11/2011
 */
public class Tabla 
{
    public static void main(String[] args) 
    {
      int renglones = 20;
      int columna1 = 0;
      int columna2 = 1;
      int columna3 = 1;
      int columna4 = 1;
 
      int auxColumna2;
      int auxColumna3;
      int auxColumna4 = 0;
 
      System.out.print(columna1 + "\t" + columna2 + 
            "\t" + columna3 + "\t\t" + columna4 +"\n");
 
      for(int i = 1; i < renglones; i++)
      {
        columna1 = i;
        auxColumna2 = (columna2 + 2);
        auxColumna3 = columna2 + columna3 + columna4;

        if(i == 1)
          auxColumna4 = columna3 + auxColumna3;
        else
          auxColumna4 = auxColumna3 + columna4;

        System.out.print(columna1 + "\t" + auxColumna2 + 
              "\t" + auxColumna3 + "\t\t" + auxColumna4+"\n");
     
        columna2 = auxColumna2;
        columna3 = auxColumna3;
        columna4 = auxColumna4;
     }
  }
}

Primero declaramos las variables que utilizaremos(de la linea 11 a la 19) y se inicializan según las condiciones que se nos piden, como se puede observar hay algunas variables que tiene "aux" estas son auxiliares que nos ayudaran para poder hacer las operaciones. En la linea 21 imprimimos en consola la parte que se pide en el ejercicio de ahi utilizamos un for para hacer las iteraciones, dentro del for en la linea 26 a columna1 se le asignara lo que tenga i(siguiendo las reglas del ejercicio), a auxColumna2 se le asignara lo que resulte de sumar columna2 mas dos(linea 27), a auxColumna3 se le asignara lo que resulte de sumar columna1 mas columna2 mas columna3(linea 28), ahora para que se pueda cumplirf la ultima regla tenemos que poner una condicion (linea 29), que solo en la primera iteracion a auxColumna4 se le asignara lo que resulte de columna3 mas auxColumna3(linea 30), ya despues de la primera iteracion a auxColumna4 se le asiganar de lo que resulte de auxColumna3 mas columna4(linea 32), ya despues de esto imprimimos en consola las cuatro columnas utilizando el tabulador horizontal "\t".

Números romanos

Con el uso del switch haremos un programa sencillo, el cual pide al usuario un numero del 1 al 10 y el programa muestra el numero que el usuario introdujo en numero romano:

//Archivo: Romano.java

import javax.swing.JOptionPane;

public class Romano{

 public static void main(String args[]){
  
  String valor=JOptionPane.showInputDialog("Introduce un numero de 1 a 10");
  int numero=Integer.parseInt(valor);
  
  switch(numero){
   
   case 1:
    System.out.println("I");
   break;
   
   case 2:
    System.out.println("II");
   break;
   
   case 3:
    System.out.println("III");
   break;
   
   case 4:
    System.out.println("IV");
   break;
   
   case 5:
    System.out.println("V");
   break;
   
   case 6:
    System.out.println("VI");
   break;
   
   case 7:
    System.out.println("VII");
   break;
   
   case 8:
    System.out.println("VIII");
   break;
   
   case 9:
    System.out.println("IX");
   break;
   
   case 10:
    System.out.println("X");
   break;
   
   default:
    System.out.println("Numero no valido");
  }
 }

Hay que programar para los tontos...

Algo que siempre tomo en cuenta a la hora de programar es que los programas que creemos deben de estar orientados a resolver la tarea que nos pidan, pero sobre todo que nuestro programa sea a prueba de tontos. Pensemos en que nosotros como personas diestras en el arte de programar entendemos muy bien el código de nuestro programa y su funcionamiento, pero NO PROGRAMAMOS PARA NOSOTROS MISMOS, nuestros programas están enfocados para el uso de cualquier persona (el usuario) y este no comprende el programa del mismo modo que el programador, por eso tenemos que siempre darle indicaciones de lo que debe hacer o de los datos que debe insertar para que nuestro programa resuelva su tarea. Como nosotros nos entendemos más hablando en código que con palabras, se los explicare así:

El siguiente es un programa muy sencillo, el cual pide un numero al usuario y el mismo numero lo muestra en pantalla:

//Archivo: Tontos.java

import javax.swing.JOptionPane;

public class Tontos{
 
   public static void main(String args[]){
  
      String valor=JOptionPane.showInputDialog("Dame un numero");
      int numero=0;
      numero=Integer.parseInt(valor);
    
      System.out.println("El numero que introdujo es: "+numero);
   }
}

Y listo, ¿es muy sencillo, no? el programa ya cumplió, y realiza a la perfección la tarea que se le encomendó. Ademas estamos siendo muy claros, le estamos diciendo al usuario que introduzca un NUMERO. Pero ¿que pasaría si es usuario introduce una letra o simplemente cancela la operación?, Nuestro programa se cae; se dice que nuestro programa se cae cuando no realiza la tarea a causa de un error lógico como este:

Como ya lo estudiamos anteriormente, si el usuario presiona el botón "Cancelar" el JOptionPane nos retorna un valor null y este valor no puede ser convertido a un entero, así que es ahí donde surge el error lógico y se cae el programa y nos muestra el mensaje anterior. Del mismo modo si el usuario introduce una letra en lugar de un numero, Integer.parseInt(); no podrá convertirlo a un valor entero y se caerá el programa. También se caerá el programa si el usuario no introduce nada y solo presiona aceptar puesto que nos retornara una cadena vacía que tampoco puede convertirse a un valor int. Cuando esto sucede nuestro programa no sirve.

Para esto JAVA implementa un par de instrucciones que nos ayudarán a combatir esos errores lógicos. Para el manejo de excepciones (o errores) tenemos el try{} catch{}, que funcionan como a continuación se explica retomando el programa anterior pero implementando estas instrucciones para mejorar nuestro programa, de tal modo que quedaría asi:

Numero Perfecto en Java

El programa pide al usuario un numero entero este es evaluado(para saber si este es un numero perfecto) si es perfecto imprime en consola un mensaje diciendo que el numero ingresado es perfecto, de lo contrario imprime en consola un mensaje diciendo que el numero no es perfecto.

/**
 * Archivo: NumeroPerfecto.java
 * @author Bello Cerecero
 * @version 1.0
 * @since 06/11/2011
 */
import javax.swing.JOptionPane;
public class NumeroPerfecto 
{
    public static void main(String[] args) 
    {
      //declaramos las variables que vamos a ocupar.
      String valor;
      int entero;
      int sumaDivisiones;
 
      //Pedimos el entero al usuario
      valor=JOptionPane.showInputDialog("Dame un numero");
      //Hacemos la conversion a int.
      entero = Integer.parseInt(valor);
 
      //Inicializamos a "sumaDivisiones" en cero.
      sumaDivisiones = 0;
 
     //utilizaremos un for
     for(int i = 1; i < entero; i++)
     {
       /*
        * ponemos una condicion.
        * el simbolo % lo que hace es una division
        * pero la diferencia es que retorna el "residuo"
        * entonces al poner "(entero % i) == 0" 
        * lo que queremos decir es que
        * "entero" es divisible entre i (sin residuo)
        * si esto resulta cierto a "sumaDivisiones" 
        * lo ira almacenado y si encuentra otro 
        * numero que sea divisible entre "entero" 
        * tambien lo guardara pero tambien lo sumara con 
        * el que se encontro primero, y asi sucesivamente.
        */
       if((entero % i) == 0)
         sumaDivisiones += i;
     
       //si no se cumple se pasa a la sig iteracion.
     }
 
     /*
      * ya que finalizamos la evalucion del entero
      * ponemos una condicion para saber si la suma de 
      * los numero que resultaron divisores del entero 
      * es igual a este mismo.
      */
      if(sumaDivisiones == entero)
        System.out.println(entero + " es un num perfecto!");
      else
        System.out.println(entero +" no es un num perfecto!");
    }
}

Trate de explicarlo lo mejor que pude (con los comentarios), si tienen alguna duda mandarme un mensaje.

Rango

Este programa pide al usuario el inicio de un rango y un numero final (por ejemplo: 5 - 10) y el programa imprime en pantalla todos lo números dentro del rango (en este ejemplo se mostrara en pantalla lo siguiente: 5 6 7 8 9 10).

//Archivo: Rango.java

import javax.swing.JOptionPane;

public class Rango{

 public static void main(String args[]){
  
  String valor=JOptionPane.showInputDialog("Introduzca el inicio del rango");
  int rinicial=Integer.parseInt(valor);
  valor=JOptionPane.showInputDialog("Introduzca el fin del rango");
  int rfinal=Integer.parseInt(valor);
  int contador;
  
  if(rinicial>=rfinal)
   System.out.println("El rango final debe ser mayor que el rango inicial");
  else{
  
   for( contador=rinicial ; contador>=rinicial&&contador<=rfinal ; contador++)
    System.out.println(contador);
  }
 }
}

Carácter en Java

He notado que casi no se habla del tipo de dato char (en java), esa es la razón de mi publicación, El tipo de datos char de Java se utiliza para representar un carácter, éste tipo emplea 16 bits para el almacenamiento de un carácter y lo efectúa en formato

Unicode, Un literal carácter representa un carácter o una secuencia de escape encerrada

entre comillas simples. Por ejemplo, 'c' , 'd'. Entonces se llega a esta definición: Un carácter es un Único carácter encerrado entre comillas simples.

Para almacenar un carácter, se almacena el código numérico que lo representa;

por tanto, internamente los caracteres son números y esto capacita a Java para realizar

algunas operaciones numéricas con datos de tipo char.

Ejemplo:

/**
* Archivo: Caracter.java
* @author Bello Cerecero
* @version 1.0
* @since 04/11/2011
*/
public class Caracter
{
  public static void main(String[] args)
  {
    char caracter;

    caracter = 'a';
    System.out.println("El carácter es ") ;
    System.out.println(caracter) ;

    caracter = 'a' - 32;
    System.out.println("Ahora el carácter es") ;
    System.out.println(caracter) ;

    caracter++;
    System.out.println("Ahora el carácter es");
    System.out.println(caracter);
  }
}

Para empezar declaramos una variable de tipo char a la que le llamamos caracter (linea 11), ahora en la linea 13 inicalizamos a la variable caracter con 'a', en las dos lineas posteriores (14 y 15) imprimimos en consola el valor de caracter, en la linea 17 a caracter le asignamos el valor de 'a' y le restamos 32, aquí lo que esta pasando es que como en Unicode cada carácter tiene un respectivo numero, a la posicion en la que se encuentra 'a' ira 32 lugares atras y ahora caracter tendrá el valor del carácter que se encuentre 32 posiciones mas atras que 'a', en las dos lineas posteriores (18 y 19). En la linea 21 a la variable caracter de sumamos uno (++) y ahora la variable caracter contendra el valor del carácter que esta una posicion mas adelante que el carácter 'a'.

La salida del programa es la siguiente:

Tablas de Operadores en JAVA

Muy útiles estas tablas, para escribir nuestras operaciones matemáticas en java, para indicar nuestras condiciones en las estructuras de control, para la toma de decisiones o simplemente para darle formato a lo que mostremos en pantalla.

OPERADORES ARITMÉTICOS

OPERADOR ARITMETICO	OPERADOR EN JAVA
Suma (+)	+
Resta (-)	-
Multiplicación (x)	*
División (÷)	/
Modulo	%

OPERADORES DE IGUALDAD O RELACIONALES

OPERADOR ARITMETICO	OPERADOR EN JAVA
Igual (=)	==
Desigual (≠)	¡=
Mayor que (>)	>
Menor que (<)	<
Mayor o igual que (≥)	>=
Menor igual que (≤)	<=

OPERADORES DE ASIGNACIÓN

OPERADOR	EXPLICACIÓN
=	Asignación. int x = 5; *
+=	Suma y asigna. x+=3; (resultado: x = 8) **
-=	Resta y asigna. x-=4; (resultado: x=1)
*=	Multiplica y asigna. x*=3; (resultado: x=15)
/=	Divide y asigna. x/=2; (resultado x=2.5)
%=	Obtiene el modulo y asigna. x%=3; (resultado: x=2)

* in x; vale 5 para todos los ejemplos de esta tabla.

** += : Lo que contiene la variable x (que vale 5), se suma con lo que indicamos (3) y al finalizar esas operaciones ahí mismo a la misma variable x se le asigna el resultado (x=8).

OPERADORES DE INCREMENTO Y DECREMENTO

OPERADOR	EXPLICACIÓN
++	Preincremento ++a
++	Postincrmento a++
--	Predecremento --a
--	Postdecremento a--

OPERADORES LÓGICOS

OPERADOR LÓGICO	OPERADOR EN JAVA
AND condicional	&&
OR condicional	||
AND lógico booleano	&
OR inclusivo lógico booleano	|
OR exclusivo lógico booleano	^
NOT lógico	!

(cont.)