Este tutorial le proporciona detalles sobre cómo usar operadores en programas Java. Es uno de los temas esenciales para que aprendas y uses en la programación real de Java.

Aprende a usar operadores en Java

El tutorial tiene las siguientes secciones para ayudarte a aprender rápidamente.

¿Qué son los operadores en la programación? ?

Un operador es un símbolo o un carácter que actúa como una función en línea.

Cada operador tiene una acción designada para realizar.
Los operadores toman entradas de los operandos (es decir, variables o una expresión o constantes). ).
Algunos de ellos funcionan con un solo operando (Unary) y otros con dos (Binario).

¿Qué tipo de operadores admite Java?

Java admite una amplia variedad de operadores para manipular datos, generalmente Almacenado en variables. Puede usarlos para realizar operaciones en variables.

También puede realizar operaciones en valores codificados. Los siguientes tipos de operadores son compatibles con Java:

Operadores aritméticos
Operadores lógicos
Operadores de bitwise
Operadores relacionales
Operadores de asignación
Operador de asignación
Operador de cesión
:
Como su nombre lo indica, los operadores aritméticos le permiten realizar operaciones aritméticas en variables de tipos de datos primitivos.

Estos incluyen:
```
 · + (Adición)

· - (Resta)

· * (Multiplicación)

· / (División)

·% (Módulo) Para almacenar el resto después de la división de dos números 
```
Ejemplo:
```
 int a = 10;
int b = 20;

int c = a + b; // var c será 30
int d = b - a; // var d evaluará a 10
int e = a * b; // var e almacenará 200
int f = b / a; // var f resultará en 2
int g = b% a; // var g será 0 
```
Debe leer – Tipos de datos en Java

Operadores lógicos:

Puede obtener estos para realizar operaciones lógicas AND, NOT y OR, como en electrónica digital. [19659011] AND y OR, ambos usan operandos binarios, mientras que NOT usa unary.

Para los operadores AND y OR, el compilador omite la segunda condición si el primero se evalúa como falso. Lo llamamos el efecto de cortocircuito.

Ejemplo:
```
 boolean a = true;
booleano b = falso;

boolean c =! a; // var c se vuelve falso, el invertido de a
boolean d = a && b; // var d llegará a falso ya que uno de los a y b es falso.
boolean e = a || segundo; // var e se convertirá en verdadero como uno de los a y b es verdadero. 
```
Operadores bit a bit:

Los operadores bit a bit proporcionan un mecanismo para manipular los bits individuales de un número.

Puede usarlos con números enteros tipos de datos. Incluyen:
```
 & (Bitwise AND)
| (Bitwise OR)
^ (Bitwise XOR)
~ (Complemento Bitwise) 
```
Ejemplo:
```
 int a = 4;
int b = 2;

int c = a & b; // var c obtendrá un 0 (0000)
int d = a ^ b; // var d obtendrá un 6 (0110)
int e = a | segundo; // var e también obtendrá un 6 (0110)
int f = ~ b; // var f obtendrá un 13 (1101) 
```
Operadores relacionales:

Los operadores relacionales le permiten realizar operaciones de relaciones como igualdad, mayor que, menor que, menor que igual a, etc.

Devuelven un valor booleano valore y trabaje en tipos de datos tanto enteros como flotantes.

Ejemplo:
```
 int a = 1;
int b = 2;
int c = 3;

int d = a == b; // var d llegará a falso
int e = a < b; // var e will get to true
int f = a > b; // var f llegará a falso
int g = c> = b; // var g llegará a true
int h = c! = a; // var h llegará a verdadero 
```
Operadores de asignación:

Los operadores de asignación le permiten almacenar el operando derecho o el resultado al operando de la izquierda.

También puede agruparlo con otros operadores (generalmente aritmética) para formar una declaración compuesta.

Ejemplo:
```
 int a = 1; // tarea simple
int b = 0;
b + = 2; // enunciado compuesto 
```
Operadores de cambios:

Los operadores de cambios le hacen cambiar los bits de un número en cualquier dirección hacia la izquierda o hacia la derecha según el valor mencionado. El operador produce un efecto similar al que obtienes de la multiplicación y división.

Estos incluyen:
```
 << (Left shift) To shift the bits of a number to the left
>> (Desplazamiento a la derecha con signo) Para desplazar los bits de un número a la derecha. El bit más a la izquierda depende del signo del número inicial.
>>> (Desplazamiento a la derecha sin signo) Para desplazar los bits de un número a la derecha. El bit situado más a la izquierda se establece en 0. 
```
Ejemplo:
```
 int a = 60; // a se acaricia como 0011 1100
int b = a << 2; // b gets the value 240 (1111 0000)
int c = a >> 2; // c obtiene el valor 15 (11111)
int d = a >>> 2; // d obtiene el valor 15 (0000 1111) 
```
Operadores unarios:

Los operadores unarios solo necesitan un operando. Los operandos son los valores que actúan como entrada en las operaciones. Estos incluyen:
```
 ++ Incremento por uno

- Disminución en uno 
```
Ejemplo:
```
 int a = 1; // tarea simple

int b = a ++; // b se convertirá en 2 y a también se incrementará en 1, es decir, 2
int c = a--; // c evaluará a 1 y a también disminuirá en 1 y se convertirá en 1 
```
Operadores Ternarios:

Los operadores Ternarios tienen tres operandos y son una versión abreviada de if-else.

Tiene la siguiente sintaxis :
```
 Condición? Si es verdadero: si es falso 
```
Ejemplo:
```
 int a = 1;
int b = 2;
int c = a> b? 3: 4; // c obtendrá 4 como resultado, ya que la condición se volverá falsa.
int d = a <b? 3: 4; // d obtendrá 3 como resultado, ya que la condición se volverá verdadera. 
```
instanceof Operator:

Este operador proporciona la capacidad de verificar si un objeto pertenece a una clase o interfaz en particular.

Utiliza lo siguiente sintaxis:
```
 (Nombre de objeto) instanceof (clase / tipo de interfaz) 
```
Después de la verificación, si el objeto resulta ser de la clase o tipo de interfaz, el operador devuelve el éxito, es decir, verdadero.

Ejemplo:
```
 String val = "Hello";
System.out.print (val instanceof String); 
```
La declaración anterior se imprime como verdadera.

Debe leerse: Escriba su primer programa Java

Precedencia de los operadores:

La prioridad o prioridad del operador define la Orden para evaluar una expresión. Ayuda a determinar qué operación ejecutar primero.

La evaluación comienza con los operadores que tienen una prioridad más alta y luego procesa aquellos con menor prioridad.

Si dos operadores tienen el mismo orden de prioridad, entonces se evalúan desde la izquierda a la derecha, excepto por una excepción del operador de asignación.