Ir al contenido principal

Variables y tipos de datos primitivos en Java

Introducción

En cualquier lenguaje de programación, las variables son elementos fundamentales que nos permiten almacenar y manipular datos. En Java, por ser un lenguaje fuertemente tipado, cada variable debe tener un tipo de dato específico que determina qué clase de información puede contener y qué operaciones se pueden realizar con ella. En este artículo, exploraremos los diferentes tipos de datos primitivos que ofrece Java, cómo declarar variables y las mejores prácticas para su uso. Estos conocimientos constituyen la base sobre la que construiremos conceptos más avanzados en nuestra formación como programadores Java.

¿Qué son las variables?

Una variable en Java es un espacio en la memoria del ordenador que se utiliza para almacenar un valor. Cada variable tiene:

  • Un nombre o identificador
  • Un tipo de dato
  • Un valor (que puede cambiar a lo largo del programa)

Declaración de variables

En Java, las variables deben declararse antes de utilizarse, especificando su tipo y nombre:

tipo nombreVariable;

También podemos asignar un valor inicial en el momento de la declaración:

tipo nombreVariable = valor;

Reglas para nombrar variables

Los nombres de variables en Java deben seguir ciertas reglas:

  • Pueden contener letras, dígitos, guiones bajos (_) y símbolos de dólar ($)
  • Deben comenzar con una letra, guion bajo o símbolo de dólar (nunca con un número)
  • No pueden ser palabras reservadas de Java (como class, if, while, etc.)
  • Son sensibles a mayúsculas y minúsculas (distingue entre contador y Contador)

Por convención, los nombres de variables:

  • Comienzan con minúscula
  • Si contienen múltiples palabras, utilizan camelCase (primera palabra en minúscula, siguientes con inicial mayúscula)
  • Deben ser descriptivos sobre el contenido o propósito de la variable

Ejemplos correctos:

int edad;
double precioProducto;
String nombreUsuario;
boolean estaActivo;

Ejemplos incorrectos:

int 1numero;       // Error: comienza con un número
double precio-producto;  // Error: contiene un guion
char class;        // Error: palabra reservada

Tipos de datos primitivos en Java

Java ofrece ocho tipos de datos primitivos, que se dividen en cuatro categorías:

1. Tipos enteros

Almacenan números enteros (sin parte decimal):

Tipo Tamaño (bits) Rango Valor por defecto
byte 8 -128 a 127 0
short 16 -32.768 a 32.767 0
int 32 -2.147.483.648 a 2.147.483.647 0
long 64 -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 0L

Ejemplos:

byte edad = 25;
short codigoPostal = 28001;
int poblacion = 3200000;
long distanciaEnKm = 384400L;  // La 'L' indica que es un literal de tipo long

2. Tipos de punto flotante

Almacenan números con parte decimal:

Tipo Tamaño (bits) Precisión Valor por defecto
float 32 7 dígitos decimales 0.0f
double 64 15 dígitos decimales 0.0d

Ejemplos:

float altura = 1.75f;    // La 'f' indica que es un literal de tipo float
double pi = 3.14159265359;

3. Tipo carácter

Almacena un único carácter Unicode:

Tipo Tamaño (bits) Descripción Valor por defecto
char 16 Un carácter Unicode (0 a 65535) '\u0000'

Ejemplos:

char letra = 'A';
char simbolo = '@';
char digito = '7';
char espacio = ' ';

4. Tipo booleano

Almacena un valor lógico (verdadero o falso):

Tipo Valores posibles Valor por defecto
boolean true, false false

Ejemplos:

boolean esEstudiante = true;
boolean tieneLicencia = false;

Declaración y asignación de variables

Declaración simple

Podemos declarar variables sin asignarles valor:

int contador;
double temperatura;

En este caso, las variables de tipo primitivo que sean atributos de clase (no locales) se inicializan automáticamente con su valor por defecto.

Declaración con inicialización

Es una buena práctica inicializar las variables al declararlas:

int contador = 0;
double temperatura = 36.5;

Declaraciones múltiples

Podemos declarar varias variables del mismo tipo en una sola línea:

int x = 10, y = 20, z = 30;

Modificación de variables

El valor de una variable puede cambiar durante la ejecución del programa:

int edad = 25;
System.out.println("Edad actual: " + edad);

edad = 26;  // Modificamos el valor
System.out.println("Edad después del cumpleaños: " + edad);

Constantes

Si queremos definir valores que no deben cambiar durante la ejecución del programa, usamos la palabra clave final:

final double PI = 3.14159265359;
final int DIAS_SEMANA = 7;

Por convención, los nombres de constantes se escriben en mayúsculas y usando guiones bajos para separar palabras.

Literales en Java

Los literales son valores constantes que aparecen directamente en el código:

Literales enteros

int decimal = 10;       // Decimal (base 10)
int octal = 012;        // Octal (base 8) comienza con 0
int hexadecimal = 0xA;  // Hexadecimal (base 16) comienza con 0x
int binario = 0b1010;   // Binario (base 2) comienza con 0b (desde Java 7)

Literales de punto flotante

double d1 = 123.4;
double d2 = 1.234e2;    // Notación científica: 1.234 × 10²
float f1 = 123.4f;      // La 'f' indica que es float

Literales de caracteres

char c1 = 'A';
char c2 = '\t';         // Tabulación
char c3 = '\u0041';     // Representación Unicode de 'A'

Literales booleanos

boolean b1 = true;
boolean b2 = false;

Literal especial

String s = null;        // Representa una referencia nula

Inferencia de tipos con var (desde Java 10)

Desde Java 10, podemos usar la palabra clave var para que el compilador infiera el tipo de la variable a partir del valor asignado:

var contador = 10;              // Infiere que es int
var mensaje = "Hola, mundo";    // Infiere que es String
var precio = 19.99;             // Infiere que es double

Restricciones importantes:

  • Solo funciona con variables locales (dentro de métodos)
  • La variable debe inicializarse en la misma línea
  • No funciona con variables de clase o parámetros de métodos

Conversión entre tipos primitivos

Conversión implícita (widening)

Java realiza conversiones automáticas cuando no hay pérdida de información:

byte b = 100;
int i = b;    // Conversión automática de byte a int

La jerarquía de tipos para conversión implícita es:

byte → short → int → long → float → double
char → int → long → float → double

Conversión explícita (narrowing)

Cuando puede haber pérdida de información, debemos hacer un casting explícito:

double d = 100.58;
int i = (int) d;    // Casting explícito, i = 100 (se pierde la parte decimal)

Ejemplos prácticos

Calculadora de promedio

public class CalculadoraPromedio {
    public static void main(String[] args) {
        // Declaración e inicialización de variables
        int nota1 = 85;
        int nota2 = 90;
        int nota3 = 78;
        
        // Cálculo del promedio
        double promedio = (nota1 + nota2 + nota3) / 3.0;
        
        // Mostrar resultado
        System.out.println("El promedio de las notas es: " + promedio);
    }
}

Conversor de temperatura

public class ConversorTemperatura {
    public static void main(String[] args) {
        // Constantes
        final double FACTOR_CONVERSION = 1.8;
        final int AJUSTE = 32;
        
        // Temperatura en Celsius
        double temperaturaCelsius = 25.0;
        
        // Conversión a Fahrenheit
        double temperaturaFahrenheit = (temperaturaCelsius * FACTOR_CONVERSION) + AJUSTE;
        
        // Mostrar resultado
        System.out.println(temperaturaCelsius + " grados Celsius equivalen a " + 
                           temperaturaFahrenheit + " grados Fahrenheit");
    }
}

Cálculo del área de un círculo

public class AreaCirculo {
    public static void main(String[] args) {
        // Constante
        final double PI = 3.14159;
        
        // Radio del círculo
        double radio = 5.0;
        
        // Cálculo del área
        double area = PI * radio * radio;
        
        // Mostrar resultado
        System.out.println("El área del círculo con radio " + radio + 
                           " es: " + area + " unidades cuadradas");
    }
}

Resumen

Las variables y los tipos de datos primitivos son las unidades básicas para almacenar información en Java. Hemos explorado los ocho tipos primitivos que ofrece el lenguaje: enteros (byte, short, int, long), de punto flotante (float, double), carácter (char) y booleano (boolean). Además, hemos aprendido las reglas para declarar variables, inicializarlas y modificar su valor, así como el uso de constantes mediante la palabra clave final. Estos conceptos fundamentales son esenciales para cualquier programa Java y nos servirán como base para los temas más avanzados que veremos en los siguientes artículos del tutorial.

Volver arriba