style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

blog de Jhanno

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

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
}

Capítulo 002 Ejercicio 008b (Manipulación de bits)

// He aqui un ejemplo que demuestra el uso de todos los operadores de bit.

import java.util.*;

public class ManipulacionBits {

public static void main(String args[]){
Random aleatorio = new Random();
int i = aleatorio.nextInt();
int j = aleatorio.nextInt();
pBinInt("-1", -1);
pBinInt("+1", +1);
int posmax = 2147483647;
pBinInt("posmax", posmax);
int negmax = -2147483648;
pBinInt("i", i);
pBinInt("~i", ~i);
pBinInt("-i", -i);
pBinInt("j", j);
pBinInt("i & j", i&j);
pBinInt("i | j", i|j);
pBinInt("i ^ j", i^j);
pBinInt("i << 5", i<<5);
pBinInt("i >> 5", i>>5);
pBinInt("(~i) >> 5", (~i)>>5);
pBinInt("i >>> 5", i>>>5);
pBinInt("(~i) >>> 5", (~i)>>>5);

long l = aleatorio.nextLong();
long m = aleatorio.nextLong();
pBinLong("-1L", -1L);
pBinLong("+1L", +1L);
long ll = 9223372036854775807L;
pBinLong("maxpos", ll);
long lln = -9223372036854775808L;
pBinLong("maxneg", lln);
pBinLong("l", l);
pBinLong("~l", ~l);
pBinLong("-l", -l);
pBinLong("m", m);
pBinLong("l & m", l&m);
pBinLong("l | m", l|m);
pBinLong("l ^ m", l^m);
pBinLong("l << 5", l<<5);

Capítulo 002 Ejercicio 008a (Desplazamiento de datos sin signo)

// Prueba del desplazamiento a la derecha sin signo

/** Los operadores de desplazamiento también manipulan bits. Sólo se pueden utilizar con tipos primitivos enteros.
* El operador de desplazamiento a la izquierda (<<) provoca que el operando de la izquierda del operador sea
* desplazado a la izquierda, tantos bits como se especifique tras el operador (insertando ceros en los bits menos
* significativos). El operador de desplazamiento a la derecha con signo (>>) provoca que el operando de la izquierda
* del operador sea desplazado a la derecha el número de bits que se especifique tras el operador. El desplazamiento a
* la derecha con signo (>>) utiliza la extensión de signo: si el valor es positivo se insertan ceros en los bits
* más significativos; si el valor es negativo, se insertan unos en los bits más significativos. Java también ha
* incorporado el operador de rotación a la derecha sin signo(>>>), que utiliza la extensión cero; independientemente
* del signo, se insertan ceros en los bits mas significativos. Este operador no existe en C ni en C++.
*

Capítulo 002 Ejercicio 007 (Corto Circuito)

// Demuestra el comportamiento de los cortocircuitos con operadores lógicos.

/** Al manipular los operadores lógicos se pueden entrar en un fenómeno de "cortocircuito". Esto
* significa que la expresión se evaluará únicamente hasta que se pueda determinar sin ambigüedad la
* certeza o falsedad de toda la expresión. Como resultado, podría ocurrir que no sea necesario evaluar
* todas las partes de la expresión lógica.
*
* Cada test lleva a cabo una comparación con el argumento pasado y devuelve verdadero o falso. También
* imprime información para mostrar lo que está invocando. Las comprobaciones se usan en la expresión:
*
* if(prueba1(0) && prueba2(2) && prueba3(3))
*
* Naturalmente uno podría pensar que se ejecutarían las tres pruebas, pero en la salida se muestra de
* otra forma:
*
* prueba1(0)
* resultado: true
* prueba2(2)
* resultado: false
* La expresión es falsa
*
* La primera prueba produjo un resultado verdadero, de forma que la evaluación de la expresión
* continúa. Sin embargo, el segundo test produjo un resultado falso. Puesto que esto significa

Distribuir contenido

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">