Operador Resto: %
Devuelve el resto de una división.
class Resto{
public static void main (String[] args){
int dividendo = 15;
int divisor = 2;
int resto = dividendo % divisor;
System.out.println("Resto: " + resto);
int expresion = 3 + dividendo % divisor;
System.out.println("Expresion: " + expresion);
}
}
Hay que recordar que los operadores *, /, % tienen una prioridad mayor que los operadores + y -, como se puede comprobar en el ejemplo.
Recordamos también que las expresiones se evalúan por defecto de izquierda a derecha y que para cambiar la prioridad en las evaluaciones se pueden utilizar paréntesis.
Operador Concatenador: +
Con este operador se realiza una concatenación de objetos String y resulta en un nuevo objeto String.
String sujeto = "Ellos";
String predicado = "estudiaban Java";
String frase = sujeto + " " + predicado;
System.out.println(frase); //Devuelve "
Si uno de los argumentos del operador + es String el otro argumento se convierte en objeto String.
Por ejemplo, entre números y String:
class PruebaConcatenador{
public static void main (String[] args){
String nombre = "Virginia";
int a = 10;
int b = 20;
System.out.println(nombre + a + b);
System.out.println(a + b + nombre);
System.out.println(a + b + nombre + a + b);
}
}
Devolvería:
Todos los objetos pueden convertirse en objeto String de forma automática, pero el resultado puede tener poco significado. Es por esto que para dar una representación significativa de un objeto en String se suele sobrecargar el método toString().
Operadores de Incremento y Decremento: ++, –
Estos operadores se pueden colocar delante de la variable (notación prefjia) o después de la variable (notación sufija) y realizan un incremento o decremento en 1 en el valor de la variable.
Cuando tenemos la notación prefija (++i ó –i), primero se realiza el aumento o decremento en el valor y luego se evalúa.
Cuando tenemos la notaciión sufija (i++ ó i–), primero se evalúa y luego se realiza el aumento o decremento en el valor.
Por ejemplo:
class OperadoresIncrDecr{
public static void main (String[] args){
int a = 10;
int b = 10;
System.out.println("a++: " + a++); //1º Evalua con a y luego la incrementa.
System.out.println("++b: " + ++b); //1º Incrementa y luego evalua con el nuevo valor.
System.out.println(a); //Comprobamos que el valor se ha incrementado.
System.out.println(b); //Comprobamos que el valor se ha incrementado.
}
}
Devuelve:
Operador Condicional: ?:
El siguiente operador evalúa una condición y asigna un valor si es verdadera u otro valor si es falsa.
x = (expresion logica) ? valorSiVerdadero : valorSiFalso
Por ejemplo:
int nota = 80;
String resultado = (nota >= 65)? "Aprobado!!!" : "Suspenso";
Operadores Lógicos: &, |, &&, ||, ^, !
& y | son los operadores And y Or lógicos. Evalúan siempre ambas condiciones. No tienen evaluación perezosa.
&& y || son los operadores And y Or lógicos con evaluación perezosa.
Quiere decir que si pueden dar el resultado evaluando solo la primera condición no evaluarán la segunda.
Esto se da cuando:
- La primera condición en || es cierta, independientemente de la segunda condición el resultado ya es cierto.
- La primera condición en && es falsa, independientemente de la segunda condición el resultado es falso.
Un ejemplo con operadores de incremento para comprobar los diferentes resultados que podemos obtener si usamos un operador con evaluación normal o perezosa:
class Logicos{
public static void main (String[] args){
int a = 0; //Valores para operadores &, |
int b = 5;
int c = 0; //Valores para operadores perezosos &&, ||
int d = 5;
if ( a == 0 | b++ > 2) //Evalúa las dos condiciones y b se incrementa.
{ System.out.println("Cierto (a==0 | b++ > 2)-> a: " + a + " b: " + b); }
if (c == 0 || d++ > 2) //Evalúa solo la 1ª condición al ser cierta (c==0), b no incrementa.
{ System.out.println("Cierto (c==0 || d++ > 2)-> c: " + c + " d: " + d); }
System.out.println();
if (a > 0 & b++ < 5) //Evalúa las dos condiciones, b se incrementa de nuevo.
{ }
else
{ System.out.println("Falso (a>0 & b++ a: " + a + " b: " + b); }
if (c > 0 && d++ < 5) //Evalúa solo la 1ª condición por ser falsa (c > 0), d no incrementa.
{ }
else
{ System.out.println("Falso (c>0 && d++ <5) -> c: " + c + " d: " + d); }
}
}
Devuelve:
^ es el operador Xor. Devueve cierto cuando una de las condiciones es falsa y la otra verdadera.
Siempre evalúa ambos operandos.
! es el operador Not. Si la condición es cierta devuelve falso y si es falsa devuelve cierto.
Con esto terminamos el tema de Operadores.
Recordaros que los operadores de desplazamiento de bits no entran en el examen para la versión 6. Os podéis encontrar preguntas sobre desplazamiento de bits en cuestionarios por ser de versiones anteriores.
En este post tenéis algunos ejercicios resueltos sobre Operadores.
Me gusta:
Sé el primero en decir que te gusta esta post.
