Tipos de operadores en Java

En Java se utiliza varios tipos de operadores: aritméticos, condicionales, de Bit, de asignación, de precedencia, y el operador ternario, conocer cada uno de estos operadores es imprescindible para poderlos utilizar y que nuestros programas estén optimizados.

Estos datos son manipulados en distintas operaciones, para sumar, restar, multiplicar, etc., hasta realizar operaciones más complejas, todos estos operadores son de fácil uso.

Operadores aritméticos de Java

Estos operadores son los que más se utiliza al momento de realizar nuestros programas en Java, a continuación se muestra una tabla con estos operadores de Java.

Debemos tomar en cuenta que no es lo mismo dividir dos números enteros que dos números de coma flotante, a continuación un ejemplo con estos operadores de Java.

Ejemplo

/**
 *
 * @author Creatividad Codificada
 */
public class OperadoresAritmeticos {

    /**
     * @param args the command line arguments
     */
        public static void main(String[] args) {
        
        byte x = 27, y = 15, resultado;
        float x1 = 27, y1 = 15, resultado1; 
        resultado = (byte)(x / y);
        resultado1 = x1 / y1;
        
        System.out.println("x=27 y=15 :: x1=27 y1=15 ");//Variables
        System.out.println("x + y = "+(x+y));//Suma
        System.out.println("x - y = "+(x-y));//Resta
        System.out.println("x * y = "+(x*y));//Producto
        System.out.println("x % y = "+(x%y));//Modulo
        System.out.println("x / y = "+resultado+"(Numeros enteros)");//Division
        System.out.println("x1 / y1 = "+resultado1+"(Numeros de coma flotante)");//Division
       
    }
}

Resultado

x=27 y=15 :: x1=27 y1=15
x + y = 42
x - y = 12
x * y = 405
x % y = 12
x / y = 1(Numeros enteros)
x1 / y1 = 1.8(Numeros de coma flotante)

Operadores condicionales de Java

Estos operadores de Java se utilizan para comparar valores, además siempre devolverán valores booleanos, a continuación se mostrara una tabla con estos operadores.

EL operador lógico && (“Y” lógico) se utiliza para comparar dos o más expresiones de modo que si ambas son verdaderas el resultado final será también verdadero (true) en caso contrario será falso, el operador lógico || (“O” lógico) se utiliza también para comparar dos expresiones, Cuando una de las expresiones sea verdadera (true) el resultado también será verdadera (true) en caso de que ninguno sea verdadero (true) el resultados será falso (false).

Para entender de mejor manera todos estos operadores lógicos de Java se realizara un ejemplo utilizando todos estos operadores.

Ejemplo

/**
 *
 * @author Creatividad Codificada
 */
public class OperadoresLogicos {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    
        boolean mayor, menor;
        byte edad1=15, edad2=18;
        System.out.println("Edad1 = 15 :: Edad2 = 18");
        System.out.println("Edad1 < Edad2 = "+(edad1<edad2));
        System.out.println("Edad1 > Edad2 = "+(edad1>edad2));
        System.out.println("Edad1 >= Edad2 = "+(edad1>=edad2));
        System.out.println("Edad1 <= Edad2 = "+(edad1<=edad2));
        System.out.println("Edad1 == Edad2 = "+(edad1==edad2));
        System.out.println("Edad1 != Edad2 = "+(edad1!=edad2));
        System.out.println("Edad1 != Edad2 = "+!(edad1!=edad2)+"(NOT)");
        System.out.print("(Edad1 < Edad2) && (Edad1==15) = ");
        System.out.println((edad1 < edad2) && (edad1==15));
        System.out.print("(Edad1 == Edad2) || (Edad1 < 18) = ");
        System.out.println((edad1 == edad2) || (edad1 <= 18));
    }
}

Resultado

Edad1 = 15 :: Edad2 = 18
Edad1 < Edad2 = true Edad1 > Edad2 = false
Edad1 >= Edad2 = false
Edad1 <= Edad2 = true
Edad1 == Edad2 = false
Edad1 != Edad2 = true
Edad1 != Edad2 = false(NOT)
(Edad1 < Edad2) && (Edad1==15) = true
(Edad1 == Edad2) || (Edad1 < 18) = true

Operadores de BIT de Java

Estos operadores son muy utilizados cuando queremos trabajar directamente con bits, cuando hablamos de este tipo de operador tenemos que tomar en cuenta que las operaciones se hacen en binario aunque trabajemos en decimal, octal o hexadecimal, es decir si trabajo con un número entero decimal internamente Java lo transforma en número binario (100 (decimal) = 1100100 (Binario)), a continuación se muestra una tabla con todos estos operadores de BIT de Java.

Cuando se habla de AND, OR, XOR y NOT estamos hablando de lógica binaria, utilizada en gran medida en la electrónica digital si tienes algún conocimiento de electrónica seguro lo entiendes a la perfección y si no, no te preocupes en posteriores artículos realizaremos proyectos con estos operadores para tu mejor comprensión.

Ejemplo

/**
 *
 * @author Creatividad Codificada
 */
public class OperadoresdeBit {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int x = 50;
        int y = 10;
        System.out.print("x = 50");
        System.out.println(" :: 50 en Binario : 110010 ");
        System.out.print("x>>1 = " + (x>>1));
        System.out.println(" :: 25 en Binario : 011001 ");
        System.out.println("recorrio una posicion a la derecha");
        System.out.println("x&y = "+ (x&y));
        System.out.println("x|y = "+ (x|y));
        System.out.println("x^y = "+ (x^y));
        System.out.println("~x = "+ (~x));
    }
}

Resultado

x = 50 :: 50 en Binario : 110010
x>>1 = 25 :: 25 en Binario : 011001
recorrio una posicion a la derecha
x&y = 2
x|y = 58
x^y = 56
~x = -51

Como abran visto este ejemplo no está completo falta realizar ejemplos con desplazamiento a la izquierda, desplazamiento a la derecha con relleno de ceros y desplazamiento izquierda con relleno de ceros, sería muy bueno que practiquen modificando el código del ejemplo para trabajar con los operadores faltantes y ver qué sucede.

Operadores de asignación de Java

Como su nombre dice estos operadores asignan un valor a una variable, el operador más usado es sin duda es “=”, además se pueden usar expresiones complejas como: x += 3;  es igual  x = x + 3;

Y si necesitamos en algún programa una expresión compleja podemos utilizar los que muestra la siguiente tabla.

También existe lo operadores de asignación de incremento (++) y decremento (–), que son muy utilizados cuando queremos trabajar con series de números y muchas otras aplicaciones.

 x++; //esto es x=x+1;
 x--; //esto es x=x-1;

Cuando empecemos a trabajar con estos operadores debemos saber que no es igual trabajar con x++ que trabajar con ++x.

Ejemplo

/**
 *
 * @author Creatividad Codificada
 */
public class OperadoresdeAsignacion {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        short x = 2;
        short y = 2;
                
        //Toma en valor inicial de x = 2
        System.out.println("x++ = "+ (x++));
        
        //ahora x = 3, pero como incia con un incremento
        //su valor final sera x = 4
        System.out.println("++x = "+ (++x));
        
        //y+=3 :: y=y+3
        System.out.println("y+=3 -> y = "+ (y += 3));
    }
}

Resultado

x++ = 2
++x = 4
y+=3 -> y = 5

Operador condicional ternario de Java

Este operador nos permite ejecutar una acción u otra dependiendo del valor de la condición en unas sola línea.

Sintaxis

expresionlogica? valorSiVerdadero : valorSiFalso;

Ejemplo

/**
 *
 * @author Creatividad Codificada
 */
public class OperadorTernario {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int edad = 5, entrada;
        entrada=(edad>10)?60:30; // operador ternario
        System.out.println("Precio de la entrada = "+entrada);
    }
}

Resultado

Precio de la entrada = 30

Si el usuario es mayor de 10 años pagara 60 y si no pagara solo 30.

Precedencia

Muchas veces cuando trabajamos con muchos operadores en una misma expresión, existe la confusión con relación al resultado, por esto es importante saber cuál es precedencia correcta para tener la certeza de cuál es el resultado final de nuestra expresión, a continuación se muestra una tabla con el orden de precedencia que se usa en Java.

En esta tabla los operadores que tienen mayor precedencia están en la parte superior y los de menor precedencia en la parte inferior, ahora si vemos la tabla de izquierda a derecha la precedencia es la misma, por ejemplo si en una expresión existe una división y un producto en la misma línea el compilador de Java realizara primero la operación que este más a la izquierda.

10/5*2=4

Para sacarnos de cualquier duda sobre los resultados de alguna expresión se recomienda usar paréntesis para separar los operadores de Java.

Ejemplo

/**
 *
 * @author Creatividad Codificada
 */
public class Precedencia {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int resultado, resultado1;
        resultado = 10/5*2;
        resultado1 = 10/(5*2);
        
        System.out.println("10/5*2 = "+resultado);
        System.out.println("10/(5*2) = "+resultado1);
        System.out.println("10/5*2 es distinto de 10/(5*2)");
    }
}

Resultado

10/5*2 = 4

10/(5*2) = 1

10/5*2 es distinto de 10/(5*2)

Como pudimos observar existe una gran variedad de operadores en Java, por lo cual dependerá de nosotros cual es el más apropiado para nuestros programas.