Tipos de Datos en Java

tipo nombreVariable;           // Declaración (reserva espacio, sin valor inicial)
tipo nombreVariable = valor;   // Declaración con inicialización (reserva y asigna)

int edad;                    // Declaración sin inicialización
edad = 25;                   // Asignación posterior

int cantidad = 100;          // Declaración con inicialización
double precio = 19.99;
char letra = 'A';
boolean activo = true;

// Declaración múltiple del mismo tipo (todas int)
int x, y, z;
int a = 1, b = 2, c = 3;

// ✅ Correcto (camelCase para variables y métodos)
int edadUsuario;
double precioTotal;
boolean estaActivo;
String nombreCompleto;

// ❌ Incorrecto (estilos de otros lenguajes)
int edad_usuario;    // snake_case (estilo C/Python) - NO usar
int EdadUsuario;     // PascalCase - reservado para nombres de clases
int EDAD_USUARIO;    // SCREAMING_SNAKE_CASE - reservado para constantes
int edadusuario;     // Sin separación - difícil de leer

byte edad = 25;          // OK: 25 está en el rango
byte temperatura = -10;  // OK: valores negativos permitidos
byte maximo = 127;       // OK: valor máximo
byte minimo = -128;      // OK: valor mínimo

// byte overflow = 128;  // ❌ ERROR de compilación: 128 fuera de rango

// ¿Qué pasa con overflow en tiempo de ejecución?
byte b = 127;
b = (byte)(b + 1);       // b = -128 (overflow, da la vuelta)

short poblacion = 30000;   // OK para ciudades pequeñas
short altitud = -500;      // Metros bajo el nivel del mar
short temperatura = 32767; // Máximo valor

// En la práctica, casi siempre es mejor usar int
int poblacionMejor = 30000;  // Más idiomático en Java

int cantidad = 1000000;          // Un millón
int saldo = -50000;              // Puede ser negativo
int poblacionCiudad = 45000000;  // Buenos Aires

// Constantes útiles de la clase Integer
int maximo = Integer.MAX_VALUE;  // 2147483647
int minimo = Integer.MIN_VALUE;  // -2147483648

// El literal 42 es automáticamente int
int respuesta = 42;

long poblacionMundial = 8_000_000_000L;  // 8 mil millones
long distanciaLuna = 384_400_000L;       // metros
long timestampActual = System.currentTimeMillis();  // Milisegundos desde 1970

// Constantes útiles
long maxLong = Long.MAX_VALUE;   // 9223372036854775807
long minLong = Long.MIN_VALUE;   // -9223372036854775808

int decimal = 42;        // Base 10 (decimal) - sin prefijo
int binario = 0b101010;  // Base 2 (binario) - prefijo 0b o 0B
int octal = 052;         // Base 8 (octal) - prefijo 0
int hexadecimal = 0x2A;  // Base 16 (hexadecimal) - prefijo 0x o 0X

// Todos representan el mismo valor: 42
System.out.println(decimal);      // 42
System.out.println(binario);      // 42
System.out.println(octal);        // 42
System.out.println(hexadecimal);  // 42

// Sin separadores (difícil de leer)
long poblacion = 8000000000L;
int binario = 0b11110000111100001111000011110000;

// Con separadores (mucho más claro)
long poblacionClara = 8_000_000_000L;            // 8 mil millones
int binarioClaro = 0b1111_0000_1111_0000_1111_0000_1111_0000;
double precio = 1_234_567.89;
long telefono = 011_4444_5555L;

// Reglas: no pueden estar al inicio, al final, ni junto al punto decimal
// int invalido1 = _1000;     // ❌ ERROR
// int invalido2 = 1000_;     // ❌ ERROR
// double invalido3 = 1_.5;   // ❌ ERROR

float temperatura = 36.5f;   // La f es OBLIGATORIA
float pi = 3.14159f;
float pequeno = 1.5e-10f;    // Notación científica: 1.5 × 10⁻¹⁰

// Sin la f, Java interpreta el literal como double
// float error = 36.5;   // ❌ ERROR: incompatible types (double to float)
float correcto = 36.5f;     // ✅ Con sufijo f
float tambienOk = (float)36.5;  // ✅ Con casting explícito

double precio = 19.99;       // No necesita sufijo (es el tipo por defecto)
double pi = 3.141592653589793;
double avogadro = 6.022e23;  // Notación científica: 6.022 × 10²³
double pequeno = 1.5e-300;   // Número muy pequeño

// Constantes útiles de la clase Double
double maxDouble = Double.MAX_VALUE;  // ≈1.7 × 10³⁰⁸
double minPositivo = Double.MIN_VALUE;  // ≈4.9 × 10⁻³²⁴ (mínimo positivo)

// numeroEexponente significa numero × 10^exponente
double grande = 1.5e10;    // 1.5 × 10¹⁰ = 15,000,000,000
double pequeno = 2.5e-8;   // 2.5 × 10⁻⁸ = 0.000000025
double velocidadLuz = 3e8; // 3 × 10⁸ m/s

// También funciona con float (agregá la f)
float grandeF = 1.5e10f;

double resultado = 0.1 + 0.2;
System.out.println(resultado);  // Imprime: 0.30000000000000004 (¡no 0.3!)

// ¿Por qué? 0.1 y 0.2 no tienen representación binaria exacta
// La suma acumula pequeños errores de redondeo

// Otro ejemplo clásico
double suma = 0.0;
for (int i = 0; i < 10; i = i + 1) {
    suma = suma + 0.1;
}
System.out.println(suma);  // Imprime: 0.9999999999999999 (¡no 1.0!)

// Infinitos (cuando el resultado es demasiado grande)
double infinito = Double.POSITIVE_INFINITY;     // +∞
double negInfinito = Double.NEGATIVE_INFINITY;  // -∞

// Not a Number (resultado indefinido o inválido)
double noEsNumero = Double.NaN;  // "Not a Number"

// ¿Cómo se generan estos valores?
double divisionPorCero = 1.0 / 0.0;    // POSITIVE_INFINITY (¡no es error!)
double divNegativa = -1.0 / 0.0;       // NEGATIVE_INFINITY
double overflow = 1e308 * 10;          // POSITIVE_INFINITY (overflow)
double indeterminado = 0.0 / 0.0;      // NaN (0/0 es indefinido)
double raizNegativa = Math.sqrt(-1);   // NaN (raíz de negativo)

// Comparación con Double.POSITIVE_INFINITY funciona normalmente
System.out.println(divisionPorCero == Double.POSITIVE_INFINITY);  // true

boolean activo = true;
boolean encontrado = false;

// ✅ Correcto en Java: condiciones booleanas explícitas
if (activo) {
    System.out.println("Está activo");
}

int x = 5;
// ❌ En Java esto NO compila
// if (x) { ... }           // ERROR: int no es boolean

// ✅ Correcto: comparación explícita
if (x != 0) {
    System.out.println("x es distinto de cero");
}

// ❌ No se puede asignar int a boolean
// boolean b = 1;           // ERROR: incompatible types
// boolean b = 0;           // ERROR: incompatible types

// ✅ Correcto
boolean b = true;
boolean c = (x > 0);  // Resultado de comparación es boolean

boolean a = true;
boolean b = false;

boolean and = a && b;    // false (AND lógico)
boolean or = a || b;     // true (OR lógico)
boolean not = !a;        // false (NOT lógico)

// Comparaciones producen boolean
int x = 10;
int y = 20;
boolean mayor = x > y;      // false
boolean igual = x == y;     // false
boolean diferente = x != y; // true

char letra = 'A';          // Carácter ASCII básico
char digito = '7';         // Los dígitos también son caracteres
char simbolo = '@';
char enie = 'ñ';           // ¡Directamente soportado!
char omega = 'Ω';          // Letra griega
char corazon = '♥';        // Símbolo especial

// Secuencias de escape para caracteres especiales
char nuevaLinea = '\n';    // Salto de línea
char tabulacion = '\t';    // Tabulación
char comillaSimple = '\''; // Comilla simple (escapada)
char barraInvertida = '\\';// Barra invertida (escapada)

// Caracteres Unicode por código hexadecimal
char omegaPorCodigo = '\u03A9';    // Ω (U+03A9)
char corazonPorCodigo = '\u2665';  // ♥ (U+2665)

// Imprimir texto con formato
System.out.println("Línea 1\nLínea 2\nLínea 3");
// Salida:
// Línea 1
// Línea 2
// Línea 3

System.out.println("Columna1\tColumna2\tColumna3");
// Salida:
// Columna1    Columna2    Columna3

System.out.println("Ella dijo: \"Hola\"");
// Salida:
// Ella dijo: "Hola"

System.out.println("Ruta: C:\\Users\\Juan");
// Salida:
// Ruta: C:\Users\Juan

char letra = 'A';
int codigo = letra;              // codigo = 65 (código ASCII/Unicode de 'A')
System.out.println(codigo);      // Imprime: 65

// Obtener la siguiente letra
char siguiente = (char)(letra + 1);  // siguiente = 'B' (código 66)
System.out.println(siguiente);   // Imprime: B

// Convertir minúscula a mayúscula (los códigos difieren en 32)
char minuscula = 'a';            // código 97
char mayuscula = (char)(minuscula - 32);  // código 65 = 'A'
// O más legible:
mayuscula = (char)(minuscula - 'a' + 'A');

// Iterar sobre todas las letras del alfabeto
for (char c = 'a'; c <= 'z'; c = (char)(c + 1)) {
    System.out.print(c);  // Imprime: abcdefghijklmnopqrstuvwxyz
}
System.out.println();

// Verificar si un char es un dígito
char caracter = '7';
boolean esDigito = (caracter >= '0' && caracter <= '9');  // true

// Convertir char dígito a su valor numérico
int valor = caracter - '0';  // valor = 7 (no 55 que es el código de '7')

final int MAX_INTENTOS = 3;
final double PI = 3.14159265359;
final char SEPARADOR = ',';
final String MENSAJE_ERROR = "Operación inválida";

// Convención: SCREAMING_SNAKE_CASE para constantes
final int DIAS_POR_SEMANA = 7;
final double GRAVEDAD = 9.81;
final int PUERTO_HTTP = 80;

// Una vez asignado, no se puede cambiar
// MAX_INTENTOS = 5;  // ❌ ERROR: cannot assign a value to final variable

public static void main(String[] args) {
    final double TASA_IVA = 0.21;
    final int DESCUENTO_MAXIMO = 50;
    
    double precio = 100.0;
    double precioConIva = precio * (1 + TASA_IVA);
    
    System.out.println(precioConIva);  // 121.0
}

int a = 17;
int b = 5;

int suma = a + b;       // 22
int resta = a - b;      // 12
int producto = a * b;   // 85
int cociente = a / b;   // 3 (división ENTERA, trunca el decimal)
int resto = a % b;      // 2 (17 = 5×3 + 2)

// El operador - también es unario (negación)
int negativo = -a;      // -17

// División entre enteros → resultado entero (truncado)
int resultado1 = 7 / 2;     // 3 (no 3.5, no 4)
int resultado2 = 1 / 2;     // 0 (no 0.5)
int resultado3 = -7 / 2;    // -3 (trunca hacia cero)

// Para obtener decimal, al menos UN operando debe ser double/float
double decimal1 = 7.0 / 2;      // 3.5 (7.0 es double)
double decimal2 = 7 / 2.0;      // 3.5 (2.0 es double)
double decimal3 = (double)7 / 2; // 3.5 (casting a double)
double decimal4 = 7 / (double)2; // 3.5

// ❌ ERROR COMÚN: asignar división entera a double
double mal = 7 / 2;  // mal = 3.0 (primero divide enteros → 3, luego convierte a double)

// Verificar si un número es par o impar
int numero = 17;
boolean esPar = (numero % 2 == 0);  // false (17 es impar)

// Obtener el último dígito de un número
int n = 12345;
int ultimoDigito = n % 10;  // 5

// Ciclar valores (ej: horas del reloj)
int hora = 25;
int horaReal = hora % 24;  // 1 (25 horas = 1 hora del día siguiente)

// Verificar divisibilidad
boolean divisiblePor5 = (numero % 5 == 0);  // false

int edad = 18;

boolean esMayor = edad >= 18;       // true
boolean esExacto = edad == 18;      // true
boolean esDiferente = edad != 21;   // true
boolean esMenor = edad < 18;        // false

// Pueden usarse directamente en condiciones
if (edad >= 18) {
    System.out.println("Es mayor de edad");
}

boolean a = true;
boolean b = false;

boolean and = a && b;  // false (true Y false = false)
boolean or = a || b;   // true (true O false = true)
boolean not = !a;      // false (NO true = false)

// Ejemplos prácticos
int edad = 25;
boolean tieneLicencia = true;

// Puede manejar si es mayor de 18 Y tiene licencia
boolean puedeManejar = (edad >= 18) && tieneLicencia;  // true

// Descuento si es estudiante O es jubilado
boolean esEstudiante = true;
boolean esJubilado = false;
boolean tieneDescuento = esEstudiante || esJubilado;   // true

// Entrada gratuita si NO es mayor de 12
int edadVisitante = 10;
boolean entradaGratis = !(edadVisitante > 12);  // true (10 no es > 12)
// Equivalente más claro:
entradaGratis = edadVisitante <= 12;

// && (AND): si el primero es false, el resultado ya es false
// → no evalúa el segundo
boolean resultado1 = false && metodoQueNuncaSeEjecuta();  // false, no llama al método

// || (OR): si el primero es true, el resultado ya es true
// → no evalúa el segundo
boolean resultado2 = true || metodoQueNuncaSeEjecuta();   // true, no llama al método

// Evitar división por cero
int divisor = 0;
// Si divisor es 0, la primera condición es false y NO evalúa la división
if (divisor != 0 && numero / divisor > 10) {
    // ...
}

// Evitar NullPointerException (más adelante verás referencias)
String texto = null;
// Si texto es null, no intenta llamar .length() (que fallaría)
if (texto != null && texto.length() > 5) {
    // ...
}

// Sin cortocircuito, esto fallaría si texto es null

int a = 0b1010;  // 10 en decimal
int b = 0b1100;  // 12 en decimal

int and = a & b;   // 0b1000 = 8   (bits en común)
int or = a | b;    // 0b1110 = 14  (bits de alguno)
int xor = a ^ b;   // 0b0110 = 6   (bits diferentes)
int not = ~a;      // Complemento a uno (invierte todos los bits)

// Desplazamientos
int izq = a << 2;  // 0b101000 = 40 (equivale a multiplicar por 4)
int der = a >> 1;  // 0b0101 = 5    (equivale a dividir por 2)

// Verificar si un número es par (bit menos significativo = 0)
int numero = 42;
boolean esPar = (numero & 1) == 0;  // true (42 en binario termina en 0)

// Multiplicar por 2, 4, 8... (desplazar a la izquierda)
int x = 5;
int porDos = x << 1;    // 10
int porCuatro = x << 2; // 20
int porOcho = x << 3;   // 40

// Dividir por 2, 4, 8... (desplazar a la derecha)
int y = 40;
int entreDos = y >> 1;    // 20
int entreCuatro = y >> 2; // 10

// Extraer el byte menos significativo de un int
int valor = 0x12345678;
int byteMenor = valor & 0xFF;  // 0x78 = 120

// Intercambiar dos valores sin variable temporal (truco clásico)
int p = 5, q = 3;
p = p ^ q;  // p = 6
q = p ^ q;  // q = 5
p = p ^ q;  // p = 3
// Ahora p = 3, q = 5

int negativo = -8;  // En binario: 11111111111111111111111111111000

int conSigno = negativo >> 2;   // -2 (rellena con 1s, preserva signo)
int sinSigno = negativo >>> 2;  // 1073741822 (rellena con 0s)

// Con números positivos, ambos dan el mismo resultado
int positivo = 8;
int a = positivo >> 2;   // 2
int b = positivo >>> 2;  // 2

// Multiplicación antes que suma
int a = 2 + 3 * 4;      // 2 + 12 = 14, no 20

// Paréntesis fuerzan orden
int b = (2 + 3) * 4;    // 5 * 4 = 20

// Comparación antes que lógicos
boolean c = 5 > 3 && 2 < 4;  // (5 > 3) && (2 < 4) = true && true = true

// AND antes que OR
boolean d = true || false && false;  // true || (false && false) = true || false = true
boolean e = (true || false) && false; // true && false = false

byte b = 10;
short s = b;     // ✅ OK: byte cabe en short
int i = s;       // ✅ OK: short cabe en int
long l = i;      // ✅ OK: int cabe en long
float f = l;     // ✅ OK: long cabe en float (pero puede perder precisión)
double d = f;    // ✅ OK: float cabe en double

// char también se promueve a int
char c = 'A';
int codigo = c;  // ✅ OK: codigo = 65

double d = 9.99;
int i = (int) d;       // i = 9 (trunca la parte decimal, NO redondea)

long l = 1000L;
int j = (int) l;       // ✅ OK si el valor cabe en int

float f = 3.7f;
int k = (int) f;       // k = 3 (trunca)

// Casting entre enteros
int grande = 300;
byte b = (byte) grande;  // b = 44 (overflow, 300 no cabe en byte)

// int usa 32 bits, byte usa 8 bits
// Solo se mantienen los 8 bits menos significativos

int valor = 300;           // En binario: 00000000 00000000 00000001 00101100
byte b = (byte) valor;     // Solo toma:                         00101100 = 44

int negativo = -1;         // En binario: 11111111 11111111 11111111 11111111
byte bn = (byte) negativo; // Solo toma:                         11111111 = -1

int grande = 128;          // En binario: 00000000 00000000 00000000 10000000
byte bg = (byte) grande;   // Solo toma:                         10000000 = -128 (!)

double d1 = 9.1;
double d2 = 9.9;
double d3 = -9.9;

int i1 = (int) d1;  // 9 (no 9)
int i2 = (int) d2;  // 9 (no 10 — trunca, no redondea)
int i3 = (int) d3;  // -9 (trunca hacia cero, no hacia -10)

// Si querés redondear, usá Math.round()
long redondeado = Math.round(9.5);  // 10
int redondeadoInt = (int) Math.round(9.5);  // 10

int entero = 5;
double decimal = 2.0;
double resultado = entero / decimal;  // entero se promueve a double → 2.5

// Regla importante: byte, short y char se promueven a int en CUALQUIER operación
byte x = 10;
byte y = 20;
// byte z = x + y;  // ❌ ERROR: x + y es int, no byte
int z = x + y;      // ✅ OK: el resultado es int
byte z2 = (byte)(x + y);  // ✅ OK con casting explícito

// Esto también aplica a operaciones unarias (excepto asignación)
short s = 100;
// short s2 = -s;   // ❌ ERROR: -s es int
int s2 = -s;        // ✅ OK

byte a = 100;
byte b = 100;

// Sin promoción automática (hipotético), esto daría overflow:
// byte c = a + b;  // 200 no cabe en byte → resultado incorrecto

// Con promoción automática:
int c = a + b;      // c = 200 (correcto, cabe en int)

// Si realmente querés un byte (sabiendo que puede haber overflow):
byte d = (byte)(a + b);  // d = -56 (overflow intencional)

String textoEntero = "100";
int numero = Integer.parseInt(textoEntero);     // 100
System.out.println(numero + 50);                // 150

String textoDecimal = "19.99";
double precio = Double.parseDouble(textoDecimal);  // 19.99

String textoLargo = "9876543210";
long grande = Long.parseLong(textoLargo);       // 9876543210L

String textoByte = "42";
byte pequeño = Byte.parseByte(textoByte);       // 42

// Para boolean
String textoBoolean = "true";
boolean activo = Boolean.parseBoolean(textoBoolean);  // true
// Nota: cualquier valor distinto de "true" (ignorando mayúsculas) da false

int numero = 42;
double precio = 19.99;
boolean activo = true;

// Opción 1: String.valueOf() — la más explícita
String s1 = String.valueOf(numero);   // "42"
String s2 = String.valueOf(precio);   // "19.99"
String s3 = String.valueOf(activo);   // "true"

// Opción 2: concatenación con String vacío — común pero menos clara
String s4 = "" + numero;              // "42"
String s5 = "" + precio;              // "19.99"

// Opción 3: métodos toString() de las clases wrapper
String s6 = Integer.toString(numero);      // "42"
String s7 = Double.toString(precio);       // "19.99"

// Opción 4: con formato específico
String s8 = String.format("%d", numero);   // "42"
String s9 = String.format("%.2f", precio); // "19.99" (2 decimales)