Java Standard Edition

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

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

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

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

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

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

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

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

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

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

}