RSS

Archivo de la categoría: Tema4

Los Operadores en Java (II)

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.

Anuncios
 
6 comentarios

Publicado por en 4 noviembre, 2011 en Tema4

 

Etiquetas: , , , , , , , , ,

Los Operadores en Java (I)

Operadores

Los operadores son símbolos especiales que producen un nuevo valor a partir de uno o varios operandos.
Los valores producidos son, en la mayoría de los casos, booleanos o numéricos.


En la imagen tendríamos un ejemplo de un operador binario, que a partir de dos operandos produciría un nuevo valor.

En la siguiente tabla mostramos los operadores en Java, su orden de precedencia y su asociatividad.
(I-D: de izquierda a derecha, D-I: de derecha a izquierda).



Operador de Asignación: =
Cuando asignamos valor a variables de tipo primitivo hay casos en los que se produce un casting implícito, otros en los que es necesario un casting explícito y casos en los que se puede producir un truncamiento.
Cuando asignamos valores a variables de tipos de referencia debemos tener cuidado con el tipo.

Esto lo podemos ver en los posts del Tema3.



Operadores de Asignación Compuestos: +=, -=, *=, /=
Se tratan en el examen los cuatro anteriores por ser los más usuales.

Algunos ejemplos:

x += 10; //sería igual a  x = x + 10;
y -= 50; //sería igual a  y = y - 50;
z *= 7;  // equivale a  z = z * 7;
w /= 100; // equivale a w = w/100;

En los operadores compuestos la expresión de la derecha siempre se evalúa primero.

x *= 3 + 5; //sería equilvalente a x *= (3+5), es decir x = x * (3 + 5)  y no x = (x * 3) + 5.



Operadores Relacionales: <, <=, >, >=
Siempre devuelven true or false. Se suelen utilizar en sentencias ifs para comprobar condiciones o en expresiones para asignar el valor resultante a una variable boolean.

Pueden comparar cualquier combinación de enteros, reales o carácteres. Cuando se compara con un carácter se utiliza su valor Unicode numérico.

Ejemplos:

boolean resultado;
int x = 200;
if (x<=100)
{
  resultado = true;
}
else
{
  resultado = false;
}

También se podría hacer directamente:

boolean resultado;
resultado = (x<=100);

Con caracteres:

char a = 'A';
char b = 'B';
boolean resultado = a>b;



Operadores de Igualdad: ==, !=

Se pueden comparar dos números, dos carácteres, dos boolean o dos variables de referencia.
Cuando se comparan tipos primitivos devolverá true si ambos valores son iguales.
Cuando se comparan referencias devolverá true si las variables apuntan al mismo objeto.
(No si dos objetos son iguales).

Ejemplos:

class Igualdad{
    public static void main (String[] args)
    {
         int a = 100;
         char b = 'b';
         boolean res = true;

         char[] letras1 = {'a','b','c','d'};
         char[] letras2 = {'a','b','c','d'};

         if (a == 100L)
         { System.out.println("100 y 100L, Iguales");}

         if (res != (b&gt;a))
         { System.out.println("res distinto a (b>;a)");}

         if (letras1 == letras2) //Imprime distinto aunque ambos tengan el mismo contenido.
         { System.out.println("Iguales");} //porque cada referencia apunta a un obj distinto.
         else
         { System.out.println("Distintos");}

         letras2 = letras1; //hacemos que letras2 apunte a letras1

         if (letras1 == letras2) //Imprimirá iguales porque ahora
         { System.out.println("Iguales");} //apuntan al mismo objeto.
         else
         { System.out.println("Distintos");}
    }
}

 


Operador instanceof:

Se utiliza solo con referencias y comprueba si un objeto es de una clase o interfaz determinada.

Por ejemplo, supongamos la siguiente jerarquía de clases:


La clase Persona tiene una subclase Empleado. Empleado a su vez tiene una subclase Tecnico.
Además la clase Persona implementa la interfaz Modales.

Con las siguientes declaraciones:

Persona p1 = new Persona();
Persona p2 = new Empleado();
Empleado e1 = new Empleado();
Tecnico t1 = new Tecnico();
Boolean b;

¿Qué devolvería el operador instanceof en las siguientes líneas de código?

b = p1 is instanceof Persona;
b = p1 is instanceof Modales;
b = p1 is instanceof Object;
b = p1 is instanceof Empleado;
b = p1 is instanceof Tecnico;

b = p2 is instanceof Persona;
b = p2 is instanceof Empleado;
b = p2 is instanceof Modales;
b = p2 is instanceof Tecnico;

b = e1 is instanceof Empleado;
b = e1 is instanceof Modales;
b = e1 is instanceof Persona;
b = e1 is instanceof Tecnico;

b = t1 is instanceof Persona;
b = t1 is instanceof Modales;
b = t1 is instanceof Empleado;
b = t1 is instanceof Tecnico;

b = null is instanceof Persona;
b = e1 is instanceof String;

Seguimos con el resto de operadores en la siguiente entrada…

 
1 comentario

Publicado por en 2 noviembre, 2011 en Tema4

 

Etiquetas: , , , , , , , , ,

 
A %d blogueros les gusta esto: