1. Palabra clave var
Cuando empezamos a escribir código en Java, nos recibe un sistema de tipos estricto: cada variable debe declararse explícitamente — indicar su tipo. Esto es útil para la fiabilidad, pero a veces las anotaciones se vuelven aparatosas y sobrecargan el código. Para hacernos la vida más fácil, en Java se añadió una herramienta conveniente — inferencia de tipos (var).
var permite escribir un código más corto y limpio sin sacrificar la seguridad de tipos: tú escribes el valor y el compilador infiere el tipo por sí mismo.
Ejemplo
var age = 23; // el compilador determinará el tipo del número 23 y pondrá int age
var name = "Anna"; // el compilador determinará el tipo de "Anna" y pondrá String name
var price = 99.99; // el compilador determinará el tipo de 99.99 y pondrá double price
¿Por qué apareció var?
- Legibilidad: no hace falta escribir a mano tipos largos (como HashMap<String, List<Integer>>).
- Flexibilidad: permite cambiar tipos más fácilmente en el futuro: si corriges la parte derecha — a la izquierda var se adaptará.
- Estilo moderno: prácticamente todos los proyectos Java modernos usan var donde el tipo se lee fácilmente a partir de la inicialización.
Cuándo se puede (y se debe) usar var
- Cuando por la derecha se ve de forma inequívoca qué tipo tiene la variable.
- Cuando el tipo es evidente (var price = 100; — está claro que es int).
- Cuando el tipo es demasiado largo o complejo (por ejemplo, HashMap<Integer, List<Calendar>>).
Ejemplo con un array
var numbers = new int[] { 1, 2, 3, 4 };
Ejemplo con un método
var input = console.nextLine(); // input — es un String (el método devuelve String)
Cuándo es mejor NO usar var
Si el tipo no es obvio por la parte derecha, el código puede volverse menos comprensible. Si dentro de un mes tú mismo no vas a entender qué tipo es, mejor indícalo explícitamente.
var mystery = DoSomethingVeryComplicated(); // ¿QUIÉN ERES, mystery???
Aquí es mejor indicar el tipo explícitamente:
String result = DoSomethingVeryComplicated();
Regla de oro: ¡usa var solo donde no empeore la legibilidad!
var — solo para variables locales
La palabra clave var funciona solo para variables locales — dentro de métodos. No se puede usar var para:
- parámetros de método;
- campos de clase;
- constantes.
Cómo funciona var «bajo el capó»
- El compilador de Java durante la compilación sustituye el tipo correcto.
- Después de compilar no queda ningún var.
- No hay pérdida de rendimiento: es una comodidad solo para el programador.
var year = 2025; // en tiempo de compilación se transforma en: int year = 2025;
Errores típicos al usar var
Variable no inicializada:
var a; // ERROR: el compilador no tiene de qué deducir el tipo
Inicialización ambigua:
var list = null; // ERROR: no se puede inferir el tipo a partir de null
Reutilización de la variable con tipos distintos:
var value = 5; // value — int
value = "Cinco"; // ERROR: ¡value ya es int!
Comparación: tipos explícitos y var
| Escenario | Tipo explícito | var |
|---|---|---|
| El tipo es inequívoco | |
|
| Un método devuelve un tipo complejo | |
|
| Array | |
|
2. Palabra clave final: declaración de constantes
Una constante es una variable cuyo valor no se puede cambiar después de la inicialización. Las constantes hacen el código fiable, comprensible y protegen de cambios accidentales de números y cadenas importantes.
- Número pi (PI = 3.14159…)
- Cantidad máxima de usuarios (MAX_USERS = 1000)
- Nombre de la empresa (COMPANY_NAME = "CodeGym")
En Java para declarar una constante se usa el modificador final. Le dice al compilador: «¡después de la primera asignación — no se puede cambiar más!»
final Tipo NOMBRE_DE_CONSTANTE = valor;
Sintaxis
final int DAYS_IN_WEEK = 7;
final double PI = 3.1415926535;
final String GREETING = "¡Hola, Java!";
Puntos importantes:
- Una variable con final debe estar inicializada (de inmediato o en el constructor — si es un campo de clase).
- Intentar cambiar el valor provocará un error de compilación.
Ejemplo: no se puede cambiar una variable final
final int MAX_USERS = 100;
MAX_USERS = 200; // Error: no se puede asignar un nuevo valor a una variable final
Comentario: si descomentas la asignación — el proyecto no compilará.
3. static final: constantes a nivel de clase
En Java a menudo se necesitan constantes que no dependan de un objeto concreto — «comunes» a toda la clase. Para ello se usa la combinación static + final.
¿Por qué static final?
- static — la variable pertenece a la clase (una para todos).
- final — el valor no se puede cambiar.
Sintaxis
public static final double PI = 3.1415926535;
public static final int MAX_USERS = 1000;
public static final String COMPANY_NAME = "CodeGym";
¿Dónde declararlas? Normalmente — al inicio de la clase (antes de los métodos).
Ejemplo de uso en una clase
public class MathUtils
{
public static final double PI = 3.1415926535;
public static double circleLength(double radius)
{
return 2 * PI * radius;
}
}
Llamada:
double len = MathUtils.circleLength(5);
System.out.println(len); // 31.4159...
Ten en cuenta: accedemos a la constante a través del nombre de la clase: MathUtils.PI.
4. Diferencia entre simplemente final y static final
final — el valor del campo no se puede cambiar tras la inicialización, pero cada objeto tiene su propio valor.
static final — una constante para toda la clase, no depende de los objetos.
Ejemplo: diferencia en la práctica
public class User
{
public final String name; // Cada User tiene su propio nombre (final)
public static final String COMPANY = "CodeGym"; // Una empresa para todos (static final)
public User(String name)
{
this.name = name;
}
}
User u1 = new User("Vasya");
User u2 = new User("Petya");
System.out.println(u1.name); // Vasya
System.out.println(u2.name); // Petya
System.out.println(User.COMPANY); // CodeGym
Conclusión: name — campo individual inmutable, COMPANY — constante común.
Convenciones de nomenclatura para constantes
Las constantes se suelen nombrar con MAYÚSCULAS_Y_GUIONES_BAJOS.
public static final int MAX_USERS = 1000;
public static final double GRAVITY = 9.81;
public static final String DEFAULT_GREETING = "Hello, world!";
Consejo: si ves un nombre así — no intentes cambiar su valor en el código: el compilador no lo permitirá.
5. Práctica: declaración y uso de constantes
Ejemplo: clase con constantes
public class CircleCalculator
{
public static final double PI = 3.1415926535;
public static double getLength(double radius)
{
return 2 * PI * radius;
}
public static double getArea(double radius)
{
return PI * radius * radius;
}
}
Uso:
public class Main
{
public static void main(String[] args)
{
double r = 5.0;
System.out.println("Longitud de la circunferencia: " + CircleCalculator.getLength(r));
System.out.println("Área del círculo: " + CircleCalculator.getArea(r));
}
}
Resultado:
Longitud de la circunferencia: 31.415926535
Área del círculo: 78.5398163375
Intento de cambiar una constante
CircleCalculator.PI = 3.14; // Error de compilación: cannot assign a value to final variable PI
6. Particularidades y matices
Constantes para objetos
Se puede declarar final para referencias a objetos, ¡pero eso no hace inmutable al objeto! Solo prohíbe asignar a la variable otra referencia.
final StringBuilder sb = new StringBuilder("Hello");
sb = new StringBuilder("World"); // Error: no se puede asignar un nuevo objeto
sb.append(", Java!"); // Permitido — cambia el estado del objeto
System.out.println(sb); // Hello, Java!
Conclusión: final protege la referencia, no el objeto. Para inmutabilidad real usa clases inmutables (por ejemplo, String, List.of(), etc.).
Uso de constantes frente a los «números mágicos»
Mala práctica:
double area = 3.1415 * r * r; // ¿Qué es 3.1415? ¿Por qué exactamente ese número?
Buena práctica:
double area = PI * r * r; // Se entiende de inmediato que se usa el número pi
7. Errores típicos al trabajar con constantes y var
Error n.º 1: intentar cambiar el valor de una variable final. Si la variable está declarada con final, una reasignación provocará un error de compilación.
Error n.º 2: intentar declarar una constante con var. Para constantes usa siempre un tipo explícito junto con final o static final. var — solo para variables locales.
Error n.º 3: nomenclatura incorrecta de constantes. Las constantes deben escribirse con MAYÚSCULAS_Y_GUIONES_BAJOS. Una declaración como final int maxUsers = 100; reduce la legibilidad.
Error n.º 4: olvidar el alcance (scope). Una constante declarada dentro de un método solo es visible en él. Para usarla en toda la clase, declárala a nivel de clase como static final.
Error n.º 5: creer que final hace inmutable al objeto. final fija la referencia, no el estado del objeto — son cosas distintas.
GO TO FULL VERSION