0x0 - Nomenclatura y Formato

NombreDeClase = PalabraInicial + Palabra2 + Palabra3 + ...
donde cada palabra comienza con Mayúscula

public class CalculadoraAvanzada {
    // ...
}

public class GestorDeUsuarios {
    // ...
}

public class GeneradorDeReportes {
    // ...
}

public class ConexionBaseDeDatos {
    // ...
}

public class calculadoraAvanzada {  // Primera letra debe ser mayúscula
    // ...
}

public class gestor_de_usuarios {  // No usar guiones bajos
    // ...
}

public class GENERADOR_DE_REPORTES {  // No todo en mayúsculas
    // ...
}

public class conexionBDD {  // Evitar acrónimos no estándar
    // ...
}

public class ConexionHttp {  // Mejor legibilidad
public class AnalizadorXml {
public class ClienteApi {

public class ConexionHTTP {  // Aceptable
public class AnalizadorXML {
public class ClienteAPI {

// Aceptable pero largo
public class SistemaDeGestionDeInventarioDeAlmacen {
    // ...
}

// Mejor: más conciso sin perder claridad
public class GestorInventarioAlmacen {
    // ...
}

Identificador válido: [a-zA-Z]+
- Solo letras mayúsculas y minúsculas del alfabeto inglés
- Sin números (ni siquiera al final)
- Sin guiones bajos (_)
- Sin caracteres acentuados (á, é, í, ó, ú)
- Sin ñ ni otros caracteres especiales

// Números en identificadores
public class Cliente2 {  // ❌ Contiene número
    private String nombre1;  // ❌ Contiene número
    private String apellido2;  // ❌ Contiene número
}

// Guiones bajos
public class Gestor_Usuarios {  // ❌ Contiene guión bajo
    private int cantidad_items;  // ❌ Contiene guión bajo
}

// Caracteres especiales del español
public class Año {  // ❌ Contiene ñ
    private String descripción;  // ❌ Contiene acento
    private boolean esEspañol;  // ❌ Contiene ñ
}

// Símbolos especiales
public class Calculadora$ {  // ❌ Contiene $
    private double precio€;  // ❌ Contiene símbolo de moneda
}

public class ClientePremium {  // ✅ Solo alfabéticos
    private String nombrePrimario;  // ✅ Sin números
    private String apellidoSecundario;  // ✅ Descriptivo sin números
}

public class GestorUsuarios {  // ✅ Sin guiones bajos
    private int cantidadItems;  // ✅ CamelCase correcto
}

public class Anio {  // ✅ Sin ñ
    private String descripcion;  // ✅ Sin acentos
    private boolean esEspaniol;  // ✅ Sin ñ (o mejor: isSpanish)
}

public class Calculadora {  // ✅ Sin símbolos especiales
    private double precioEnEuros;  // ✅ Nombre descriptivo
}

// Incorrecto
private static final int AÑO_ACTUAL = 2024;  // ❌ Contiene ñ
private static final String CONFIGURACIÓN_INICIAL = "...";  // ❌ Contiene acento

// Correcto
private static final int ANIO_ACTUAL = 2024;  // ✅
private static final String CONFIGURACION_INICIAL = "...";  // ✅
// O mejor aún:
private static final int CURRENT_YEAR = 2024;  // ✅
private static final String INITIAL_CONFIG = "...";  // ✅

// Técnicamente válido en Java, pero NO permitido en esta cátedra
public class Año2024 {  // Compila, pero ❌ para nosotros
    private int número;  // Compila, pero ❌ para nosotros
}

nombreDeVariable = palabraInicial + Palabra2 + Palabra3 + ...
donde la primera palabra va en minúscula
y cada palabra subsiguiente comienza con Mayúscula

public class CuentaBancaria {
    // Correcto ✅
    private String numeroDeCuenta;
    private double saldoActual;
    private String nombreTitular;
    private boolean estaActiva;

    // Incorrecto ❌
    private String NumeroDeCuenta;  // Primera letra debe ser minúscula
    private double Saldo_Actual;    // No usar guiones bajos
    private String nombre_titular;  // No usar snake_case
    private boolean ESTA_ACTIVA;    // No todo en mayúsculas
}

public void procesarTransaccion() {
    // Correcto ✅
    double montoTotal = 0.0;
    int numeroDeItems = 10;
    String codigoTransaccion = generarCodigo();
    boolean esValida = validar(montoTotal);

    // Incorrecto ❌
    double MontoTotal = 0.0;        // Primera letra mayúscula
    int numero_de_items = 10;       // Guiones bajos
    String COD_TRANSACCION = "";    // Todo mayúsculas
    boolean Valida = false;         // Primera letra mayúscula
}

public class Calculadora {
    // Correcto ✅
    public double calcularInteres(double capitalInicial,
                                   double tasaAnual,
                                   int periodoEnMeses) {
        // ...
    }

    public void registrarUsuario(String nombreCompleto,
                                  String correoElectronico,
                                  int edadEnAnios) {
        // ...
    }

    // Incorrecto ❌
    public double calcularInteres(double CapitalInicial,  // Mayúscula inicial
                                   double tasa_anual,      // Guión bajo
                                   int PERIODO) {          // Todo mayúsculas
        // ...
    }
}

// Aceptable en contextos apropiados
for (int i = 0; i < n; i++) {  // i, n: índices y límites
    for (int j = 0; j < m; j++) {  // j, m: índices anidados
        matriz[i][j] = 0;
    }
}

// Coordenadas
double x = punto.getX();
double y = punto.getY();
double z = punto.getZ();

// Matemática
double a = 2.0;
double b = 3.5;
double c = Math.sqrt(a * a + b * b);

// Recomendado
private String urlServidor;
private int idUsuario;
private String codigoHtml;
private Object valorJson;

// Aceptable
private String url;
private int id;
private String html;
private Object json;

// Correcto: prefijos interrogativos
private boolean esActivo;
private boolean tienePermisos;
private boolean puedeEditar;
private boolean estaListo;

// Incorrecto: sin prefijo interrogativo
private boolean activo;     // ❌
private boolean permisos;   // ❌
private boolean editable;   // ❌
private boolean listo;      // ❌

// Mal: sintaxis correcta pero no descriptivo
private int num;      // ❌ Muy genérico
private String str;   // ❌ No dice qué contiene
private double val;   // ❌ Ambiguo

// Bien: sintaxis y semántica correctas
private int numeroDeClientes;    // ✅ Claro y específico
private String nombreCompleto;   // ✅ Describe el contenido
private double saldoDisponible;  // ✅ Contexto claro

nombreDeMetodo = verbo + Complemento + Complemento2 + ...
donde el verbo inicial va en minúscula
y cada complemento comienza con Mayúscula

public class Calculadora {
    // Correcto ✅
    public double calcularPromedio(double[] valores) { ... }
    public String obtenerNombre() { ... }
    public void validarDatos() { ... }
    public boolean esValido() { ... }
    public void establecerValor(int valor) { ... }

    // Incorrecto ❌
    public double CalcularPromedio() { ... }     // Mayúscula inicial
    public String ObtenerNombre() { ... }        // Mayúscula inicial
    public void Validar_Datos() { ... }          // Mayúscula + guión bajo
    public boolean EsValido() { ... }            // Mayúscula inicial
    public void ESTABLECER_VALOR(int valor) { ... }  // Todo mayúsculas
}

public class Persona {
    private String nombre;
    private int edad;

    // Correcto ✅
    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }
}

public class Usuario {
    // Correcto ✅ - usar prefijos interrogativos
    public boolean esAdministrador() { ... }
    public boolean tienePermisos() { ... }
    public boolean puedeEditar() { ... }
    public boolean estaActivo() { ... }

    // Incorrecto ❌ - sin prefijos interrogativos
    public boolean administrador() { ... }
    public boolean permisos() { ... }
    public boolean editable() { ... }
    public boolean activo() { ... }
}

// Correcto ✅
public String convertirATexto() { ... }
public int obtenerComoEntero() { ... }
public List<String> transformarALista() { ... }

// Incorrecto ❌
public String ConvertirTexto() { ... }      // Mayúscula inicial
public int obtener_como_entero() { ... }    // Guiones bajos
public List<String> TransformarLista() { ... }  // Mayúscula inicial

public class CuentaBancaria {
    // Constructor: mismo nombre que la clase
    public CuentaBancaria(String numero, double saldoInicial) {
        // ...
    }
}

public class Utilidades {
    // Correcto ✅
    public static String formatearFecha(Date fecha) { ... }
    public static int calcularMaximo(int a, int b) { ... }
    public static boolean validarEmail(String email) { ... }

    // Incorrecto ❌
    public static String FormatearFecha(Date fecha) { ... }
    public static int Calcular_Maximo(int a, int b) { ... }
}

public interface EventListener {
    void alRecibirEvento(Event evento);  // ✅ dromedarioCase
    void alCompletarTarea();             // ✅ dromedarioCase
}

// Implementación
button.onClick(evento -> {
    procesarClick(evento);  // ✅ dromedarioCase
});

// Demasiado largo - considera refactorizar
public void validarYProcesarYGuardarTransaccionEnBaseDeDatos() { ... }  // ❌

// Mejor: divide en métodos más específicos
public void procesarTransaccion(Transaccion t) {  // ✅
    validarTransaccion(t);
    guardarEnBaseDeDatos(t);
}

private void validarTransaccion(Transaccion t) { ... }
private void guardarEnBaseDeDatos(Transaccion t) { ... }

NOMBRE_CONSTANTE = PALABRA1 + _ + PALABRA2 + _ + ...
donde todas las letras van en MAYÚSCULAS
y las palabras se separan con guión bajo (_)

public class ConfiguracionSistema {
    // Correcto ✅
    public static final int MAX_INTENTOS = 3;
    public static final double PI = 3.14159265359;
    public static final String MENSAJE_ERROR = "Error al procesar";
    public static final int TIEMPO_ESPERA_MS = 5000;

    // Incorrecto ❌
    public static final int maxIntentos = 3;        // Debe ser mayúsculas
    public static final double pi = 3.14159;        // Debe ser mayúsculas
    public static final String MensajeError = "";   // Debe usar guiones bajos
    public static final int TIEMPOESPERARMS = 5000; // Falta separador
}

public class ConstantesMatematicas {
    // Correcto ✅
    public static final double PI = 3.14159265359;
    public static final double E = 2.71828182846;
    public static final double PHI = 1.61803398875;

    // Incorrecto ❌
    public static final double pi = 3.14159;    // Minúsculas
    public static final double e = 2.71828;     // Minúsculas
}

public class LimitesAplicacion {
    // Correcto ✅
    public static final int MAX_USUARIOS = 1000;
    public static final int MIN_EDAD = 18;
    public static final int TIMEOUT_SEGUNDOS = 30;

    // Incorrecto ❌
    public static final int maxUsuarios = 1000;      // dromedarioCase
    public static final int MinEdad = 18;            // CamelloCase
    public static final int TIMEOUTSEGUNDOS = 30;    // Sin separador
}

public class MensajesAplicacion {
    // Correcto ✅
    public static final String MENSAJE_BIENVENIDA = "Bienvenido al sistema";
    public static final String ERROR_CONEXION = "No se pudo conectar";
    public static final String FORMATO_FECHA = "dd/MM/yyyy";

    // Incorrecto ❌
    public static final String mensajeBienvenida = "...";  // dromedarioCase
    public static final String ErrorConexion = "...";      // CamelloCase
    public static final String FORMATOFECHA = "...";       // Sin separador
}

public class Configuracion {
    // Correcto ✅
    public static final String BASE_URL = "https://api.ejemplo.com";
    public static final int PUERTO_SERVIDOR = 8080;
    public static final String NOMBRE_BASE_DATOS = "aplicacion_db";
    public static final boolean MODO_DEBUG = true;

    // Incorrecto ❌
    public static final String baseUrl = "...";           // dromedarioCase
    public static final int PuertoServidor = 8080;        // CamelloCase
    public static final String nombre_base_datos = "..."; // No mayúsculas
}

// Correcto ✅
public enum EstadoPedido {
    PENDIENTE,
    EN_PROCESO,
    COMPLETADO,
    CANCELADO
}

public enum DiaSemana {
    LUNES,
    MARTES,
    MIERCOLES,
    JUEVES,
    VIERNES,
    SABADO,
    DOMINGO
}

// Incorrecto ❌
public enum EstadoPedido {
    Pendiente,      // CamelloCase
    enProceso,      // dromedarioCase
    completado,     // minúsculas
    CANCELADO       // ✅ Este sí está bien
}

public class Ejemplo {
    // Constante: static final, valor fijo
    public static final int MAX_VALOR = 100;  // ✅ SNAKE_CASE

    // No es constante: solo final, puede variar entre instancias
    private final String nombreUsuario;  // ✅ dromedarioCase

    public Ejemplo(String nombre) {
        this.nombreUsuario = nombre;  // Valor depende de la instancia
    }
}

public class Validador {
    // Constantes privadas
    private static final int LONGITUD_MINIMA = 8;
    private static final String PATRON_EMAIL = "^[a-z0-9]+@[a-z]+\\.[a-z]{2,}$";

    // Constantes públicas
    public static final int ERROR_VALIDACION = -1;
    public static final String VERSION = "1.0.0";
}

// Correcto ✅
public static final String URL_API = "https://api.ejemplo.com";
public static final int ID_ADMINISTRADOR = 1;
public static final String FORMATO_JSON = "application/json";
public static final int PUERTO_HTTP = 80;
public static final int PUERTO_HTTPS = 443;

// Incorrecto ❌
public static final String URLApi = "...";      // No es SNAKE_CASE
public static final int IdAdministrador = 1;    // No es SNAKE_CASE

public class ConfiguracionHttp {
    // Timeouts
    public static final int TIMEOUT_CONEXION_MS = 5000;
    public static final int TIMEOUT_LECTURA_MS = 10000;
    public static final int TIMEOUT_ESCRITURA_MS = 10000;

    // Códigos de respuesta
    public static final int CODIGO_OK = 200;
    public static final int CODIGO_ERROR = 500;
    public static final int CODIGO_NO_ENCONTRADO = 404;
}

// Incorrecto ❌ - números mágicos
if (edad >= 18) {
    // ...
}
double area = radio * radio * 3.14159;

// Correcto ✅ - constantes nombradas
public static final int EDAD_MINIMA_LEGAL = 18;
public static final double PI = 3.14159;

if (edad >= EDAD_MINIMA_LEGAL) {
    // ...
}
double area = radio * radio * PI;

// Incorrecto ❌ - No descriptivo
int n;          // ¿Qué es n?
String s;       // ¿Qué contiene?
double val;     // ¿Valor de qué?
int cnt;        // ¿Contador de qué?
String tmp;     // ¿Temporal para qué?
List<String> d; // ¿Datos de qué tipo?

// Correcto ✅ - Descriptivo
int numeroDeEstudiantes;
String nombreCompleto;
double saldoCuentaBancaria;
int contadorIntentosFallidos;
String descripcionTemporalProducto;
List<String> nombresAprobados;

// Incorrecto ❌ - No descriptivo
public void proc() { ... }           // ¿Qué procesa?
public int get() { ... }             // ¿Obtiene qué?
public void upd(String s) { ... }    // ¿Actualiza qué?
public boolean chk() { ... }         // ¿Verifica qué?

// Correcto ✅ - Descriptivo
public void procesarPagoTarjeta() { ... }
public int obtenerEdadUsuario() { ... }
public void actualizarSaldoCuenta(String numeroCuenta) { ... }
public boolean verificarCredenciales() { ... }

// Incorrecto ❌ - No descriptivo
public class Mgr { ... }        // ¿Manager de qué?
public class Data { ... }       // ¿Qué datos?
public class Utils { ... }      // ¿Utilidades de qué?
public class Info { ... }       // ¿Información de qué?

// Correcto ✅ - Descriptivo
public class GestorUsuarios { ... }
public class DatosTransaccion { ... }
public class UtilidadesFechas { ... }
public class InformacionSistema { ... }

// Aceptable ✅ - Contexto de bucle simple
for (int i = 0; i < tamano; i++) {
    procesar(elementos[i]);
}

// Aceptable ✅ - Bucles anidados
for (int i = 0; i < filas; i++) {
    for (int j = 0; j < columnas; j++) {
        matriz[i][j] = calcular(i, j);
    }
}

// Límites numéricos comunes
int n = lista.size();
int m = matriz.length;

// Aceptable ✅ - Coordenadas cartesianas
double x = punto.getX();
double y = punto.getY();
double z = punto.getZ();

// Cálculos matemáticos
double distancia = Math.sqrt(x * x + y * y);

// Aceptable ✅ - Fórmulas conocidas
double a = coeficiente1;
double b = coeficiente2;
double c = terminoIndependiente;
double discriminante = b * b - 4 * a * c;

// Aceptables en contexto apropiado
int max = encontrarMaximo();      // vs maximoValor
int min = encontrarMinimo();      // vs minimoValor
String id = generarIdentificador(); // vs identificador
String url = construirUrl();      // vs localizadorRecursoUniforme

// Pero mejor aún: combinar con contexto
int maxIntentos = 3;
int minEdad = 18;
String idUsuario = "USR001";
String urlServidor = "https://...";

// Incorrecto ❌ - bucle complejo con variables de una letra
for (int i = 0; i < estudiantes.size(); i++) {
    for (int j = 0; j < materias.size(); j++) {
        for (int k = 0; k < examenes.size(); k++) {
            // ¿Qué representa cada índice? Difícil de seguir
            procesar(datos[i][j][k]);
        }
    }
}

// Correcto ✅ - bucle complejo con nombres descriptivos
for (int indiceEstudiante = 0; indiceEstudiante < estudiantes.size(); indiceEstudiante++) {
    for (int indiceMateria = 0; indiceMateria < materias.size(); indiceMateria++) {
        for (int indiceExamen = 0; indiceExamen < examenes.size(); indiceExamen++) {
            // Ahora es claro qué procesa cada nivel
            procesar(datos[indiceEstudiante][indiceMateria][indiceExamen]);
        }
    }
}

// Mejor aún ✅ - usar for-each cuando sea posible
for (Estudiante estudiante : estudiantes) {
    for (Materia materia : estudiante.getMaterias()) {
        for (Examen examen : materia.getExamenes()) {
            procesar(estudiante, materia, examen);
        }
    }
}

// Difícil de pronunciar ❌
String usrNmFst;      // "user name first"?
int stdCnt;           // "standard count"?
double tmpVal;        // "temporary value"?

// Fácil de pronunciar ✅
String nombrePrimerUsuario;
int cantidadEstudiantes;
double valorTemporal;

// Difícil de buscar ❌
String data;    // Buscar "data" devuelve demasiados resultados
int temp;       // "temp" aparece en muchos contextos
int count;      // "count" es muy genérico

// Fácil de buscar ✅
String datosTransaccion;
int temperaturaMaxima;
int contadorTransaccionesExitosas;

// ❌ Código difícil de entender
public void proc(String s, int n) {
    String tmp = s.substring(0, n);
    int val = tmp.length();
    if (val > 0) {
        List<String> l = new ArrayList<>();
        for (int i = 0; i < val; i++) {
            l.add(tmp.charAt(i) + "");
        }
    }
}

// ✅ Código claro y autoexplicativo
public void procesarSubcadena(String textoOriginal, int longitudMaxima) {
    String subcadena = textoOriginal.substring(0, longitudMaxima);
    int cantidadCaracteres = subcadena.length();

    if (cantidadCaracteres > 0) {
        List<String> caracteresIndividuales = new ArrayList<>();
        for (int indice = 0; indice < cantidadCaracteres; indice++) {
            caracteresIndividuales.add(subcadena.charAt(indice) + "");
        }
    }
}

public interface Comparable<T> {
    int compararCon(T otro);  // Depende del estado de this
}

public interface Serializable {
    byte[] serializar();  // Serializa el estado actual
}

public interface Validable {
    boolean esValido();  // Valida el estado actual
}

public interface Cloneable {
    Object clonar();  // Clona el estado actual
}

public interface Dibujable {
    void dibujar(Graphics g);  // Dibuja el objeto usando su estado
}

public interface Ejecutable {
    void ejecutar();  // Ejecuta acción basada en configuración del objeto
}

// Comportamiento que depende del estado del objeto
public class Persona implements Comparable<Persona> {
    private String nombre;
    private int edad;

    @Override
    public int compararCon(Persona otra) {
        return this.edad - otra.edad;  // ✅ Usa this.edad (estado)
    }
}

public class Documento implements Serializable {
    private String titulo;
    private String contenido;

    @Override
    public byte[] serializar() {
        // ✅ Serializa this.titulo y this.contenido
        return (titulo + "|" + contenido).getBytes();
    }
}

public interface Comparador<T> {
    int compare(T o1, T o2);  // No usa this, compara dos objetos externos
}

public interface Validador<T> {
    boolean validate(T objeto);  // Validación externa sin estado
}

public interface Calculador {
    double calculate(double x, double y);  // Operación sin estado
}

public interface Conversor<F, T> {
    T convert(F from);  // Transformación sin estado propio
}

public interface Procesador<T> {
    T process(T input);  // Procesamiento funcional
}

public interface Filtrador<T> {
    boolean filter(T elemento);  // Filtrado sin estado
}

public interface Mapeador<T, R> {
    R map(T entrada);  // Mapeo funcional
}

// Comportamiento funcional sin depender de this
public class OrdenamientoPersonas {
    private static class ComparadorPorNombre implements Comparador<Persona> {
        @Override
        public int compare(Persona p1, Persona p2) {
            // ✅ No usa this, opera sobre parámetros externos
            return p1.getNombre().compareTo(p2.getNombre());
        }
    }

    private static class ComparadorPorEdad implements Comparador<Persona> {
        @Override
        public int compare(Persona p1, Persona p2) {
            // ✅ Comparación stateless
            return p1.getEdad() - p2.getEdad();
        }
    }
}

public interface Comparable<T> {
    int compararCon(T otro);
}

public class Producto implements Comparable<Producto> {
    private double precio;

    @Override
    public int compararCon(Producto otro) {
        // ✅ Compara THIS.precio con otro.precio
        return Double.compare(this.precio, otro.precio);
    }
}

// Uso: el objeto se compara a sí mismo con otro
Producto p1 = new Producto(100.0);
Producto p2 = new Producto(200.0);
int resultado = p1.compararCon(p2);  // p1 usa su propio estado

public interface Comparador<T> {
    int compare(T o1, T o2);
}

public class ComparadorProductoPorPrecio implements Comparador<Producto> {
    @Override
    public int compare(Producto p1, Producto p2) {
        // ✅ No usa this, opera sobre dos parámetros externos
        return Double.compare(p1.getPrecio(), p2.getPrecio());
    }
}

// Uso: un objeto externo compara dos productos
Comparador<Producto> comparador = new ComparadorProductoPorPrecio();
Producto p1 = new Producto(100.0);
Producto p2 = new Producto(200.0);
int resultado = comparador.compare(p1, p2);  // Comparación externa

// Excepciones históricas en Java estándar
Runnable      // Podría ser Ejecutable
Callable      // Similar a Ejecutable
Iterable      // ✅ Correcto: el objeto ES iterable
Iterator      // Operador de iteración (exception al patrón)

// Interfaces funcionales estándar
Function<T, R>     // Transformador
Predicate<T>       // Evaluador/Filtrador
Consumer<T>        // Consumidor
Supplier<T>        // Proveedor
BiFunction<T, U, R> // Transformador binario

@FunctionalInterface
public interface Transformador<T, R> {
    R transformar(T entrada);
}

@FunctionalInterface
public interface Evaluador<T> {
    boolean evaluar(T objeto);
}

// Correcto ✅ - Representan tipos/contratos, no comportamientos
public interface Lista<T> {
    void agregar(T elemento);
    T obtener(int indice);
}

public interface Figura {
    double calcularArea();
    double calcularPerimetro();
}

public interface Repositorio<T> {
    void guardar(T entidad);
    T buscarPorId(int id);
}

// Enfoque -able: Los objetos se comparan a sí mismos
public class Estudiante implements Comparable<Estudiante> {
    private String nombre;
    private double promedio;

    @Override
    public int compararCon(Estudiante otro) {
        return Double.compare(this.promedio, otro.promedio);
    }
}

// Enfoque -or: Comparador externo con diferentes estrategias
public class ComparadorEstudiantes {
    public static class PorNombre implements Comparador<Estudiante> {
        @Override
        public int compare(Estudiante e1, Estudiante e2) {
            return e1.getNombre().compareTo(e2.getNombre());
        }
    }

    public static class PorPromedio implements Comparador<Estudiante> {
        @Override
        public int compare(Estudiante e1, Estudiante e2) {
            return Double.compare(e1.getPromedio(), e2.getPromedio());
        }
    }
}

// Enfoque -able: El objeto se valida a sí mismo
public class FormularioRegistro implements Validable {
    private String email;
    private String contrasena;

    @Override
    public boolean esValido() {
        return this.email.contains("@") &&
               this.contrasena.length() >= 8;
    }
}

// Enfoque -or: Validador externo reutilizable
public class ValidadorEmail implements Validador<String> {
    @Override
    public boolean validate(String email) {
        return email != null &&
               email.contains("@") &&
               email.contains(".");
    }
}

public class ValidadorContrasena implements Validador<String> {
    private final int longitudMinima;

    public ValidadorContrasena(int longitudMinima) {
        this.longitudMinima = longitudMinima;
    }

    @Override
    public boolean validate(String contrasena) {
        return contrasena != null &&
               contrasena.length() >= longitudMinima;
    }
}

// ❌ Mal: Sufijo -able pero no usa this
public interface Calculadorable {  // Debería ser Calculador
    double calculate(double x, double y);  // No usa estado
}

// ❌ Mal: Sufijo -or pero depende de this
public interface Comparator<T> {
    int compare(T otro);  // Solo un parámetro, usa this implícitamente
    // Debería ser Comparable con compararCon(T otro)
}

// ✅ Correcto: Coincide semántica y sintaxis
public interface Calculador {
    double calculate(double x, double y);
}

public interface Comparable<T> {
    int compararCon(T otro);
}

public class Usuario {
    // Correcto ✅
    private boolean esAdministrador;
    private boolean tienePermisos;
    private boolean puedeEditar;
    private boolean estaActivo;
    private boolean fueValidado;

    // Incorrecto ❌
    private boolean administrador;    // No es interrogativo
    private boolean permisos;         // No es interrogativo
    private boolean editable;         // Ambiguo (¿adjetivo o verbo?)
    private boolean activo;           // No es interrogativo
    private boolean validado;         // Participio, no pregunta
}

public class Documento {
    // Correcto ✅
    public boolean esVacio() {
        return contenido.isEmpty();
    }

    public boolean tienePermisoLectura() {
        return permisos.contains(Permiso.LECTURA);
    }

    public boolean puedeGuardarse() {
        return !esVacio() && tieneNombreValido();
    }

    public boolean estaModificado() {
        return estadoModificacion;
    }

    // Incorrecto ❌
    public boolean vacio() {           // Sin prefijo
        return contenido.isEmpty();
    }

    public boolean permisoLectura() {  // Sin prefijo
        return permisos.contains(Permiso.LECTURA);
    }

    public boolean guardable() {       // Sufijo -able sin prefijo
        return !esVacio();
    }
}

public void procesarPedido(Pedido pedido) {
    // Correcto ✅
    boolean esValido = validar(pedido);
    boolean tieneStock = verificarStock(pedido);
    boolean puedeEnviarse = esValido && tieneStock;

    if (puedeEnviarse) {
        enviar(pedido);
    }

    // Incorrecto ❌
    boolean valido = validar(pedido);
    boolean stock = verificarStock(pedido);
    boolean enviable = valido && stock;

    if (enviable) {
        enviar(pedido);
    }
}

// Con prefijos ✅ - Se lee como pregunta natural
if (usuario.esAdministrador()) {
    // "¿El usuario es administrador? Sí → ejecutar"
}

if (archivo.puedeLeerse() && archivo.tieneContenido()) {
    // "¿El archivo puede leerse Y tiene contenido? Sí → procesar"
}

if (!conexion.estaActiva()) {
    // "¿La conexión NO está activa? Sí → reconectar"
}

// Sin prefijos ❌ - Se lee forzado o ambiguo
if (usuario.administrador()) {  // ¿Qué devuelve? ¿Un objeto? ¿Un boolean?
    // ...
}

if (archivo.legible() && archivo.contenido()) {  // Poco natural
    // ...
}

// Problemático ⚠️ - Doble negación confusa
private boolean noEstaInactivo;

if (!noEstaInactivo) {  // ❌ Difícil de leer mentalmente
    // ...
}

// Mejor ✅ - Afirmativo
private boolean estaActivo;

if (estaActivo) {  // ✅ Claro y directo
    // ...
}

// Si necesitás el negativo
if (!estaActivo) {  // ✅ Una sola negación
    // ...
}

public class Configuracion {
    private boolean modoDebug;
    private boolean autoguardado;

    // Correcto ✅ - Usar is para booleanos
    public boolean isModoDebug() {
        return modoDebug;
    }

    public boolean isAutoguardado() {
        return autoguardado;
    }

    // También aceptable ✅ - Seguir la convención de español
    public boolean esModoDebug() {
        return modoDebug;
    }

    public boolean estaAutoguardadoActivo() {
        return autoguardado;
    }

    // Incorrecto ❌
    public boolean getModoDebug() {  // Usar is, no get
        return modoDebug;
    }

    public boolean autoguardado() {  // Falta prefijo
        return autoguardado;
    }
}

// Correcto ✅
public static final boolean ES_MODO_PRODUCCION = true;
public static final boolean PUEDE_USAR_CACHE = true;
public static final boolean TIENE_LICENCIA_VALIDA = false;

// Menos claro
public static final boolean MODO_PRODUCCION = true;  // ⚠️ Ambiguo
public static final boolean CACHE = true;            // ⚠️ ¿Cache qué?
public static final boolean LICENCIA = false;        // ⚠️ No es claro

boolean esVacio = lista.isEmpty();
boolean esValido = formulario.esValido();
boolean esPar = numero % 2 == 0;
boolean esNulo = objeto == null;
boolean esPositivo = valor > 0;

boolean tieneElementos = !lista.isEmpty();
boolean tienePermisos = usuario.tieneRol(ROL_ADMIN);
boolean tieneHijos = nodo.tieneHijos();
boolean tieneErrores = validacion.tieneErrores();

boolean puedeEditar = archivo.tienePermiso(ESCRITURA);
boolean puedeEjecutar = proceso.tieneRecursos();
boolean puedeConectarse = red.estaDisponible();
boolean puedeRetirarse = saldo >= monto;

boolean estaListo = tarea.getProgreso() == 100;
boolean estaProcesando = hilo.isAlive();
boolean estaConectado = socket.isConnected();
boolean estaBloqueado = cuenta.getIntentosFallidos() > 3;

boolean necesitaActualizacion = version < VERSION_ACTUAL;
boolean necesitaValidacion = !fueValidado;
boolean necesitaRecarga = cache.isStale();

public class SistemaAutenticacion {
    public boolean autenticar(String usuario, String contrasena) {
        Usuario usr = buscarUsuario(usuario);

        // ✅ Legibilidad natural
        boolean esUsuarioValido = usr != null;
        boolean esContrasenaCorrecta = verificarContrasena(usr, contrasena);
        boolean estaCuentaActiva = usr != null && usr.estaActiva();
        boolean tienePermisosNecesarios = verificarPermisos(usr);

        return esUsuarioValido &&
               esContrasenaCorrecta &&
               estaCuentaActiva &&
               tienePermisosNecesarios;
    }
}

public class FormularioRegistro {
    private String email;
    private String contrasena;
    private String confirmacionContrasena;

    public boolean esValido() {
        // ✅ Cada condición es una pregunta clara
        boolean esEmailValido = email != null && email.contains("@");
        boolean esContrasenaSegura = contrasena != null && contrasena.length() >= 8;
        boolean esConfirmacionCorrecta = contrasena.equals(confirmacionContrasena);

        return esEmailValido && esContrasenaSegura && esConfirmacionCorrecta;
    }
}

public class GestorPermisos {
    public boolean puedeRealizarAccion(Usuario usuario, Accion accion) {
        // ✅ Flujo lógico claro mediante preguntas
        boolean esAdministrador = usuario.tieneRol(ROL_ADMIN);
        boolean tieneLicenciaActiva = usuario.getLicencia().estaVigente();
        boolean tienePermisoEspecifico = usuario.tienePermiso(accion);
        boolean estaEnHorarioPermitido = verificarHorario();

        return esAdministrador ||
               (tieneLicenciaActiva && tienePermisoEspecifico && estaEnHorarioPermitido);
    }
}

// ❌ Incorrecto - Participio sin prefijo
boolean validado;
boolean procesado;
boolean encontrado;
boolean habilitado;

// ✅ Correcto - Con prefijo interrogativo
boolean fueValidado;
boolean estaProcesado;
boolean fueEncontrado;
boolean estaHabilitado;

// ❌ Incorrecto - Adjetivo sin prefijo
boolean activo;
boolean disponible;
boolean completo;
boolean valido;

// ✅ Correcto - Con prefijo interrogativo
boolean estaActivo;
boolean estaDisponible;
boolean estaCompleto;
boolean esValido;

// ❌ Incorrecto - Verbo en infinitivo
boolean validar;   // ¿Es una acción o un estado?
boolean procesar;  // Confuso
boolean ejecutar;  // Ambiguo

// ✅ Correcto - Pregunta sobre capacidad
boolean puedeValidarse;
boolean estaProcesando;
boolean puedeEjecutarse;

public boolean puedeAprobarCredito(Cliente cliente, double monto) {
    boolean esClienteActivo = cliente.estaActivo();
    boolean tieneBuenHistorial = cliente.getScore() > 700;
    boolean esMontoRazonable = monto <= cliente.getLimiteCredito();
    boolean noTieneDeudasVencidas = !cliente.tieneDeudasVencidas();
    boolean cumpleEdadMinima = cliente.getEdad() >= EDAD_MINIMA_CREDITO;

    // ✅ La expresión final es muy legible
    return esClienteActivo &&
           tieneBuenHistorial &&
           esMontoRazonable &&
           noTieneDeudasVencidas &&
           cumpleEdadMinima;
}

// ❌ Sin prefijos - Difícil de leer
if (usuario.activo() && documento.disponible() && sistema.funcionando()) {
    // ¿Qué retornan estos métodos? ¿Booleanos? ¿Objetos?
}

// ✅ Con prefijos - Claro y directo
if (usuario.estaActivo() && documento.estaDisponible() && sistema.estaFuncionando()) {
    // Obviamente retornan booleanos y se leen como preguntas
}

strNombre   → string nombre
intEdad     → integer edad
arrValores  → array valores
lstEstudiantes → list estudiantes

// Incorrecto ❌ - Incluye el tipo en el nombre
String stringNombre = "Juan";
int intContador = 0;
double doubleTotal = 0.0;
boolean boolValido = true;
List<String> listaNombres = new ArrayList<>();
Map<String, Integer> mapEdades = new HashMap<>();
String[] arrayApellidos = new String[10];

// Correcto ✅ - Nombre describe el propósito, no el tipo
String nombre = "Juan";
int contador = 0;
double total = 0.0;
boolean esValido = true;
List<String> nombres = new ArrayList<>();
Map<String, Integer> edades = new HashMap<>();
String[] apellidos = new String[10];

public class Procesador {
    // Incorrecto ❌ - Tipo en el nombre
    public int calcularIntSuma(int[] numeros) { ... }
    public String obtenerStringNombre() { ... }
    public List<Integer> buscarListaIds() { ... }
    public boolean verificarBoolEstado() { ... }

    // Correcto ✅ - Nombre describe la acción/propósito
    public int calcularSuma(int[] numeros) { ... }
    public String obtenerNombre() { ... }
    public List<Integer> buscarIds() { ... }
    public boolean verificarEstado() { ... }
}

// Incorrecto ❌
public void procesar(String strTexto, int intLongitud, List<String> listaPalabras) {
    // ...
}

// Correcto ✅
public void procesar(String texto, int longitud, List<String> palabras) {
    // El tipo ya está declarado
}

// Aceptable ✅ - El tipo ES el propósito en este contexto
public class Configuracion {
    private Properties propiedades;  // Es un objeto Properties
    private Map<String, String> mapa;  // El contexto requiere saber que es un mapa
}

// Pero mejor aún ✅ - Agregar contexto de uso
public class Configuracion {
    private Properties propiedadesSistema;
    private Map<String, String> mapaConfiguraciones;
}

// ❌ Incorrecto - Tipo en el nombre
List<String> listaNombres;
ArrayList<Integer> arrayListIds;
Set<Persona> setPersonas;
Map<String, Usuario> mapUsuarios;

// ⚠️ Aceptable - Pero puede mejorar
List<String> nombres;
ArrayList<Integer> ids;
Set<Persona> personas;
Map<String, Usuario> usuarios;

// ✅ Mejor - Plural con contexto
List<String> nombresEstudiantes;
List<Integer> idsActivos;
Set<Persona> personasAutorizadas;
Map<String, Usuario> usuariosPorEmail;

// ❌ Incorrecto
String tempString = calcular();
int tmpInt = 0;
List<Object> listTemp = new ArrayList<>();

// ✅ Correcto
String resultadoTemporal = calcular();
int contadorTemporal = 0;
List<Object> elementosAuxiliares = new ArrayList<>();

// ✅ Mejor aún - sin "temporal" si el contexto es obvio
String resultado = calcular();
int contador = 0;
List<Object> elementos = new ArrayList<>();

// ❌ Redundancia obvia
String strNombre = "Juan";  // Ya veo que es String
int intEdad = 25;           // Ya veo que es int
boolean boolActivo = true;  // Ya veo que es boolean

// Si cambio el tipo, ¿también cambio el nombre?
List<String> listNombres = new ArrayList<>();

// Después quiero usar un Set
Set<String> listNombres = new HashSet<>();  // ❌ El nombre miente!

// Mejor sin el tipo en el nombre
List<String> nombres = new ArrayList<>();
// Cambio fácil sin inconsistencia
Set<String> nombres = new HashSet<>();  // ✅ El nombre sigue siendo correcto

// ❌ Difícil de leer - enfoque en tipos
if (intEdad >= intEdadMinima && strNombre != null) {
    listEstudiantes.add(new Estudiante(strNombre, intEdad));
}

// ✅ Fácil de leer - enfoque en propósito
if (edad >= edadMinima && nombre != null) {
    estudiantes.add(new Estudiante(nombre, edad));
}

// Excepciones históricas de Java (NO imitar)
StringBuilder sb = new StringBuilder();  // Tipo en el nombre de clase
StringBuffer buffer = new StringBuffer();

// En tu código, evitá esto
// ❌ No hagas:
String strBuilder = "...";
int intBuffer = 0;

// ✅ Hacé:
String construccionMensaje = "...";
int tamanioBuffer = 0;

// Incorrecto ❌
int resultado = a+b*c-d/e;
double promedio = suma/cantidad;
int incremento = x+1;
int decremento = y-1;

// Correcto ✅
int resultado = a + b * c - d / e;
double promedio = suma / cantidad;
int incremento = x + 1;
int decremento = y - 1;

// Incorrecto ❌
if (x>0 && y<10) { }
if (nombre==null || edad>=18) { }
if (valor!=0) { }

// Correcto ✅
if (x > 0 && y < 10) { }
if (nombre == null || edad >= 18) { }
if (valor != 0) { }

// Incorrecto ❌
boolean resultado = a&&b||c;
boolean negacion = !a&&b;
if (esValido&&!estaVacio) { }

// Correcto ✅
boolean resultado = a && b || c;
boolean negacion = !a && b;  // ! es unario, no lleva espacio antes
if (esValido && !estaVacio) { }

// Incorrecto ❌
int x=10;
double y=x*2;
contador+=5;
suma*=factor;

// Correcto ✅
int x = 10;
double y = x * 2;
contador += 5;
suma *= factor;

// Incorrecto ❌
String resultado = x>0?"positivo":"negativo";
int valor = a==b?1:0;

// Correcto ✅
String resultado = x > 0 ? "positivo" : "negativo";
int valor = a == b ? 1 : 0;

// Para expresiones complejas, considerar multilínea
String resultado = condicionLarga && otraCondicion
    ? "valor verdadero"
    : "valor falso";

// Correcto ✅ - Operadores unarios pegados al operando
int negativo = -x;       // Sin espacio después de -
boolean negacion = !estaActivo;  // Sin espacio después de !
contador++;              // Sin espacios
--indice;                // Sin espacios

// Incorrecto ❌
int negativo = - x;      // Espacio innecesario
boolean negacion = ! estaActivo;  // Espacio innecesario
contador ++;             // Espacio innecesario
-- indice;               // Espacio innecesario

// Sin espacios ❌ - Difícil de leer
double resultado = a*b+c*d-e/f;

// Con espacios ✅ - Clara precedencia
double resultado = a * b + c * d - e / f;

// Para expresiones muy complejas, considerar paréntesis y variables intermedias
double terminoA = a * b;
double terminoB = c * d;
double terminoC = e / f;
double resultado = terminoA + terminoB - terminoC;

// Incorrecto ❌
String mensaje = "Hola "+nombre+" bienvenido";
String ruta = directorio+"/"+archivo;

// Correcto ✅
String mensaje = "Hola " + nombre + " bienvenido";
String ruta = directorio + "/" + archivo;

// Mejor aún ✅ - Para concatenaciones complejas
String mensaje = String.format("Hola %s bienvenido", nombre);
String ruta = String.join("/", directorio, archivo);

// Correcto ✅ - Sin espacios en acceso
objeto.metodo()
array[indice]
lista.get(i)

// Incorrecto ❌
objeto . metodo()  // Sin espacios alrededor de .
array [indice]     // Sin espacio antes de [
lista . get(i)     // Sin espacios alrededor de .

// Antes del autoformato ❌
public class Ejemplo{
    private int x=0;
    public int calcular(int a,int b){
        return a+b*x-5;
    }
}

// Después del autoformato ✅
public class Ejemplo {
    private int x = 0;

    public int calcular(int a, int b) {
        return a + b * x - 5;
    }
}

// ❌ Sin espacios - Difícil de analizar visualmente
if(usuario.esActivo()&&!usuario.estaBloqueado()&&usuario.tienePermiso(EDITAR)||usuario.esAdministrador()){
    double resultado=(a+b)*(c-d)/e+f*g;
}

// ✅ Con espacios - Fácil de leer y entender
if (usuario.esActivo() && !usuario.estaBloqueado() &&
    usuario.tienePermiso(EDITAR) || usuario.esAdministrador()) {

    double resultado = (a + b) * (c - d) / e + f * g;
}

// Una línea sin llaves
if (x > 0) return x;

// Múltiples sentencias en una línea
if (encontrado) procesarDatos(); else mostrarError();

// For de una línea
for (int i = 0; i < 10; i++) suma += valores[i];

// While de una línea
while (hayMas()) procesar();

// Siempre usar llaves, incluso para una sola instrucción
if (x > 0) {
    return x;
}

// Bloques separados y claros
if (encontrado) {
    procesarDatos();
} else {
    mostrarError();
}

// For con llaves
for (int i = 0; i < 10; i++) {
    suma += valores[i];
}

// While con llaves
while (hayMas()) {
    procesar();
}

// Código original ❌
if (condicion)
    instruccion1();

// Alguien agrega una línea sin darse cuenta
if (condicion)
    instruccion1();
    instruccion2();  // ❌ SIEMPRE se ejecuta, no está en el if!

// Con llaves ✅ - Error imposible
if (condicion) {
    instruccion1();
    instruccion2();  // ✅ Claramente dentro del bloque
}

// Cadena demasiado larga - Difícil de leer y debuggear
String resultado = objeto.getParte1().getParte2().getParte3().getParte4().getValor();

// Imposible colocar breakpoint en parte específica
Usuario usuario = sistema.getModulo().getGestor().buscarUsuario(id).validar().normalizar();

// Cadena larga con operaciones
double total = pedido.getItems().stream().filter(i -> i.esActivo())
    .map(Item::getPrecio).reduce(0.0, Double::sum);

// Descomponer en pasos intermedios - Fácil de debuggear
String parte2 = objeto.getParte1().getParte2();
String parte3 = parte2.getParte3();
String parte4 = parte3.getParte4();
String resultado = parte4.getValor();

// O si la cadena es corta (máximo 2-3 llamadas)
String parte3 = objeto.getParte1().getParte2().getParte3();
String resultado = parte3.getParte4().getValor();

// Para cadenas inevitables, usar líneas múltiples
Usuario usuario = sistema.getModulo()
    .getGestor()
    .buscarUsuario(id)
    .validar()
    .normalizar();

// Streams: una operación por línea
double total = pedido.getItems()
    .stream()
    .filter(Item::esActivo)
    .map(Item::getPrecio)
    .reduce(0.0, Double::sum);

// ✅ Aceptable - 2 llamadas
String nombre = usuario.getPerfil().getNombre();

// ✅ Aceptable - 3 llamadas en contexto claro
int longitud = texto.trim().toLowerCase().length();

// ❌ Demasiadas - 4+ llamadas
String dato = sistema.getConfig().getSeccion("db").getParametro("url").toString();

// ✅ Refactorizado
Configuracion config = sistema.getConfig();
SeccionConfig seccionDb = config.getSeccion("db");
Parametro parametroUrl = seccionDb.getParametro("url");
String dato = parametroUrl.toString();

// ❌ Difícil de debuggear
String valor = obj.getA().getB().getC().getD();
// Si esto lanza NullPointerException, ¿cuál método retornó null?

// ✅ Fácil de debuggear
A parteA = obj.getA();           // Breakpoint aquí
B parteB = parteA.getB();        // Breakpoint aquí
C parteC = parteB.getC();        // Breakpoint aquí
String valor = parteC.getD();    // Breakpoint aquí
// Ahora es trivial encontrar dónde está el null

// ✅ Aceptable - Builder pattern con una llamada por línea
Persona persona = new PersonaBuilder()
    .nombre("Juan")
    .apellido("Pérez")
    .edad(30)
    .email("juan@example.com")
    .build();

// ✅ Aceptable - Stream API bien formateado
List<String> nombres = estudiantes.stream()
    .filter(e -> e.estaActivo())
    .map(Estudiante::getNombre)
    .sorted()
    .collect(Collectors.toList());

// ❌ Incorrecto - Todo en una línea
Persona p = new PersonaBuilder().nombre("Juan").apellido("Pérez").edad(30).build();

// ❌ Incorrecto - Múltiples sentencias
int x = 0; int y = 0; procesarAmbos(x, y);

// ❌ Incorrecto - Declaraciones múltiples
String nombre = "Juan", apellido = "Pérez", email = "juan@mail.com";

// ✅ Correcto - Una sentencia por línea
int x = 0;
int y = 0;
procesarAmbos(x, y);

// ✅ Correcto - Una declaración por línea
String nombre = "Juan";
String apellido = "Pérez";
String email = "juan@mail.com";

import java.util.*;
import java.io.*;
import java.awt.*;

public class Ejemplo {
    private List<String> nombres = new ArrayList<>();
    private Map<Integer, String> datos = new HashMap<>();
    // ¿Qué otras clases de java.util estoy importando innecesariamente?
}

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;

public class Ejemplo {
    private List<String> nombres = new ArrayList<>();
    private Map<Integer, String> datos = new HashMap<>();
    // Claro: solo uso List, ArrayList, Map, HashMap
}

// ❌ Imports con wildcard - Ambigüedad
import java.util.*;
import java.awt.*;

public class Ventana {
    // ¿Cuál List? ¿java.util.List o java.awt.List?
    private List elementos;  // ERROR: Ambiguo!
}

// ✅ Imports explícitos - Sin ambigüedad
import java.util.List;
import java.util.ArrayList;
import java.awt.Window;
import java.awt.Frame;

public class Ventana {
    private List<String> elementos;  // ✅ Claro: java.util.List
    private Frame marco;              // ✅ Claro: java.awt.Frame
}

// ✅ Importar una, usar fully qualified name para la otra
import java.util.Date;

public class Ejemplo {
    private Date fechaUtil;                    // java.util.Date
    private java.sql.Date fechaSql;            // java.sql.Date (fully qualified)

    public void procesar() {
        fechaUtil = new Date();
        fechaSql = new java.sql.Date(System.currentTimeMillis());
    }
}

// ✅ Orden estándar de imports
// 1. Imports estáticos
import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

// 2. java.*
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

// 3. javax.*
import javax.swing.JFrame;

// 4. org.*
import org.junit.Test;

// 5. com.*
import com.empresa.proyecto.Utilidades;

// Línea en blanco antes de la clase
public class MiClase {
    // ...
}

// Con wildcard ❌ - Imposible saber qué se usa realmente
import java.util.*;

public class Ejemplo {
    private List<String> nombres = new ArrayList<>();
    // ¿Uso algo más de java.util? No es evidente
}

// Con imports explícitos ✅ - Claro qué se usa
import java.util.List;
import java.util.ArrayList;
import java.util.Map;  // ← IDE marcará esto como "no usado"

public class Ejemplo {
    private List<String> nombres = new ArrayList<>();
    // Claro: Map no se usa, puede eliminarse
}

// Aceptable en casos específicos ⚠️
import static java.lang.Math.*;

public class CalculosGeometricos {
    public double calcularDistancia(double x, double y) {
        return sqrt(pow(x, 2) + pow(y, 2));  // Usa múltiples métodos de Math
    }

    public double calcularArea(double radio) {
        return PI * pow(radio, 2);
    }
}

// Pero aún mejor ✅ - Explícito
import static java.lang.Math.PI;
import static java.lang.Math.pow;
import static java.lang.Math.sqrt;

public class CalculosGeometricos {
    // Mismo código, pero claro qué métodos de Math se usan
}

# ❌ Con wildcard - No se ve qué cambió
  import java.util.*;

# ✅ Con imports explícitos - Cambio claro
  import java.util.List;
  import java.util.ArrayList;
+ import java.util.Set;
+ import java.util.HashSet;

// ❌ Números mágicos - ¿Qué significan?
if (edad >= 18) { ... }              // ¿Por qué 18?
double area = radio * radio * 3.14159;  // ¿Por qué este valor específico?
for (int i = 0; i < 100; i++) { ... }   // ¿Por qué 100?
Thread.sleep(5000);                  // ¿Por qué 5000?
if (intentos > 3) { ... }            // ¿Por qué 3?

public class SistemaAutenticacion {
    public boolean autenticar(String usuario, String contrasena) {
        int intentos = contarIntentos(usuario);

        if (intentos > 3) {  // ❌ ¿Por qué 3?
            bloquearCuenta(usuario, 86400);  // ❌ ¿Qué es 86400?
            return false;
        }

        if (contrasena.length() < 8) {  // ❌ ¿Por qué 8?
            return false;
        }

        return verificarHash(usuario, contrasena);
    }

    public double calcularDescuento(double monto) {
        if (monto > 1000) {  // ❌ ¿Por qué 1000?
            return monto * 0.15;  // ❌ ¿Qué es 0.15?
        }
        return monto * 0.05;  // ❌ ¿Qué es 0.05?
    }
}

public class SistemaAutenticacion {
    private static final int MAX_INTENTOS_FALLIDOS = 3;
    private static final int DURACION_BLOQUEO_SEGUNDOS = 86400;  // 24 horas
    private static final int LONGITUD_MINIMA_CONTRASENA = 8;

    private static final double MONTO_DESCUENTO_PREMIUM = 1000.0;
    private static final double DESCUENTO_PREMIUM = 0.15;  // 15%
    private static final double DESCUENTO_ESTANDAR = 0.05;  // 5%

    public boolean autenticar(String usuario, String contrasena) {
        int intentos = contarIntentos(usuario);

        if (intentos > MAX_INTENTOS_FALLIDOS) {
            bloquearCuenta(usuario, DURACION_BLOQUEO_SEGUNDOS);
            return false;
        }

        if (contrasena.length() < LONGITUD_MINIMA_CONTRASENA) {
            return false;
        }

        return verificarHash(usuario, contrasena);
    }

    public double calcularDescuento(double monto) {
        if (monto > MONTO_DESCUENTO_PREMIUM) {
            return monto * DESCUENTO_PREMIUM;
        }
        return monto * DESCUENTO_ESTANDAR;
    }
}

// ✅ Aceptable - Contexto matemático/lógico obvio
int suma = 0;           // Inicialización neutral para suma
int producto = 1;       // Inicialización neutral para producto
int resultado = -1;     // Valor de "no encontrado" estándar

// ✅ Aceptable - Índices estándar
array[0]                // Primer elemento
lista.get(1)            // Segundo elemento
return -1;              // Convención de "no encontrado"

// ✅ Aceptable - Comparaciones estándar
if (valor == 0) { ... }     // Comparación con cero
if (contador > 0) { ... }   // Positivo
if (indice < 0) { ... }     // Negativo (inválido)

// ✅ Aceptable - Incrementos/Decrementos unitarios
contador++;
indice += 1;
valor -= 1;

// ✅ Aceptable - Multiplicadores triviales
doble = valor * 2;
mitad = valor / 2;

// ✅ Aceptable - Números pequeños con contexto claro
int diasPorSemana = 7;
int mesesPorAnio = 12;
int horasPorDia = 24;

// Pero si se usa múltiples veces, mejor como constante
private static final int DIAS_POR_SEMANA = 7;

public class ValidadorTarjetaCredito {
    // ❌ Número mágico
    if (digitosVerificadores % 10 == 0) { ... }

    // ✅ Con constante y comentario explicativo
    private static final int MODULO_LUHN = 10;

    // Algoritmo de Luhn para validación de tarjetas
    if (digitosVerificadores % MODULO_LUHN == 0) { ... }
}

// ❌ Números mágicos en dimensiones
int[] buffer = new int[1024];
if (archivo.size() > 5242880) { ... }  // ¿Qué es este número?

// ✅ Con constantes descriptivas
private static final int TAMANIO_BUFFER = 1024;
private static final int MAX_TAMANIO_ARCHIVO = 5 * 1024 * 1024;  // 5 MB

int[] buffer = new int[TAMANIO_BUFFER];
if (archivo.size() > MAX_TAMANIO_ARCHIVO) { ... }

// ❌ Números mágicos en tiempos
Thread.sleep(5000);
cache.setTiempoVida(3600);
if (tiempoTranscurrido > 86400) { ... }

// ✅ Con constantes que documentan la unidad
private static final int ESPERA_INICIAL_MS = 5000;     // 5 segundos
private static final int TIEMPO_VIDA_CACHE_SEG = 3600; // 1 hora
private static final int SEGUNDOS_POR_DIA = 86400;     // 24 horas

Thread.sleep(ESPERA_INICIAL_MS);
cache.setTiempoVida(TIEMPO_VIDA_CACHE_SEG);
if (tiempoTranscurrido > SEGUNDOS_POR_DIA) { ... }

// ✅ Mejor aún - usar TimeUnit para claridad
private static final long ESPERA_INICIAL = TimeUnit.SECONDS.toMillis(5);
private static final long TIEMPO_VIDA_CACHE = TimeUnit.HOURS.toSeconds(1);
private static final long UN_DIA = TimeUnit.DAYS.toSeconds(1);

// ❌ Números mágicos
double descuento = precio * 0.15;
double iva = subtotal * 0.21;
double comision = monto * 0.03;

// ✅ Con constantes
private static final double TASA_DESCUENTO = 0.15;      // 15%
private static final double TASA_IVA = 0.21;            // 21%
private static final double TASA_COMISION = 0.03;       // 3%

double descuento = precio * TASA_DESCUENTO;
double iva = subtotal * TASA_IVA;
double comision = monto * TASA_COMISION;

// ✅ Alternativa - expresar como porcentaje entero
private static final double PORCENTAJE_DESCUENTO = 15.0;
private static final double DESCUENTO = PORCENTAJE_DESCUENTO / 100.0;

public class CalculosGeometricos {
    // ✅ Constantes matemáticas conocidas
    private static final double PI = 3.14159265359;
    private static final double E = 2.71828182846;
    private static final double PHI = 1.61803398875;  // Razón áurea

    // O mejor aún, usar las del JDK
    private static final double PI = Math.PI;
    private static final double E = Math.E;

    public double calcularAreaCirculo(double radio) {
        return PI * radio * radio;  // Claro qué es PI
    }
}

public class ConfiguracionServidor {
    // Timeouts (en milisegundos)
    private static final int TIMEOUT_CONEXION_MS = 5000;
    private static final int TIMEOUT_LECTURA_MS = 10000;
    private static final int TIMEOUT_ESCRITURA_MS = 10000;

    // Límites de recursos
    private static final int MAX_CONEXIONES_SIMULTANEAS = 100;
    private static final int MAX_TAMANIO_COLA = 1000;
    private static final int MAX_HILOS_POOL = 50;

    // Reintentos
    private static final int MAX_REINTENTOS = 3;
    private static final int ESPERA_ENTRE_REINTENTOS_MS = 2000;
}

public final class Constantes {
    // Constructor privado para prevenir instanciación
    private Constantes() {
        throw new AssertionError("Clase de constantes no instanciable");
    }

    // Constantes de la aplicación
    public static final int EDAD_MINIMA_REGISTRO = 18;
    public static final int LONGITUD_MAXIMA_NOMBRE = 100;
    public static final String FORMATO_FECHA_ESTANDAR = "dd/MM/yyyy";

    // Constantes de configuración
    public static final int TIMEOUT_DEFAULT_MS = 30000;
    public static final int MAX_INTENTOS_CONEXION = 5;
}

// ✅ Aceptable - Expresión calculada auto-documentada
private static final int BYTES_POR_MEGABYTE = 1024 * 1024;
private static final int SEGUNDOS_POR_DIA = 24 * 60 * 60;
private static final long MILISEGUNDOS_POR_HORA = 60 * 60 * 1000;

// Más claro que el literal directo
private static final int BYTES_POR_MEGABYTE = 1048576;  // ¿Qué es esto?

// ❌ Constante con nombre no descriptivo - Sigue siendo "mágica"
private static final int VALOR = 18;
private static final double NUMERO = 3.14159;
private static final int LIMITE = 100;

// ✅ Constante con nombre descriptivo
private static final int EDAD_MINIMA_LEGAL = 18;
private static final double PI = 3.14159;
private static final int MAX_ELEMENTOS_PAGINA = 100;

// ✅ No requiere constante - Contexto obvio
String[] partes = texto.split(" ");
if (lista.size() == 0) { ... }      // Aunque isEmpty() es mejor
array[0] = valor;                   // Primer elemento
return lista.size() - 1;            // Último índice

// ❌ Constante innecesaria - Sobrecomplica
private static final int PRIMER_ELEMENTO = 0;
private static final int LISTA_VACIA = 0;

array[PRIMER_ELEMENTO] = valor;  // Overkill
if (lista.size() == LISTA_VACIA) { ... }  // Usar isEmpty()

// ✅ Aceptable - Operaciones matemáticas obvias
int doble = valor * 2;
int mitad = valor / 2;
boolean esPar = numero % 2 == 0;
int cuadrado = lado * lado;

// ❌ Constante innecesaria
private static final int MULTIPLICADOR_DOBLE = 2;
int doble = valor * MULTIPLICADOR_DOBLE;  // Sobrecomplica

// ¿Es mágico?
if (temperatura > 100) { ... }
// Pregunta: ¿Por qué 100? ¿Celsius? ¿Fahrenheit? ¿Kelvin?
// Respuesta: ❌ SÍ es mágico

// ✅ Solución
private static final double TEMP_EBULLICION_CELSIUS = 100.0;
if (temperatura > TEMP_EBULLICION_CELSIUS) { ... }

// ¿Es mágico?
for (int i = 0; i < array.length; i++) { ... }
// Pregunta: ¿Son 0 y 1 mágicos aquí?
// Respuesta: ❌ NO son mágicos, contexto obvio (iteración completa)

// ✅ Constante + comentario explica el origen
private static final int MAX_CONEXIONES_TCP = 65535;  // Límite de puertos TCP/IP

private static final double GRAVEDAD_TIERRA = 9.80665;  // m/s² (estándar CGPM)

// Días hasta advertencia de expiración
private static final int DIAS_ADVERTENCIA_LICENCIA = 30;

// Factor de conversión de Fahrenheit a Celsius
private static final double FACTOR_F_TO_C = 5.0 / 9.0;

// ❌ Test con números mágicos
@Test
public void testDescuento() {
    double resultado = calcularDescuento(1500);
    assertEquals(225.0, resultado, 0.01);  // ¿De dónde sale 225?
}

// ✅ Test con constantes descriptivas
@Test
public void testDescuentoPremium() {
    double montoCompra = 1500.0;
    double descuentoEsperado = montoCompra * 0.15;  // 15% para monto > 1000

    double resultado = calcularDescuento(montoCompra);

    assertEquals(descuentoEsperado, resultado, 0.01);
}

// ❌ Hard-coded - Requiere recompilar para cambiar
private static final int MAX_CONEXIONES = 100;
private static final String URL_BASE = "http://localhost:8080";

// ✅ Configurable - Puede cambiar sin recompilar
public class Configuracion {
    private static final int MAX_CONEXIONES_DEFAULT = 100;
    private static final String URL_BASE_DEFAULT = "http://localhost:8080";

    public int getMaxConexiones() {
        return Integer.parseInt(
            System.getProperty("max.conexiones",
                              String.valueOf(MAX_CONEXIONES_DEFAULT))
        );
    }

    public String getUrlBase() {
        return System.getProperty("url.base", URL_BASE_DEFAULT);
    }
}

// Antes ❌
public class Validador {
    public boolean esContrasenaSegura(String contrasena) {
        return contrasena.length() >= 8 &&
               contiene(contrasena, "[0-9]") &&
               contiene(contrasena, "[A-Z]");
    }

    public boolean esCodigoValido(String codigo) {
        return codigo.matches("[A-Z]{2}[0-9]{8}");
    }
}

// Después ✅
public class Validador {
    private static final int LONGITUD_MINIMA_CONTRASENA = 8;
    private static final String PATRON_TIENE_DIGITO = "[0-9]";
    private static final String PATRON_TIENE_MAYUSCULA = "[A-Z]";

    private static final int LONGITUD_CODIGO_LETRAS = 2;
    private static final int LONGITUD_CODIGO_DIGITOS = 8;
    private static final String PATRON_CODIGO =
        String.format("[A-Z]{%d}[0-9]{%d}",
                     LONGITUD_CODIGO_LETRAS,
                     LONGITUD_CODIGO_DIGITOS);

    public boolean esContrasenaSegura(String contrasena) {
        return contrasena.length() >= LONGITUD_MINIMA_CONTRASENA &&
               contiene(contrasena, PATRON_TIENE_DIGITO) &&
               contiene(contrasena, PATRON_TIENE_MAYUSCULA);
    }

    public boolean esCodigoValido(String codigo) {
        return codigo.matches(PATRON_CODIGO);
    }
}

// ❌ Comentarios obvios que no agregan valor
public class Cliente {
    // Incrementa i en 1
    i = i + 1;

    // Verifica si el nombre es nulo
    if (nombre == null) {
        // Lanza excepción
        throw new IllegalArgumentException();
    }

    // Crea un nuevo objeto ArrayList
    List<Producto> productos = new ArrayList<>();

    // Loop que itera sobre los productos
    for (Producto p : productos) {
        // Imprime el producto
        System.out.println(p);
    }

    // Retorna verdadero
    return true;
}

public class Cliente {
    // No necesita comentario, el código es claro
    i = i + 1;

    // Validación temprana para evitar NullPointerException en comparaciones posteriores
    if (nombre == null) {
        throw new IllegalArgumentException("El nombre no puede ser nulo");
    }

    // No necesita comentario
    List<Producto> productos = new ArrayList<>();

    // Usamos búsqueda binaria porque la lista está ordenada (O(log n) vs O(n))
    int posicion = busquedaBinaria(lista, elemento);

    // El algoritmo de Luhn requiere sumar dígitos en posiciones pares
    // por separado de los impares antes de la verificación final
    int sumaPares = calcularSumaPosicionesPares(digitos);
    int sumaImpares = calcularSumaPosicionesImpares(digitos);

    // Retornamos true porque la especificación del cliente requiere
    // que clientes sin compras previas sean considerados activos por defecto
    return true;
}

// Calcula el precio final aplicando descuento por volumen
// Si compra más de 100 unidades: 15% descuento
// Si compra más de 50 unidades: 10% descuento
// Si compra más de 20 unidades: 5% descuento
double precioFinal;
if (cantidad > 100) {
    precioFinal = precioBase * 0.85;
} else if (cantidad > 50) {
    precioFinal = precioBase * 0.90;
} else if (cantidad > 20) {
    precioFinal = precioBase * 0.95;
} else {
    precioFinal = precioBase;
}

// ✅ El método y las constantes eliminan la necesidad de comentarios
private static final int UMBRAL_DESCUENTO_MAXIMO = 100;
private static final int UMBRAL_DESCUENTO_MEDIO = 50;
private static final int UMBRAL_DESCUENTO_MINIMO = 20;

private static final double DESCUENTO_MAXIMO = 0.15;
private static final double DESCUENTO_MEDIO = 0.10;
private static final double DESCUENTO_MINIMO = 0.05;

public double calcularPrecioConDescuentoPorVolumen(double precioBase, int cantidad) {
    double porcentajeDescuento = obtenerDescuentoPorVolumen(cantidad);
    return precioBase * (1 - porcentajeDescuento);
}

private double obtenerDescuentoPorVolumen(int cantidad) {
    if (cantidad > UMBRAL_DESCUENTO_MAXIMO) {
        return DESCUENTO_MAXIMO;
    }
    if (cantidad > UMBRAL_DESCUENTO_MEDIO) {
        return DESCUENTO_MEDIO;
    }
    if (cantidad > UMBRAL_DESCUENTO_MINIMO) {
        return DESCUENTO_MINIMO;
    }
    return 0.0;
}

public double calcularDescuento(double monto) {
    // Aplicamos la fórmula de descuento exponencial porque
    // da mejores resultados en el análisis de fidelización (ver informe Q1-2024)
    return monto * Math.exp(-0.05 * diasDesdePrimeraCompra);
}

/**
 * Calcula el descuento aplicable basado en el monto y la antigüedad del cliente.
 *
 * @param monto el monto base sobre el cual calcular el descuento
 * @return el descuento aplicable en la misma unidad que el monto
 * @throws IllegalArgumentException si el monto es negativo
 */
public double calcularDescuento(double monto) {
    // ...
}

// La regla de negocio establece que usuarios premium
// tienen acceso sin límite de intentos durante el período de prueba
if (usuario.esPremium() && usuario.enPeriodoDePrueba()) {
    return Integer.MAX_VALUE;
}

// LIMITACIÓN: Este algoritmo asume que los datos están ordenados
// Si se modifica para aceptar datos no ordenados, cambiar a búsqueda lineal
return busquedaBinaria(datos, objetivo);

// Timeout de 30 segundos basado en SLA del servicio externo (28s + 2s buffer)
private static final int TIMEOUT_MILISEGUNDOS = 30000;

// Incrementamos primero porque el índice inicial es -1
// (representa "antes del primer elemento")
indice++;
Elemento actual = array[indice];