> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud1-introduccion-a-programacion/execucion-secuencial/operadores.md).

# Operadores

En Java, os **operadores** son símbolos que se utilizan para realizar operacións sobre variables e valores. Existen varios tipos de operadores, cada un co seu propósito específico. Aquí están os principais grupos de operadores en Java:

## Operadores Aritméticos

Usados para realizar operacións matemáticas básicas.

* **`+`**: Suma
* **`-`**: Resta
* **`*`**: Multiplicación
* **`/`**: División (resulta en un `int` se ambos operandos son enteiros)
* **`%`**: Módulo (resto da división)

```java
int a = 10, b = 5;
int suma = a + b; // 15
int resto = a % b; // 0
```

## Operadores de Comparación

Usados para comparar valores e devolver un resultado booleano (`true` ou `false`).

* **`==`**: Igualdade
* **`!=`**: Diferente
* **`>`**: Maior
* **`<`**: Menor
* **`>=`**: Maior ou igual
* **`<=`**: Menor ou igual

```java
boolean sonIgual = (a == b); // false
boolean maior = (a > b); // true
```

## Operadores Lóxicos

Usados para combinar expresións booleanas.

* **`&&`**: AND (retorna `true` se ambas expresións son verdadeiras)
* **`||`**: OR (retorna `true` se polo menos unha das expresións é verdadeira)
* **`!`**: NOT (inverte o valor booleano)

```java
boolean x = true;
boolean y = false;
boolean resultado = x && y; // false
```

{% hint style="warning" %}
A **orde de precedencia** dos **operadores lóxicos** de mayor a menor precedencia é: !, &&, ||
{% endhint %}

## Operadores de Asignación

Usados para asignar valores a variables. Java permite operadores de asignación combinados.

* **`=`**: Asignación simple
* **`+=`**: Suma e asigna
* **`-=`**: Resta e asigna
* **`*=`**: Multiplicación e asigna
* **`/=`**: División e asigna
* **`%=`**: Módulo e asigna

```java
int c = 10;
c += 5; // c agora é 15
```

## Operadores Unarios

Operadores que actúan sobre un só operando.

* **`++`**: Incremento (aumenta o valor en 1)
* **`--`**: Decremento (reduza o valor en 1)

```java
int d = 5;
d++; // d agora é 6
```

**Pre-incremento e Post-incremento**

```java
int i = 5;
int j = 5;
//Pre-incremento: Primero incrementa y luego devuelve el valor
int resultado = ++i;
//i = 6, resultado = 6
//Post-incremento: Primero devuelve el valor y luego incrementa
int resultado2 = j++;
//j=6, resultado2 = 5
```

## Operadores Ternarios

Un operador que permite realizar unha asignación baseada nunha condición, similar a un `if` simple.

```java
int idade = 18;
String maiorDeIdade = (idade >= 18) ? "Si" : "Non"; // "Si"
```

## Operadores a nivel de byte

En Java, os **operadores a nivel de byte** (ou *bitwise*) traballan directamente sobre a representación binaria dos números. Estes operadores manipulan os bits individuais dos operandos, en vez de operar sobre os valores como un todo.

* **AND bit a bit (`&`)**: Realiza unha operación `AND` en cada bit dos operandos. O resultado terá un `1` só se ambos bits son `1`.

  ```java
  int a = 5;  // 0101 en binario
  int b = 3;  // 0011 en binario
  int resultado = a & b; // 0001 (1 en decimal)
  ```
* **OR bit a bit (`|`)**: Realiza unha operación `OR` en cada bit. O resultado terá un `1` se polo menos un dos bits é `1`.

  ```java
  int a = 5;  // 0101
  int b = 3;  // 0011
  int resultado = a | b; // 0111 (7 en decimal)
  ```
* **XOR bit a bit (`^`)**: Realiza unha operación `XOR` (ou exclusivo). O resultado terá un `1` se os bits son distintos.

  ```java
  int a = 5;  // 0101
  int b = 3;  // 0011
  int resultado = a ^ b; // 0110 (6 en decimal)
  ```
* **NOT bit a bit (`~`)** : Este operador inviste todos os bits, cambiando os `1` por `0` e viceversa.

  ```java
  int a = 5;  //  00000000 00000000 00000000 00000101
  int resultado = ~a; // 11111111 11111111 11111111 11111010 (-6 en decimal, por complemento a dous)
  ```
* **Desprazamento á esquerda (`<<`)**: Despraza os bits cara á esquerda, enchendo con ceros á dereita. Multiplica o número por `2^n`.

  ```java
  int a = 5;  // 00000101
  int resultado = a << 2; // 00010100 (20 en decimal)
  ```
* **Desprazamento á dereita con signo (`>>`)**: Despraza os bits cara á dereita, mantendo o bit de signo. Divide enteiramente por `2^n`.

  ```java
  int a = -20;  // 11111111 11111111 11111111 11101100 (en complemento a dous)
  int resultado = a >> 2; // 11111111 11111111 11111111 11111011 (-5 en decimal)
  ```
* **Desprazamento á dereita sen signo (`>>>`)**: Despraza os bits cara á dereita, enchendo con ceros, sen manter o signo.

  ```java
  int a = -20;
  int resultado = a >>> 2; // 00111111 11111111 11111111 11111011 (1073741819 en decimal)
  ```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://educacion.gitbook.io/programacion/ud1-introduccion-a-programacion/execucion-secuencial/operadores.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.