Blogs

Capítulo 002 Ejercicio 022 (Límites Aleatorios)

// ¿Produce Math.random() los valores de 0.0 y 1.0?

/** Hay una segunda cuestión que concierne a Math.random(). ¿Produce un valor de cero a uno,
* inlcluyendo o excluyendo el valor "1"? En el lingo matemático ¿es (0,1) ó [0,1], ó (o,1] ó [0,1)?
* (El corchete significa "incluye" mientras que el paréntesis significa "excluye"). De nuevo, la
* solución la puede proporcionar un programa de prueba:
*
*/

public class LimitesAleatorios{

static void uso(){
System.out.println("Utilización: \n\t" +
"Limites Aleatorios inferior\n\t" +
"Limites Aleatorios superior");
System.exit(1);
}

public static void main(String args[]){
if(args.length != 1)
uso();

if(args[0].equals("inferior")){
while(Math.random() != 0.0)
; // Seguir intentándolo
System.out.println("Produjo 0.0!");
}else if(args[0].equals("superior")){
while(Math.random() != 1.0)
; // Seguir intentándolo
System.out.println("Produjo 1.0!");
}
else
uso();
}
}

/** Para ejecutar el programa se teclea una línea de comando como:
*
* java LimitesAleatorios inferior
*
* o
*

Capítulo 002 Ejercicio 021 (Convertir Números)

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

Capítulo 002 Ejercicio 020 (Vocales y Consonantes)

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

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 015 (Lista caracteres)

/** Un bucle for lleva a cabo la inicialización antes de la primera iteración. Después, lleva a cabo la comprobación
* condicional y, al final de cada iteración, hace algún tido de "paso".
*
* La forma del bucle for es:
*
* for(inicialización; expresión condicional, paso)
* sentencia
*
* Cualquiera de las expresiones inicialización, expresión o paso puede estar vacía. Dicha expresión se evalúa
* antes de cada iteración, y en cuanto el resultado sea falso, la ejecución continuará en la línea siguiente
* a la sentencia for. Al final de cada iteración se ejecuta paso.
*
* Los bucles for suelen utilizarse para crear contadores:
**/

// Muestra el funcionamiento del bucle "for" listando todos los caracteres ASCII.

public class ListaCaracteres{
public static void main(String args[]){
for(char c =0; c<128; c++)
if(c != 26) // Limpiar pantalla en código ASCII
System.out.println("Valor: " + (int)c + " Caracter: " + c);
}
}

/** Fíjese que la variable "c" está definida en el punto en que se usa, dentro de la expresión de control del bucle

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

Distribuir contenido