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

Java Standard Edition

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

Capítulo 002 Ejercicio 006 (Operadores Relacionales y Lógicos)

// Operadores Relacionales y Lógicos
import java.util.*;

public class Logico{

/** Sólo es posible aplicar AND, OR o NOT a valores boolean. No se puede
* construir una expresión lógica con valores que no sean de tipo boolean, cosa que si
* se puede hacer en C y C++. Se pueden ver intentos fallidos de hacer esto en las líneas que
* comienzan por //! en el ejemplo siguiente. Sin embargo, las sentencias que vienen a
* continuación producen valores lógicos utilizando comparaciones relacionales, y después
* se usan operaciones lógicas en los resultados.
*
* Obsérvese que un valor lógico se convierte automáticamente a formato de texto si se utiliza
* allí donde se espera un String.
*
* Se puede reemplazar la definición int en el programa siguiente por cualquier otro tipo de
* datos primitivo, excepto boolean. Hay que tener en cuenta, sin embargo, que la comparación
* de números en coma flotante es muy estricta. Un número que sea diferente por muy poco de otro número

Capítulo 002 Ejercicio 005c (Métodos de comparación) (Ejemplo 002)

/** La expresión System.out.println(n1 == n2); visualizará el resultado de la comparación
* de tipo lógico. Seguramente la salida debería ser true y después false, pues ambos
* objetos Integer son el mismo. Pero mientras que los contenidos de los objetos son los mismos,
* las referencias no son las mismas, y los operadores == y != comparan referencias a
* objetos. Por ello, la salida es, de hecho, false y después true. Naturalmente esto
* sorprende a la gente al principio.
*
* ¿Qué ocurre si se desea comparar los contenidos de dos objetos? Es necesario utilizar el método
* especial equals()/b> que existe para todos los objetos (no primitivos, que funcionan perfectamente
* con == y !=.
*
* El resultado es true tal y como se espera.
*
* Ah, pero no es así de simple. Si uno crea su propia clase, como ésta:
*/

class Valor {
int i;
}

/** Se obtiene como resultado false. Esto se debe a que el comportamiento por defecto de equals()
* es comparar referencias. Por tanto, a menos que se invalide equals en la nueva clase no se obtendrá

Capítulo 002 Ejercicio 005b (Métodos de comparación) (Ejemplo 001)

/** La expresión System.out.println(n1 == n2); visualizará el resultado de la comparación
* de tipo lógico. Seguramente la salida debería ser true y después false, pues ambos
* objetos Integer son el mismo. Pero mientras que los contenidos de los objetos son los mismos,
* las referencias no son las mismas, y los operadores == y != comparan referencias a
* objetos. Por ello, la salida es, de hecho, false y después true. Naturalmente esto
* sorprende a la gente al principio.
*
* ¿Qué ocurre si se desea comparar los contenidos de dos objetos? Es necesario utilizar el método
* especial equals()/b> que existe para todos los objetos (no primitivos, que funcionan perfectamente
* con == y !=.
*
* El resultado es true tal y como se espera.
*/

public class MetodoComparacion{
public static void main (String args[]){
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.println(n1.equals(n2));
}
}

Capítulo 002 Ejercicio 005a (Equivalencia)

/** La expresión System.out.println(n1 == n2); visualizará el resultado de la comparación
* de tipo lógico. Seguramente la salida debería ser true y después false, pues ambos
* objetos Integer son el mismo. Pero mientras que los contenidos de los objetos son los mismos,
* las referencias no son las mismas, y los operadores == y != comparan referencias a
* objetos. Por ello, la salida es, de hecho, false y después true. Naturalmente esto
* sorprende a la gente al principio.
*
* ¿Qué ocurre si se desea comparar los contenidos de dos objetos? Es necesario utilizar el método
* especial equals()/b> que existe para todos los objetos (no primitivos, que funcionan perfectamente
* con == y !=.
*/

public class Equivalencia{
public static void main (String args[]){
Integer n1 = new Integer(47);
Integer n2 = new Integer(47);
System.out.println(n1 == n2);
System.out.println(n1 != n2);
}
}

Capítulo 002 Ejercicio 004 (Incrementos y Decrementos)

// Programa que muestra el funcionamiento de los operadores "++" y "--"
public class AutoInc{

public static void main(String args[]){
int i = 1;

visualizar("i : " + i);

visualizar("++i : " + ++i); // Pre incremento
visualizar("i++ : " + i++); // Post incremento

visualizar("i : " + i);

visualizar("--i : " + --i); // Pre decremento
visualizar("i-- : " + i--); // Post decremento

visualizar("i : " + i);

}

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

}

Capítulo 002 Ejercicio 003 (Operadores Matemáticos)

// Programa que demuestra los Operadores Matemáticos
import java.util.*;

public class OperadoresMatematicos{

// Sobrecarga de un método que muestra en la consola una cadena
static void visualizar(String s){
System.out.println(s);
}

// Sobrecarga de un método que muestra en la consola una cadena y un entero
static void visualizar(String s, int i){
System.out.println(s + " = " + i);
}

// Sobrecarga de un método que muestra en la consola una cadena y un float
static void visualizar(String s, float f){
System.out.println(s + " = " + f);
}

// Método principal
public static void main(String args[]){
// Crear un generador de números aleatorios

// El generador se alimentará por defecto de la hora actual;
Random aleatorio = new Random();
int i,j,k;

// '%' Limita el valor a 99
j = aleatorio.nextInt() % 100;
k = aleatorio.nextInt() % 100;

visualizar("j",j);visualizar("k",k);

i = j + k; visualizar("j + k",i);
i = j - k; visualizar("j - k",i);
i = k / j; visualizar("k / j",i);
i = k * j; visualizar("k * j",i);
i = k % j; visualizar("k % j",i);
j %= k; visualizar("j %= k",j);

Capítulo 002 Ejercicio 002 (Pasar objeto)

class Carta{
char c;
}

public class PasarObjeto{

static void f(Carta y){
y.c = 'z';
}

public static void main(String args[]){
Carta x = new Carta();
x.c = 'a';
System.out.println("1: x.c: " + x.c);
f(x);
System.out.println("2: x.c: " + x.c);
}

}

Capítulo 002 Ejercicio 001 (Asignación)

class Numero{
int i;
}

public class Asignacion{
public static void main(String args[]){
Numero n1 = new Numero();
Numero n2 = new Numero();

n1.i = 9;
n2.i = 47;
System.out.println("1: n1.i: " + n1.i + ", n2.i: " + n2.i);

n1 = n2;
System.out.println("2: n1.i: " + n1.i + ", n2.i: " + n2.i);

n1.i = 27;
System.out.println("3: n1.i: " + n1.i + ", n2.i: " + n2.i);
}
}

Distribuir contenido

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