> 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/tipos-de-datos.md).
# Tipos de datos
En Java, os **tipos de datos primitivos** son os tipos máis básicos que a linguaxe ofrece para almacenar información. Estes tipos non son obxectos e almacénanse directamente na memoria. Java ofrece 8 tipos de datos primitivos, que se dividen en **numéricos**, **caracteres** e **lóxicos**.
Aquí están os 8 tipos primitivos en Java:
## Tipos numéricos enteiros(sen decimais)
Estes tipos úsanse para almacenar números enteiros, sen parte decimal.
* **`byte`**: Almacena números enteiros pequenos.
* **Tamaño**: 8 bits (1 byte).
* **Intervalo**: de -128 a 127.
* **Uso**: Adecuado para almacenar pequenas cantidades de datos e reducir o consumo de memoria en grandes `arrays`:copy: de números enteiros.
Exemplo:
```java
byte idade = 25;
```
* **`short`**: Almacena números enteiros de tamaño mediano.
* **Tamaño**: 16 bits (2 bytes).
* **Intervalo**: de -32.768 a 32.767.
* **Uso**: Útil cando se precisa máis rango que `byte` pero aínda se quere aforrar memoria en comparación con `int`.
Exemplo:
```java
short ano = 2024;
```
* **`int`**: O tipo máis común para números enteiros.
* **Tamaño**: 32 bits (4 bytes).
* **Intervalo**: de -2.147.483.648 a 2.147.483.647.
* **Uso**: É o tipo predeterminado para a maioría dos números enteiros.
Exemplo:
```java
int poboacion = 1000000;
```
* **`long`**: Para números enteiros moi grandes.
* **Tamaño**: 64 bits (8 bytes).
* **Intervalo**: de -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807.
* **Uso**: Útil cando se traballa con cifras moi grandes como contadores ou cifras financeiras.
* **Nota**: Debe incluírse un `L` ao final do número para especificar que é un `long`.
Exemplo:
```java
long distanciaEstrelas = 12345678901234L;
```
## Tipos numéricos de punto flotante (con decimais)
Estes tipos úsanse para almacenar números con parte decimal.
* **`float`**: Almacena números de punto flotante (con decimais) de precisión simple.
* **Tamaño**: 32 bits (4 bytes).
* **Intervalo**: Aproximadamente de 3.4e−038 a 3.4e+038.
* **Uso**: Adecuado para cálculos que non requiren unha gran precisión.
* **Nota**: Os valores `float` deben ter un `f` ao final para diferencialos dos `double`:copy:.
Exemplo:
```java
float temperatura = 23.7f;
```
* **`double`**:copy:: Almacena números de punto flotante de precisión dobre.
* **Tamaño**: 64 bits (8 bytes).
* **Intervalo**: Aproximadamente de 1.7e−308 a 1.7e+308.
* **Uso**: É o tipo predeterminado para números decimais en Java e é adecuado para cálculos máis precisos.
Exemplo:
```java
double prezo = 19.99;
```
## Tipo carácter
O tipo de datos **`char`** almacena un único carácter Unicode.
* **Tamaño**: 16 bits (2 bytes).
* **Intervalo**: de 0 a 65.535 (inclúe caracteres de diferentes alfabetos, símbolos, etc.).
* **Uso**: Útil para almacenar letras, números ou calquera outro carácter en formato Unicode.
Exemplo:
```java
char inicial = 'A';
```
Java utiliza a codificación **Unicode** que consiste en identificar cada carácter mediante un número único chamado `code pint`:copy:. Este pode representarse en decimal (de 0 ao 65535), ou con número de 4 cifras decimais.
A hora de seleccionar un carácter pódese utilizar a súa codificación Unicode ou co propio carácter se é posible escribilo mediante teclado.
```java
char c;
c = 'a';
c = 97; // Asignase o valor 'a' mediante un número decimal que se corresponde con ese caracter
c = '\u0061'; // Asignase o valor 'a' mediante un número hexadecimal que se corresponde con ese caracter
```
Unicode funciona de xeito similar ao visto en Python con ASCII, pero Unicode conta con moitos máis caracteres:
* [Caracteres Unicode](https://symbl.cc/es/unicode-table/)
O código ASCII tamén está incluído en Unicode, constituíndo os 128 primeiros caracteres.
:fw: Comiñas simple para char
Os valores de tipo `char` deben estar entre comiñas simples (`'A'`).
En cambio as cadeas de texto deben de estar entre comiñas dobres (`"A"`)
## Tipo lóxico
O tipo de datos **`boolean`**:copy: almacena valores lóxicos.
* **Tamaño**: Non está definido exactamente en termos de bits, pero almacena dous valores posibles: `true` ou `false`.
* **Uso**: Usado para controlar a lóxica dos programas (condicións, bucles, etc.).
Exemplo:
```java
boolean activo = true;
```
## Resumo dos tipos primitivos
| Tipo | Tamaño | Intervalo | Exemplo |
| -------------------------------------- | ------- | ------------------------------- | ------------------------------------------------------ |
| `byte` | 8 bits | -128 a 127 | `byte b = 100;`:copy: |
| `short` | 16 bits | -32.768 a 32.767 | `short s = 300;`:copy: |
| `int` | 32 bits | -2^31 a 2^31-1 | `int i = 50000;`:copy: |
| `long` | 64 bits | -2^63 a 2^63-1 | `long l = 9000000000L;`:copy: |
| `float` | 32 bits | ±3.4e−038 a ±3.4e+038 | `float f = 3.14f;`:copy: |
| `double`:copy: | 64 bits | ±1.7e−308 a ±1.7e+308 | `double d = 3.141592653;`:copy: |
| `char` | 16 bits | 0 a 65.535 (caracteres Unicode) | `char c = 'A';`:copy: |
| `boolean`:copy: | 1 bit | `true` ou `false` | `boolean b = true;`:copy: |
## Overflow en Java
En Java, o ***overflow*** acontece cando un valor supera os límites do tipo de dato en que se almacena. Isto é común con tipos de datos primitivos como `int`, `byte`, etc. Se se intenta almacenar un valor máis grande que o máximo permitido ou menor que o mínimo, o valor sufre un *overflow* ou *underflow*, e a variable volve ao valor oposto dentro do seu rango.
Por exemplo, un `int` en Java é un número enteiro de 32 bits (4 bytes) con rango de valores entre `-2,147,483,648`:copy: (mínimo) e `2,147,483,647`:copy: (máximo). Se realizamos unha operación que resulta nun valor superior a `2,147,483,647`:copy: ou inferior a `-2,147,483,648`:copy:, ocorre un *overflow* ou *underflow*, e o valor “rebota” ao extremo oposto.
No seguinte exemplo, intentamos sumar 1 ao valor máximo dun `int`, o que causa un *overflow*:
```java
public class App {
public static void main(String[] args) {
int maxInt = Integer.MAX_VALUE; // Valor máximo de int (2,147,483,647)
System.out.println("Valor máximo de int: " + maxInt);
int overflowedInt = maxInt + 1; // Isto causa un overflow
System.out.println("Despois do overflow: " + overflowedInt); // Resultado: -2,147,483,648
}
}
```
**Saída**:
```
Valor máximo de int: 2147483647
Despois do overflow: -2147483648
```
No exemplo:
* `maxInt`:copy: contén o valor máximo dun `int`.
* Ao sumar 1 a `maxInt`:copy:, o valor excede o límite e rebota ao valor mínimo dun `int` (`-2,147,483,648`:copy:), causando un overflow.
O mesmo ocorre en ***underflow*** cando restas 1 ao valor mínimo dun `int` (`Integer.MIN_VALUE`:copy:).
---
# 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/tipos-de-datos.md?ask=
```
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.