Java Standard Edition

Capítulo 002 Ejercicio 019 (While etiquetado)

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

Capítulo 002 Ejercicio 018 (For etiquetado)

// 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

Capítulo 002 Ejercicio 017 (Break y Continue)

/** 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

Capítulo 002 Ejercicio 016 (Operador coma)

/** 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
*
**/

Capítulo 002 Ejercicio 014 (Prueba While)

// 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);
*

Capítulo 002 Ejercicio 013 (Sentencia If - else) (Ejemplo 002)

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

Capítulo 002 Ejercicio 012 (Sentencia If - else) (Ejemplo 001)

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),

Capítulo 002 Ejercicio 011 (Desbordamiento)

// ¡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;
*

Capítulo 002 Ejercicio 010 (Todos los operadores)

/** Prueba todos los operadores con todos los tipos de datos para probar
* cuáles son aprobados por el compilador de Java
**/

class TodosOperadores {

// Para aceptar los resultados de un test booleano:
static void f(boolean b){

// Mostramos en pantalla el resultado boolean obtenido
System.out.println(b);

}

/** Fíjese que boolean es bastante limitado. Se le pueden asignar los valores true y false, y se puede
* comprobar su validez o falsedad, pero no se pueden sumar valores lógicos o llevar a cabo ningún
* otro tipo de operación sobre ellos.
**/

void pruebaBool(boolean x, boolean y){

// Operadores aritméticos:
//! x = x * y;
//! x = x / y;
//! x = x % y;
//! x = x + y;
//! x = x - y;
//! x++;
//! x--;
//! x = +y;
//! x = -y;

// Relacionales y lógicos:
//! f(x > y);
//! f(x >= y);
//! f(x < y);
//! f(x <= y);
f(x == y);
f(x != y);
f(!y);
x = x && y;
x = x || y;

// Operadores de bit:
//! x = ~y;
x = x & y;
x = x | y;
x = x ^ y;
//! x = x << 1;
//! x = x >> 1;
//! x = x >>> 1;

Capítulo 002 Ejercicio 009 (Literales)

/** Generalmente al insertar un valor literal en un programa, el compilador sabe exactamente de qué tipo hacerlo.
* Sin embargo, en ocasiones, el tipo es ambiguo. Cuando ocurre esto es necesario guiar al compilador añadiendo
* alguna información extra en forma de caracteres asociados con el valor literal.
*
* El código siguiente muestra estos caracteres:
*/

class Literales {
char c = 0xffff; // Caracter máximo valor hexadecimal
byte b = 0x7f; // Máximo byte valor hexadecimal
short s = 0x7fff; // Máximo short valor hexadecimal
int i1 = 0x2f; // Hexadecimal (minúsculas)
int i2 = 0X2F; // Hexadecimal (mayúsculas)
int i3 = 0177; // Octal (Cero delantero)

// Hexadecimal y Octal también funcionan con long
long n1 = 200L; // Sufijo long
long n2 = 200l; // Sufijo long
long n3 = 200;

//! long 16(200); // Prohibido
float f1 = 1;
float f2 = 1F; // Sufijo float
float f3 = 1f; // Sufijo float
float f4 = 1e-45f; // 10 elevado a la -45
float f5 = 1e+9f; // Sufijo float

double d1 = 1d; // Sufijo double
double d2 = 1D; // Sufijo double
double d3 = 47e47d; // 10 elevado a la 47
}

Distribuir contenido