Java Standard Edition

// ¿Qué ocurre cuando se convierte un float o un double a un valor entero?

/** La sentencia
*
* char c = (char)(Math.random() * 26 + 'a');
*
* merece una mirada más detallada. Math.random() produce un double, por lo que se convierte el
* valor 26 a double para llevar a cabo la multiplicación, que también produce un double. Esto
* significa que debe convertirse la 'a' a double para llevar a cabo la suma. El resultado double
* se vuelve a convertir en char con un molde.
*
* ¿Qué es lo que hace la conversión a char? Es decir, si se tiene el valor de 29.7 y se convierte
* a char, ¿cómo se sabe si el valor resultante es 30 ó 29? La respuesta a esta pregunta se puede ver
* en este ejemplo:
*
**/

public class ConvertirNumeros{
public static void main(String args[]){
double
encima = 0.7,
debajo = 0.4;
System.out.println("Encima: " + encima);
System.out.println("Debajo: " + debajo);
System.out.println("(int)encima: " + (int)encima);
System.out.println("(int)debajo: " + (int)debajo);
System.out.println("(char)('a' + encima): " + (char)('a' + encima));

/** La orden switch suele clasificarse como sentencia de selección. La sentencia switch selecciona de entre fragmentos
* de código basados en el valor de una expresión entera. Es de la forma:
*
* switch(selector - entero){
* case valor - entero 1 : sentencia; break;
* case valor - entero 2 : sentencia; break;
* case valor - entero 3 : sentencia; break;
* case valor - entero 4 : sentencia; break;
* case valor - entero 5 : sentencia; break;
* // ...
* default: sentencia;
* }
*
* El selector entero es una expresión que produce un valor entero. El switch compara el resultado de selector entero
* con cada valor entero. Si encuenta un valor que coincida, ejecuta la sentencia (simple o compuesta) correspondiente.
* Si no encuentra ninguna coincidencia, ejecuta la sentencia default.
*
* Observese en la definición anterior que cada case acaba con break, lo que causa que la ejecución salte al final de
* la sentencia switch. Ésta es la forma convencional de construir una sentencia switch, pero el break es opcional. Si
* no se pone, se ejecutará el código de las sentencias "case" siguientes, hasta encontrar un break. Aunque este

// El bucle While Etiquetado de Java

public class WhileEtiquetado{

public static void main(String args[]){
int i = 0;
externo:
while(true){
visualizar("Bucle While externo");
while(true){
i++;
visualizar("i = " + i);

if(i == 1){
visualizar("Continuar");
continue;
}

if(i == 3){
visualizar("Continuar externo");
continue externo;
}

if(i == 5){
visualizar("Salir");
break;
}

if(i == 7){
visualizar("Break externo");
break externo;
}
}
}
}

static void visualizar(String s){
System.out.println(s);
}

}

/** Las mismas reglas son ciertas para while:
*
* 1. Un continue sin más va hasta el comienzo del bucle más interno y continúa.
* 2. Un continue etiquetado va a la etiqueta, y vuelve a entrar en el bucle situado justo después de la etiqueta.
* 3. Un break "abandona" el bucle.
* 4. Un break etiquetado abandona el final del bucle marcado por la etiqueta.
*
* La salida de este método lo deja claro:
*
* --------------------Configuration: --------------------

// Programa que muestra el bucle "for etiquetado" de Java

/** La palabra clave "goto" ha estado presente en los lenguajes de programación desde los comienzos.
* Sin duda, el "goto" era la genésis del control de los programadores en el lenguaje ensamblador:
* "Si se da la condición A, entonces saltar aquí, sino, saltar ahí". Si se lee el código ensamblador
* generado al final por cualquier compilador, se verá que el control del programa contiene muchos saltos.
* Sin embargo, un "goto" es un salto a nivel de código fuente, y eso es lo que le ha traido tan mala
* reputación. Si un programa salta siempre de un lado a otro, ¿no hay forma de reorganizarlo de manera que
* el flujo de control no dé tantos saltos? "goto" cayó en desgracia con la publicación del famoso artículo
* "El Goto considerado dañino", de Edsger Dijkstra, y desde entonces, la prohibición del "goto" ha sido
* un deporte popular, con los partidarios de la palabra clave repudiada buscando guarida.
*
* Como es típico en situaciones como ésta, el terreno imparcial es el más fructífero. El problema no es

/** Dentro del cuerpo de cualquier sentencia de iteración también se puede controlar el flujo del bucle
* utilziando break y continue. Break sale del bucle sin ejecutar el resto de las sentencias del bucle.
* Continue detiene la ejecución de la iteración actual y vuelve al principio del bucle para comenzar la
* siguiente iteración.
**/

// Muestra el funcionamiento de las palabras clave "break" y "continue"
public class BreakyContinue{

public static void main(String args[]){

for(int i = 0; i < 100; i++){

if(i == 74)
break; // Sale del bucle for

if(i % 9 != 0)
continue; // Siguiente iteración

System.out.println(i);
}

int i = 0;
// Un "bucle infinito":
while(true){
i++;
int j = i * 27;

if(j == 1269)
break; // Sale del bucle

if(i % 10 != 0)
continue; // Parte superior del bucle

System.out.println(i);

}
}

}

/** En el bucle for el valor de "i" nunca llega a 100 porque la sentencia break rompe el bucle cuando "i"
* vale 74. Normalmente, el break sólo se utilizaría de esta manera si no se supiera cuándo va a darse la

/** Anteriormente se mencionó que el operador coma (no el separador coma, que se usa para separar
* definiciones y parámetros de funciones) sólo tiene un uso en Java: en la expresión de control
* de un bucle for. Tanto en la inicialización como en las porciones de "paso" de las expresiones
* de control, se tiene determinado número de sentencias separadas por comas, y estas sentencias
* se evaluarán secuencialmente.
**/

public class OperadorComa{
public static void main(String args[]){
for(int i = 1, j = i + 10; i < 5; i++, j = i * 2 )
System.out.println("i= " + i + " j = " + j );
}
}

/* La salida en pantalla es:
*
* i= 1 j = 11
* i= 2 j = 4
* i= 3 j = 6
* i= 4 j = 8
*
* Process completed.
*
* Se puede ver que tanto en la inicialización como en las porciones de "paso" se evalúan las
* sentencias en orden secuencial. Además, la porción de inicialización puede tener cualquier
* número de definiciones de un tipo
*
**/

// Muestra el comportamiento del bucle While

public class PruebaWhile{

public static void main(String args[]){

double r = 0;

while(r < 0.99d) {
r = Math.random();
System.out.println(r);
}

}

}

/** La sentencia while, do-while y for son para el control de bucles y en ocasiones se clasifican
* como sentencias de iteración. Se repite una sentencia hasta que la expresión condicional controladora
* se evalúe a falsa. La forma de un bucle while es:
*
* while(expresion-condicional)
* sentencia
*
* La expresión condicional se evalúa al comienzo de cada iteración del bucle, y de nuevo antes de cada
* iteración subsiguiente de la sentencia.
*
* Este ejemplo usa el método estático random() de la biblioteca Math, que genera un valro double entre 0 y 1.
* (Incluye el 0, pero no el 1). La expresión condicional para el while dice "siga haciendo este bucle hasta que
* el número sea 0,99 o mayor". Cada vez que se ejecute este programa, se logrará un listado de números de
* distinto tamaño.
*
* La forma del do-while es
*
* do
* sentencia
* while(expresión condicional);
*

public class IfElse2{

static int prueba(int intento, int solucionar){
int resultado = 0;

if(intento > solucionar)
return +1;
else if(intento < solucionar)
return -1;
else
return 0; // Coincidir
}

public static void main(String[] args){
System.out.println(prueba(10,5));
System.out.println(prueba(5,10));
System.out.println(prueba(5,5));
}

}

// No hay necesidad de else porque el método no continuará ejecutándose una vez que se ejecute el return

public class IfElse{

static int prueba(int intento, int solucion){
int resultado = 0;

if(intento > solucion)
resultado = +1;
else if(intento < solucion)
resultado = -1;
else
resultado = 0; // Coincidir

return resultado;
}

public static void main(String[] args){
System.out.println(prueba(10,5));
System.out.println(prueba(5,10));
System.out.println(prueba(5,5));
}

}

/** Todas las sentencias condicionales utilizan la certeza o la falsedad de una expresión de condición para determinar
* el cauce de ejecución. Un ejemplo de una expresión condicional es A == B. Ésta hace uso del operador condicional ==
* para ver si el valor de A es equivalente al valor de B. La expresión devuelve true o false. Cualquiera de los
* operadores relacionales vistos anteriormente puede usarse para producir una sentencia condicional. Fíjese que Java
* no permite utilizar un número como un boolean, incluso aunque está permitido en C y C++ (donde todo lo distinto de
* cero es verdadero, y cero es falso). Si se quiere usar un valor que no sea lógico en una condición, como if(a),

// ¡Sorpresa! Java permite desbordamientos.

/** En char, byte y short se puede ver el efecto de promoción con los operadores aritméticos. Cada
* operación aritmética que se haga con estos tipos genera como resultado un int, que debe ser explícitamente
* convertido para volver al tipo original (una conversión reductora que podría implicar pérdida de información)
* para volver a ser asignado a ese tipo. Con los valores int, sin embargo, no es necesaria ninguna conversión,
* porque todo es ya un int. Aunque no hay que relajarse pensando que todo está ya a salvo. Si se multiplican dos
* valores de tipo int lo suficientemente grandes, se desbordará el resultado.
*
* Esto se demuestra en el siguiente ejemplo:
**/

public class Desbordamiento{

public static void main(String args[]){
int grande = 0x7fffffff; // Valor entero máximo
visualizar("grande = " + grande);
int mayor= grande * 4;
visualizar("mayor = " + mayor);
}

static void visualizar(String s){
System.out.println(s);
}

}

/** La salida de esto es:
*
* grande = 2147483647
* mayor = -4;
*