Dominar Operadores en Java: Tipos, Sintaxis y Ejemplos Prácticos

Operadores en Java

En este tutorial, aprenderás sobre los diferentes tipos de operadores en Java, su sintaxis y cómo usarlos con la ayuda de ejemplos.

Los operadores son símbolos que realizan operaciones sobre variables y valores. Por ejemplo, + es un operador usado para adición, mientras que * es un operador usado para multiplicación.

Los operadores en Java se pueden clasificar en 6 tipos:

1. Operadores Aritméticos
2. Operadores de Asignación
3. Operadores Relacionales
4. Operadores Lógicos
5. Operadores Unarios
6. Operadores Bitwise

1. Operadores Aritméticos en Java

Los operadores aritméticos se usan para realizar operaciones aritméticas en variables y datos. Por ejemplo,

a + b;

Aquí, el operador + se usa para sumar dos variables a y b. De manera similar, hay varios otros operadores aritméticos en Java.

Ejemplo 1: Operadores Aritméticos

class Main {
    public static void main(String[] args) {
        // declarar variables
        int a = 12, b = 5;
        // operador de adición
        System.out.println("a + b = " + (a + b));
        // operador de sustracción
        System.out.println("a - b = " + (a - b));
        // operador de multiplicación
        System.out.println("a * b = " + (a * b));
        // operador de división
        System.out.println("a / b = " + (a / b));
        // operador módulo
        System.out.println("a % b = " + (a % b));
    }
}

Salida

a + b = 17
a - b = 7
a * b = 60
a / b = 2
a % b = 2

En el ejemplo anterior, hemos usado los operadores +, - y * para calcular operaciones de adición, sustracción y multiplicación.

Operador de División /

Observa la operación a / b en nuestro programa. El operador / es el operador de división.

Si usamos el operador de división con dos enteros, el cociente resultante también será un entero. Y si uno de los operandos es un número de punto flotante, el resultado también será en punto flotante.

En Java, (9 / 2) es 4
(9.0 / 2) es 4.5
(9 / 2.0) es 4.5
(9.0 / 2.0) es 4.5

Operador Módulo %

El operador módulo % calcula el residuo. Cuando a = 7 se divide por b = 4, el residuo es 3.

Nota: El operador % se usa principalmente con enteros.

2. Operadores de Asignación en Java

Los operadores de asignación se usan en Java para asignar valores a variables. Por ejemplo,

int age;
age = 5;

Aquí, = es el operador de asignación. Asigna el valor de su derecha a la variable de su izquierda. Es decir, 5 se asigna a la variable age.

Veamos más operadores de asignación disponibles en Java.

Ejemplo 2: Operadores de Asignación

class Main {
    public static void main(String[] args) {
        // crear variables
        int a = 4;
        int var;
        // asignar valor usando =
        var = a;
        System.out.println("var usando =: " + var);
        // asignar valor usando +=
        var += a;
        System.out.println("var usando +=: " + var);
        // asignar valor usando *=
        var *= a;
        System.out.println("var usando *=: " + var);
    }
}

Salida

var usando =: 4
var usando +=: 8
var usando *=: 32

3. Operadores Relacionales en Java

Los operadores relacionales se usan para comprobar la relación entre dos operandos. Por ejemplo,

// comprobar si a es menor que b
a < b;

Aquí, el operador < es el operador relacional. Comprueba si a es menor que b o no.

Devuelve true o false.

Ejemplo 3: Operadores Relacionales

class Main {
    public static void main(String[] args) {
        // crear variables
        int a = 7, b = 11;
        // valor de a y b
        System.out.println("a es " + a + " y b es " + b);
        // operador ==
        System.out.println(a == b); // false
        // operador !=
        System.out.println(a != b); // true
        // operador >
        System.out.println(a > b); // false
        // operador <
        System.out.println(a < b); // true
        // operador >=
        System.out.println(a >= b); // false
        // operador <=
        System.out.println(a <= b); // true
    }
}

Nota: Los operadores relacionales se usan en toma de decisiones y bucles.

4. Operadores Lógicos en Java

Los operadores lógicos se usan para comprobar si una expresión es true o false. Se usan en la toma de decisiones.

Ejemplo 4: Operadores Lógicos

class Main {
    public static void main(String[] args) {
        // operador &&
        System.out.println((5 > 3) && (8 > 5)); // true
        System.out.println((5 > 3) && (8 < 5)); // false
        // operador ||
        System.out.println((5 < 3) || (8 > 5)); // true
        System.out.println((5 > 3) || (8 < 5)); // true
        System.out.println((5 < 3) || (8 < 5)); // false
        // operador !
        System.out.println(!(5 == 3)); // true
        System.out.println(!(5 > 3)); // false
    }
}

Funcionamiento del Programa

• (5 > 3) && (8 > 5) devuelve true porque tanto (5 > 3) como (8 > 5) son true.
• (5 > 3) && (8 < 5) devuelve false porque la expresión (8 < 5) es false.
• (5 < 3) || (8 > 5) devuelve true porque la expresión (8 > 5) es true.
• (5 > 3) && (8 > 5) devuelve true porque la expresión (5 > 3) es true.
• (5 > 3) && (8 > 5) devuelve false porque tanto (5 < 3) como (8 < 5) son false.
• !(5 == 3) devuelve true porque 5 == 3 es false.
• !(5 > 3) devuelve false porque 5 > 3 es true.

5. Operadores Unarios en Java

Los operadores unarios se usan con un solo operando. Por ejemplo, ++ es un operador unario que aumenta el valor de una variable en 1. Es decir, ++5 devolverá 6.

Diferentes tipos de operadores unarios son:

Operadores de Incremento y Decremento

Java también proporciona operadores de incremento y decremento: ++ y -- respectivamente. ++ aumenta el valor del operando en 1, mientras que -- lo disminuye en 1. Por ejemplo,

int num = 5;
// aumentar num en 1
++num;

Aquí, el valor de num aumenta a 6 desde su valor inicial de 5.

Ejemplo 5: Operadores de Incremento y Decremento

class Main {
    public static void main(String[] args) {
        // declarar variables
        int a = 12, b = 12;
        int result1, result2;
        // valor original
        System.out.println("Valor de a: " + a);
        // operador de incremento
        result1 = ++a;
        System.out.println("Después del incremento: " + result1);
        System.out.println("Valor de b: " + b);
        // operador de decremento
        result2 = --b;
        System.out.println("Después del decremento: " + result2);
    }
}

Salida

Valor de a: 12
Después del incremento: 13
Valor de b: 12
Después del decremento: 11

En el programa anterior, hemos usado los operadores ++ y -- como prefijos (++a, --b). También podemos usar estos operadores como postfijos (a++, b++).

Hay una ligera diferencia cuando estos operadores se usan como prefijo versus cuando se usan como postfijo.

Para saber más sobre estos operadores, visita operadores de incremento y decremento.

6. Operadores Bitwise en Java

Los operadores bitwise en Java se usan para realizar operaciones en bits individuales. Por ejemplo,

Operación de complemento bitwise de 35
35 = 00100011 (En Binario)
~ 00100011
________
11011100 = 220 (En decimal)

Aquí, ~ es un operador bitwise. Invierte el valor de cada bit (0 a 1 y 1 a 0).

Los diversos operadores bitwise presentes en Java son:

Estos operadores no se usan generalmente en Java. Para saber más, visita Operadores Bitwise y de Desplazamiento en Java.

Otros Operadores

Además de estos operadores, hay otros operadores adicionales en Java.

Operador instanceof en Java

El operador instanceof verifica si un objeto es una instancia de una clase particular. Por ejemplo,

class Main {
    public static void main(String[] args) {
        String str = "Programiz";
        boolean result;
        // verifica si str es una instancia de la clase String
        result = str instanceof String;
        System.out.println("¿str es un objeto de String? " + result);
    }
}

Salida

¿str es un objeto de String? true

Aquí, str es una instancia de la clase String. Por lo tanto, el operador instanceof devuelve true. Para saber más, visita Java instanceof.

Operador Ternario en Java

El operador ternario (operador condicional) es una forma abreviada de la sentencia if-then-else. Por ejemplo,

variable = Expresión ? expresión1 : expresión2

class Java {
    public static void main(String[] args) {
        int februaryDays = 29;
        String result;
        // operador ternario
        result = (februaryDays == 28) ? "No es año bisiesto" : "Año bisiesto";
        System.out.println(result);
    }
}

Año bisiesto