2. Tipos de Datos y Variables

Tipos de Datos y Variables

En Java, los tipos de datos y las variables son conceptos fundamentales que definen cómo se almacena y manipula la información en un programa. Java es un lenguaje fuertemente tipado, lo que significa que todas las variables deben declararse con un tipo de dato específico antes de ser utilizadas.

2.1 Tipos de datos en Java

Java clasifica los tipos de datos en dos categorías principales:

1. Tipos primitivos: Almacenan valores simples y están predefinidos en el lenguaje.
2. Tipos de referencia: Almacenan referencias a objetos y pueden ser clases, interfaces o arrays.

2.1.1 Tipos de datos primitivos

Java proporciona ocho tipos de datos primitivos, que se dividen en cuatro grupos:

Tipos enteros

Los tipos enteros almacenan números enteros (sin parte decimal) de diferentes tamaños:

byte

• Tamaño: 8 bits (1 byte)
• Rango: -128 a 127
• Valor por defecto: 0
• Uso: Ahorro de memoria en arrays grandes o cuando se sabe que el valor estará dentro de su rango.
• Ejemplo:

  byte edad = 25;

short

• Tamaño: 16 bits (2 bytes)
• Rango: -32,768 a 32,767
• Valor por defecto: 0
• Uso: Cuando el rango de byte es insuficiente pero se quiere ahorrar memoria.
• Ejemplo:

  short temperatura = -200;

int

• Tamaño: 32 bits (4 bytes)
• Rango: -2,147,483,648 a 2,147,483,647
• Valor por defecto: 0
• Uso: Es el tipo más común para valores enteros. Java utiliza int como tipo predeterminado para literales enteros.
• Ejemplo:

  int poblacion = 1000000;

long

• Tamaño: 64 bits (8 bytes)
• Rango: -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807
• Valor por defecto: 0L
• Uso: Para valores enteros muy grandes, como identificadores únicos o timestamps.
• Ejemplo:

  long poblacionMundial = 7800000000L;

• Nota: El sufijo ‘L’ indica que es un literal de tipo long.

Tipos de punto flotante

Los tipos de punto flotante almacenan números con parte decimal:

float

• Tamaño: 32 bits (4 bytes)
• Rango: Aproximadamente ±3.40282347E+38F (6-7 dígitos significativos)
• Valor por defecto: 0.0f
• Uso: Cuando se necesita precisión decimal con menor uso de memoria.
• Ejemplo:

  float precio = 19.99f;

• Nota: El sufijo ‘f’ indica que es un literal de tipo float.

double

• Tamaño: 64 bits (8 bytes)
• Rango: Aproximadamente ±1.79769313486231570E+308 (15 dígitos significativos)
• Valor por defecto: 0.0d
• Uso: Es el tipo predeterminado para valores decimales en Java. Ofrece mayor precisión que float.
• Ejemplo:

  double pi = 3.14159265359;

Caution

Los tipos de punto flotante pueden tener problemas de precisión en cálculos financieros o cuando se requiere exactitud decimal. Para estos casos, se recomienda usar la clase BigDecimal.

Tipo caracter

char

• Tamaño: 16 bits (2 bytes)
• Rango: 0 a 65,535 (representa caracteres Unicode)
• Valor por defecto: ‘\u0000’ (carácter nulo)
• Uso: Almacena un único carácter Unicode.
• Ejemplo:

  char letra = 'A';

// Ejemplos de caracteres especiales y Unicode
char nuevaLinea = '
';
char tabulacion = '  ';
char comillaSimple = ''';
char comillaDoble = '"';
char caracterUnicode = 'Ñ';  // Representa la letra Ñ (Ñ)

Tipo booleano

boolean

• Tamaño: 1 bit (aunque la implementación JVM puede variar)
• Valores posibles: true o false
• Valor por defecto: false
• Uso: Representa valores de verdad, utilizado en expresiones condicionales.
• Ejemplo:

  boolean esActivo = true;

Tabla comparativa de tipos primitivos

Tipo	Tamaño	Rango	Valor por defecto
byte	8 bits	-128 a 127	0
short	16 bits	-32,768 a 32,767	0
int	32 bits	-2,147,483,648 a 2,147,483,647	0
long	64 bits	-9,223,372,036,854,775,808 a 9,223,372,036,854,775,807	0L
float	32 bits	±3.40282347E+38F (6-7 dígitos)	0.0f
double	64 bits	±1.79769313486231570E+308 (15 dígitos)	0.0d
char	16 bits	0 a 65,535 (Unicode)	‘\u0000’
boolean	1 bit*	true o false	false

Note

• El tamaño real de boolean puede variar según la implementación de la JVM.

2.1.2 Tipos de datos de referencia

Los tipos de datos de referencia son aquellos que almacenan referencias (direcciones de memoria) a objetos en lugar de almacenar los valores directamente. A diferencia de los tipos primitivos, los tipos de referencia se crean utilizando la palabra clave new (con algunas excepciones como String).

String

El tipo String es uno de los tipos de referencia más utilizados en Java. Representa una secuencia de caracteres y, aunque es técnicamente una clase, Java proporciona soporte especial para su uso:

Características

• Inmutabilidad: Los objetos String son inmutables, lo que significa que su contenido no puede cambiar después de ser creados.
• Pool de Strings: Java mantiene un pool de strings para optimizar el uso de memoria.
• Valor por defecto: null (como todos los tipos de referencia)
• Ejemplo:

  String nombre = "María";

Creación

Hay dos formas principales de crear un String:

// Usando literal de string (recomendado)
String nombre = "Juan";

// Usando el constructor (crea un nuevo objeto en el heap)
String apellido = new String("Pérez");

Métodos comunes

• length()

  - Devuelve la longitud del string

• charAt(int index)

  - Devuelve el carácter en la posición especificada

• substring(int beginIndex, int endIndex)

  - Extrae una subcadena

• equals(Object obj)

  - Compara el contenido con otro string

• toLowerCase()

  y

  toUpperCase()

  - Convierte a minúsculas/mayúsculas

• concat(String str)

  - Concatena strings

• trim()

  - Elimina espacios en blanco al inicio y final

Tip

Para comparar strings, siempre use el método

equals()

en lugar del operador

==

. El operador

==

compara referencias de memoria, mientras que

equals()

compara el contenido.

Arrays

Los arrays son estructuras de datos que almacenan múltiples valores del mismo tipo:

Características

• Tamaño fijo: Una vez creado, el tamaño del array no puede cambiar.
• Indexación: Los elementos se acceden mediante índices que comienzan en 0.
• Valor por defecto: null para arrays de objetos, 0 para arrays numéricos, false para arrays de boolean.

Declaración e inicialización

// Declaración
int[] numeros;  // Forma preferida
String nombres[];  // Forma alternativa

// Inicialización
numeros = new int[5];  // Array de 5 enteros
nombres = new String[3];  // Array de 3 strings

// Declaración e inicialización combinadas
int[] primos = {2, 3, 5, 7, 11};
String[] dias = {"Lunes", "Martes", "Miércoles"};

Acceso y manipulación

// Acceso a elementos
int primerNumero = numeros[0];
String segundoDia = dias[1];

// Modificación de elementos
numeros[2] = 42;
dias[0] = "Monday";

// Longitud del array
int longitud = numeros.length;

Clases y objetos

Las clases son plantillas para crear objetos, que son instancias de esas clases:

// Definición de una clase
public class Persona {
  // Atributos
  private String nombre;
  private int edad;

  // Constructor
  public Persona(String nombre, int edad) {
      this.nombre = nombre;
      this.edad = edad;
  }

  // Métodos
  public String getNombre() {
      return nombre;
  }
}

// Creación de objetos
Persona persona1 = new Persona("Ana", 30);
Persona persona2 = new Persona("Carlos", 25);

Wrappers (Clases envoltorio)

Java proporciona clases wrapper para cada tipo primitivo, permitiendo usarlos como objetos:

Tipo primitivo	Clase wrapper
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

// Autoboxing (conversión automática de primitivo a wrapper)
Integer num = 100;  // Equivalente a: Integer num = Integer.valueOf(100);

// Unboxing (conversión automática de wrapper a primitivo)
int valor = num;  // Equivalente a: int valor = num.intValue();

// Métodos útiles de las clases wrapper
String numStr = Integer.toString(42);  // Convierte int a String
int numInt = Integer.parseInt("42");  // Convierte String a int
Integer max = Integer.MAX_VALUE;  // Valor máximo de int

2.1.3 Variables y constantes

Las variables son espacios de memoria que almacenan valores que pueden cambiar durante la ejecución del programa. Las constantes, por otro lado, son valores que no pueden modificarse una vez definidos.

Declaración de variables

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

// Sintaxis básica
tipo nombreVariable;

// Ejemplos
int edad;
String nombre;
double salario;

Inicialización de variables

Las variables pueden inicializarse en el momento de la declaración o posteriormente:

// Inicialización en la declaración
int edad = 25;
String nombre = "Juan";

// Inicialización posterior
double salario;
salario = 2500.50;

Convenciones de nomenclatura

Java sigue ciertas convenciones para nombrar variables:

Reglas obligatorias

• Los nombres deben comenzar con una letra, un signo de dólar ($) o un guión bajo (_).
• Después del primer carácter, pueden contener letras, dígitos, signos de dólar y guiones bajos.
• No se pueden usar palabras reservadas de Java como nombres de variables.
• Java distingue entre mayúsculas y minúsculas (case-sensitive).

Convenciones recomendadas

• Usar camelCase para nombres de variables (primera letra en minúscula, primera letra de cada palabra subsiguiente en mayúscula).
• Los nombres deben ser descriptivos y reflejar el propósito de la variable.
• Evitar nombres de una sola letra, excepto para variables temporales como índices de bucles.

// Ejemplos de nombres siguiendo convenciones
int edadUsuario;
String nombreCompleto;
double tasaDeInteres;
boolean esActivo;

Declaración de constantes

En Java, las constantes se declaran usando las palabras clave final y generalmente static (para constantes de clase):

// Constante local
final double PI = 3.14159;

// Constante de clase (estática)
public static final int DIAS_SEMANA = 7;

// Constantes en una interfaz (implícitamente public, static y final)
interface Constantes {
  double GRAVEDAD = 9.8;
  String EMPRESA = "Mi Empresa S.A.";
}

Tip

Por convención, los nombres de las constantes se escriben en mayúsculas con palabras separadas por guiones bajos (SNAKE_CASE).

Variables de instancia vs. variables de clase

Variables de instancia

Pertenecen a un objeto específico (instancia de una clase).

public class Persona {
  // Variables de instancia
  private String nombre;
  private int edad;

  // Constructor
  public Persona(String nombre, int edad) {
      this.nombre = nombre;
      this.edad = edad;
  }
}

Variables de clase (estáticas)

Pertenecen a la clase en sí, no a instancias específicas. Se comparten entre todas las instancias.

public class Contador {
  // Variable de clase (estática)
  private static int contadorGlobal = 0;

  // Variable de instancia
  private int contadorLocal;

  public Contador() {
      contadorGlobal++;
      contadorLocal = contadorGlobal;
  }

  public static int getContadorGlobal() {
      return contadorGlobal;
  }

  public int getContadorLocal() {
      return contadorLocal;
  }
}

2.1.3 Conversión de tipos (casting)

La conversión de tipos en Java permite cambiar un valor de un tipo de dato a otro. Hay dos tipos principales de conversiones:

Conversión implícita (widening)

Ocurre automáticamente cuando se asigna un valor de un tipo de menor tamaño a uno de mayor tamaño, sin pérdida de información:

byte valorByte = 10;
short valorShort = valorByte;  // Conversión implícita de byte a short
int valorInt = valorShort;     // Conversión implícita de short a int
long valorLong = valorInt;     // Conversión implícita de int a long
float valorFloat = valorLong;  // Conversión implícita de long a float
double valorDouble = valorFloat; // Conversión implícita de float a double

Note

El orden de conversión implícita es: byte → short → int → long → float → double

Conversión explícita (narrowing)

Se requiere cuando se asigna un valor de un tipo de mayor tamaño a uno de menor tamaño, con posible pérdida de información. Se realiza mediante un operador de casting:

double valorDouble = 9.78;
float valorFloat = (float) valorDouble;  // Conversión explícita de double a float
long valorLong = (long) valorFloat;      // Conversión explícita de float a long
int valorInt = (int) valorLong;          // Conversión explícita de long a int
short valorShort = (short) valorInt;     // Conversión explícita de int a short
byte valorByte = (byte) valorShort;      // Conversión explícita de short a byte

Caution

La conversión explícita puede resultar en pérdida de información o precisión. Por ejemplo, al convertir un double a int, se pierde la parte decimal.

Ejemplos prácticos de casting

Conversión numérica

// Truncamiento de decimales
double precio = 23.56;
int precioRedondeado = (int) precio;  // precioRedondeado = 23

// Posible pérdida de información
int numeroGrande = 130;
byte numeroPequeno = (byte) numeroGrande;  // numeroPequeno = -126 (desbordamiento)

Conversión char-int

// Char a int (obtiene el valor Unicode)
char letra = 'A';
int valorUnicode = letra;  // valorUnicode = 65

// Int a char (convierte el valor numérico a su carácter Unicode)
int codigo = 66;
char caracter = (char) codigo;  // caracter = 'B'

Conversión con String

// Conversión de String a tipos primitivos
String edadTexto = "25";
int edad = Integer.parseInt(edadTexto);  // edad = 25

double salario = Double.parseDouble("2500.50");  // salario = 2500.50
boolean activo = Boolean.parseBoolean("true");  // activo = true

// Conversión de tipos primitivos a String
String edadComoTexto = String.valueOf(30);  // edadComoTexto = "30"
String precioComoTexto = Double.toString(45.75);  // precioComoTexto = "45.75"

Métodos de conversión en Java

Java proporciona varios métodos para convertir entre diferentes tipos de datos. Estos métodos son especialmente útiles cuando se trabaja con tipos de referencia y primitivos:

Métodos parse*

Convierten un String a un tipo primitivo:

Método	Descripción	Ejemplo
Integer.parseInt(String s)	Convierte un String a int	int num = Integer.parseInt("42");
Double.parseDouble(String s)	Convierte un String a double	double d = Double.parseDouble("3.14");
Float.parseFloat(String s)	Convierte un String a float	float f = Float.parseFloat("2.5f");
Long.parseLong(String s)	Convierte un String a long	long l = Long.parseLong("9876543210");
Short.parseShort(String s)	Convierte un String a short	short s = Short.parseShort("128");
Byte.parseByte(String s)	Convierte un String a byte	byte b = Byte.parseByte("120");
Boolean.parseBoolean(String s)	Convierte un String a boolean	boolean bool = Boolean.parseBoolean("true");

Caution

Los métodos parse* lanzan

NumberFormatException

si el String no tiene el formato adecuado.

Métodos valueOf

Convierten un valor (primitivo o String) a su correspondiente objeto wrapper:

Método	Descripción	Ejemplo
Integer.valueOf(String s)	Convierte un String a objeto Integer	Integer num = Integer.valueOf("42");
Integer.valueOf(int i)	Convierte un int a objeto Integer	Integer num = Integer.valueOf(42);
Double.valueOf(String s)	Convierte un String a objeto Double	Double d = Double.valueOf("3.14");
Boolean.valueOf(String s)	Convierte un String a objeto Boolean	Boolean b = Boolean.valueOf("true");
Character.valueOf(char c)	Convierte un char a objeto Character	Character c = Character.valueOf('A');

Tip

Los métodos valueOf son preferibles a los constructores de las clases wrapper, ya que pueden reutilizar objetos existentes (caché) para mejorar el rendimiento.

Métodos toString

Convierten valores a su representación en String:

Método	Descripción	Ejemplo
String.valueOf(tipo)	Método estático que convierte cualquier tipo a String	String s = String.valueOf(42);
Integer.toString(int i)	Convierte un int a String	String s = Integer.toString(42);
Double.toString(double d)	Convierte un double a String	String s = Double.toString(3.14);
objeto.toString()	Método de instancia que devuelve una representación en String del objeto	String s = new Integer(42).toString();

Conversiones especiales

Otros métodos útiles para conversiones específicas:

Método	Descripción	Ejemplo
Integer.toHexString(int i)	Convierte un int a su representación hexadecimal	String hex = Integer.toHexString(255); // "ff"
Integer.toBinaryString(int i)	Convierte un int a su representación binaria	String bin = Integer.toBinaryString(10); // "1010"
Integer.toOctalString(int i)	Convierte un int a su representación octal	String oct = Integer.toOctalString(10); // "12"
Character.getNumericValue(char ch)	Obtiene el valor numérico de un carácter	int val = Character.getNumericValue('5'); // 5
String.format()	Formatea valores en un String	String s = String.format("%.2f", 3.14159); // "3.14"

Note

Al trabajar con conversiones, siempre verifica que los valores estén dentro del rango del tipo de destino para evitar pérdida de datos o excepciones.

2.1.4 Ámbito de variables

El ámbito (scope) de una variable define dónde es accesible dentro del código. Java tiene varios niveles de ámbito:

Ámbito de bloque

Las variables declaradas dentro de un bloque de código (entre llaves {}) solo son accesibles dentro de ese bloque:

public void ejemploAmbitoBloque() {
  // Inicio del bloque externo
  int x = 10;

  if (x > 5) {
      // Inicio del bloque interno
      int y = 20;  // Variable de ámbito de bloque
      System.out.println(x);  // Accesible (x está en un bloque externo)
      System.out.println(y);  // Accesible
  }  // Fin del bloque interno

  System.out.println(x);  // Accesible
  // System.out.println(y);  // Error: y no es accesible aquí
}  // Fin del bloque externo

Ámbito de método

Las variables declaradas dentro de un método (variables locales) solo son accesibles dentro de ese método:

public class EjemploAmbito {
  public void metodo1() {
      int a = 10;  // Variable local al método1
      System.out.println(a);  // Accesible
  }

  public void metodo2() {
      // System.out.println(a);  // Error: a no es accesible aquí
      int b = 20;  // Variable local al método2
  }
}

Ámbito de clase

Las variables declaradas a nivel de clase (campos o atributos) son accesibles desde cualquier método dentro de la clase, dependiendo de su modificador de acceso:

public class Estudiante {
  // Variables de instancia (nivel de clase)
  private String nombre;  // Accesible solo dentro de esta clase
  protected int edad;     // Accesible en esta clase y sus subclases
  public String curso;    // Accesible desde cualquier parte

  public void establecerDatos(String nuevoNombre, int nuevaEdad) {
      nombre = nuevoNombre;  // Accesible
      edad = nuevaEdad;      // Accesible
      System.out.println(curso);  // Accesible
  }

  public void mostrarDatos() {
      System.out.println(nombre);  // Accesible
      System.out.println(edad);    // Accesible
  }
}

Variables estáticas vs. variables de instancia

Variables estáticas

Pertenecen a la clase, no a instancias específicas. Son compartidas por todas las instancias de la clase.

public class Contador {
  // Variable estática (compartida por todas las instancias)
  private static int contador = 0;

  public Contador() {
      contador++;
  }

  public static int getContador() {
      return contador;
  }
}

Uso:

Contador c1 = new Contador();  // contador = 1
Contador c2 = new Contador();  // contador = 2
System.out.println(Contador.getContador());  // Imprime 2

Variables de instancia

Cada instancia de la clase tiene su propia copia de estas variables.

public class Persona {
  // Variables de instancia (cada objeto tiene su propia copia)
  private String nombre;
  private int edad;

  public Persona(String nombre, int edad) {
      this.nombre = nombre;
      this.edad = edad;
  }
}

Uso:

Persona p1 = new Persona("Ana", 25);
Persona p2 = new Persona("Carlos", 30);
// p1 y p2 tienen diferentes valores para nombre y edad

Sombreado de variables (Variable Shadowing)

Ocurre cuando una variable declarada en un ámbito interno tiene el mismo nombre que una variable en un ámbito externo:

public class EjemploSombreado {
  private int x = 10;  // Variable de instancia

  public void metodo() {
      int x = 20;  // Variable local que sombrea la variable de instancia
      System.out.println(x);  // Imprime 20 (variable local)
      System.out.println(this.x);  // Imprime 10 (variable de instancia)
  }

  public void otroMetodo(int x) {  // Parámetro que sombrea la variable de instancia
      System.out.println(x);  // Imprime el valor del parámetro
      System.out.println(this.x);  // Imprime 10 (variable de instancia)
  }
}

Caution

El sombreado de variables puede hacer que el código sea confuso y propenso a errores. Es una buena práctica usar nombres diferentes para evitar este problema.

Resumen

• Java es un lenguaje fuertemente tipado con ocho tipos de datos primitivos: byte, short, int, long, float, double, char y boolean.
• Las variables deben declararse con un tipo específico antes de usarse y pueden ser locales, de instancia o estáticas.
• Las constantes se declaran con la palabra clave final y por convención se nombran en mayúsculas.
• La conversión de tipos puede ser implícita (automática) cuando se convierte de un tipo menor a uno mayor, o explícita (mediante casting) cuando se convierte de un tipo mayor a uno menor.
• El ámbito de una variable determina dónde es accesible en el código, y puede ser de bloque, de método o de clase.

Tip

Comprender bien los tipos de datos y el ámbito de las variables es fundamental para escribir código Java eficiente y libre de errores. Presta especial atención a las conversiones explícitas para evitar pérdidas de datos inesperadas.