¿Por qué int i = 1024 * 1024 * 1024 * 1024 se compila sin error?

El límite de intes de -2147483648 a 2147483647.

Si ingreso

int i = 2147483648;

entonces Eclipse mostrará un subrayado rojo debajo de "2147483648".

Pero si hago esto:

int i = 1024 * 1024 * 1024 * 1024;

Se compilará bien.

public class Test {
    public static void main(String[] args) {        

        int i = 2147483648;                   // error
        int j = 1024 * 1024 * 1024 * 1024;    // no error

    }
}

Tal vez es una pregunta básica en Java, pero no tengo idea de por qué la segunda variante no produce ningún error.

No hay nada malo con esa declaración; solo estás multiplicando 4 números y asignándolos a un int, simplemente sucede que hay un desbordamiento. Esto es diferente de asignar un solo literal , que se verificaría en los límites en tiempo de compilación.

Es el literal fuera de límites lo que causa el error, no la asignación :

System.out.println(2147483648);        // error
System.out.println(2147483647 + 1);    // no error

Por el contrario, un longliteral compilaría bien:

System.out.println(2147483648L);       // no error

Tenga en cuenta que, de hecho, el resultado es todavía calcula en tiempo de compilación, porque 1024 * 1024 * 1024 * 1024es una expresión constante :

int i = 1024 * 1024 * 1024 * 1024;

se convierte en:

   0: iconst_0      
   1: istore_1      

Tenga en cuenta que el resultado ( 0) simplemente se carga y almacena, y no se produce ninguna multiplicación.

De JLS §3.10.1 (gracias a @ChrisK por mencionarlo en los comentarios):

Es un error en tiempo de compilación si un literal decimal de tipo intes mayor que 2147483648(2 ³¹ ), o si el literal decimal 2147483648aparece en cualquier otro lugar que no sea el operando del operador menos unario ( §15.15.4 ).

1024 * 1024 * 1024 * 1024y 2147483648no tienen el mismo valor en Java.

En realidad, 2147483648 NO ES UN VALOR (aunque lo 2147483648Lsea) en Java. El compilador literalmente no sabe qué es ni cómo usarlo. Entonces se queja.

1024es un int válido en Java, y un válido intmultiplicado por otro válido int, siempre es válido int. Incluso si no es el mismo valor que esperaría intuitivamente porque el cálculo se desbordará.

Ejemplo

Considere el siguiente ejemplo de código:

public static void main(String[] args) {
    int a = 1024;
    int b = a * a * a * a;
}

¿Esperaría que esto generara un error de compilación? Ahora se vuelve un poco más resbaladizo.
¿Qué pasa si ponemos un ciclo con 3 iteraciones y multiplicado en el ciclo?

El compilador puede optimizar, pero no puede cambiar el comportamiento del programa mientras lo hace.

Alguna información sobre cómo se maneja realmente este caso:

En Java y muchos otros lenguajes, los enteros consistirán en un número fijo de bits. Los cálculos que no caben en el número de bits dado se desbordarán ; el cálculo se realiza básicamente módulo 2 ^ 32 en Java, después de lo cual el valor es de nuevo convertida en un firmado entero.

Otros lenguajes o API utilizan un número dinámico de bits ( BigIntegeren Java), generan una excepción o establecen el valor en un valor mágico como no un número.

No tengo idea de por qué la segunda variante no produce ningún error.

El comportamiento que sugiere, es decir, la producción de un mensaje de diagnóstico cuando un cálculo produce un valor que es mayor que el valor más grande que se puede almacenar en un entero , es una característica . Para que pueda utilizar cualquier función, debe pensar en ella, considerarla una buena idea, diseñar, especificar, implementar, probar, documentar y enviar a los usuarios.

Para Java, una o más de las cosas en esa lista no sucedieron y, por lo tanto, no tiene la función. No se cual; tendrías que preguntarle a un diseñador de Java.

Para C #, todas esas cosas sucedieron, hace unos catorce años, por lo que el programa correspondiente en C # ha producido un error desde C # 1.0.

Además de la respuesta de arshajii, quiero mostrar una cosa más:

No es la asignación la que causa el error, sino simplemente el uso del literal . Cuando intentas

long i = 2147483648;

notarás que también causa un error de compilación ya que el lado derecho todavía es un intliteral y está fuera de rango.

Por lo tanto, las operaciones con intvalores (y eso incluye asignaciones) pueden desbordarse sin un error de compilación (y sin un error de tiempo de ejecución también), pero el compilador simplemente no puede manejar esos literales demasiado grandes.

A: Porque no es un error.

Antecedentes: la multiplicación 1024 * 1024 * 1024 * 1024conducirá a un desbordamiento. Un desbordamiento es muy a menudo un error. Diferentes lenguajes de programación producen un comportamiento diferente cuando se producen desbordamientos. Por ejemplo, C y C ++ lo llaman "comportamiento indefinido" para enteros con signo, y el comportamiento se define como enteros sin signo (tome el resultado matemático, agregue UINT_MAX + 1siempre que el resultado sea negativo, reste UINT_MAX + 1siempre que el resultado sea mayor que UINT_MAX).

En el caso de Java, si el resultado de una operación con intvalores no está en el rango permitido, conceptualmente Java suma o resta 2 ^ 32 hasta que el resultado esté en el rango permitido. Entonces, la declaración es completamente legal y no está equivocada. Simplemente no produce el resultado que esperaba.

Seguramente puede discutir si este comportamiento es útil y si el compilador debería darle una advertencia. Yo personalmente diría que una advertencia sería muy útil, pero un error sería incorrecto ya que es Java legal.