¿Cuántas de las cuatro preguntas básicas de Java puedes decir?
1. Uso de == Símbolo
Primero, mira un código más interesante
Entero a = 1000, b = 1000; Entero C = 100, d = 100; public void mrun (nombre de cadena final) {new Runnable () {public void run () {System.out.println (name); }}; } System.out.println (a == b); System.out.println (c == d); Si puede obtener la respuesta correcta a esta pregunta y comprender el principio. Significa que tus conceptos básicos están bien. Si su respuesta es verdadera y verdadera, su fundación le faltará.
Primero, publique la respuesta, ejecute el código y obtendremos falso verdadero. Sabemos que == compara las referencias de los dos objetos. El ABCD aquí es ambos objetos recién creados. En teoría, se debe ingresar falso. Esto es lo interesante de esta pregunta. Ya sea la pregunta de la entrevista o el área de discusión del foro, la tasa de apariencia de esta pregunta es muy alta. El principio es en realidad muy simple. Veamos la clase Integer.java y lo entenderá.
Public Static Integer Value de (int i) {return i> = 128 || i <-128? nuevo entero (i): small_values [i + 128]; } / ** * Un caché de instancias utilizadas por {@link Integer#Valuef (int)} y Auto-Boxing * / private Static Final Integer [] Small_Values = new Integer [256]; static {for (int i = -128; i <128; i ++) {small_values [i+128] = new Integer (i); }} Cuando declaramos un entero C = 100;. En este momento, se realizará la operación automática de boxeo. En pocas palabras, significa convertir el tipo de datos básico en un objeto entero, y convertirlo en un objeto entero es el método Value de llamado. Puede ver que -128-127 se almacena en caché en entero. La explicación oficial es que los números pequeños se usan con mayor frecuencia, por lo que para optimizar el rendimiento, los números entre ellos se almacenan en caché. Es por eso que la respuesta a esta pregunta es falsa y tura. Cuando el valor del objeto entero declarado es entre -128-127, se hace referencia al mismo objeto, por lo que el resultado es verdadero.
2. Cadena
Luego mira el código
Cadena S1 = "ABC"; Cadena s2 = "ABC"; Cadena s3 = nueva cadena ("ABC"); System.out.println (S1 == S2); System.out.println (S1 == S3); ¿Adivinamos cuál es la respuesta a esta pregunta?
De acuerdo con la sintaxis de ==, en primer lugar, S1, S2 y S3 son tres objetos diferentes. Sentido común, la salida será falsa. Sin embargo, los resultados en ejecución del programa son realmente verdaderos y falsos. La segunda salida FALSE es comprensible, y la primera salida verdadera es desconcertante nuevamente. Sabemos que algunas variables de tipo básico y variables de referencia de Object se asignan en la memoria de la pila de la función, mientras que los objetos y matrices nuevos se almacenan en la memoria de Heap. Sin embargo, además de esto, hay otra área llamada piscina constante. Como generalmente queremos String S1 = "ABC";, el valor del objeto de cadena declarado se almacena en un grupo constante. Cuando creamos un objeto como String S1 = "ABC", "ABC" se almacena en el grupo constante (también llamado grupo de cadenas). Cuando creamos una cadena de referencia S2 = "ABC", la capa subyacente de Java priorizará encontrar si "ABC" existe en el grupo constante. Si existe, deje que S2 apunte a este valor y no lo recreará. Si no hay un grupo constante, se creará y se agregará a la piscina. Por eso las respuestas son verdaderas y falsas.
3. Palabra clave final <Br /> Veamos un código de código
public void mrun (nombre de cadena final) {new runnable () {public void run () {try {horth.sleep (1000); } Catch (InterruptedException e) {// TODO Auto Generado Bloque E.PrintStackTrace (); } System.out.println (nombre); } }.comenzar(); } Creo que todos han escrito mucho de este tipo de código. Cuando las clases internas acceden a las variables locales, deben agregar un modificador final antes de las variables locales, de lo contrario, el compilador informará un error. Por lo general, hacemos lo mismo. Ok, la segunda pregunta es, ¿por qué agregar el modificador final? Creo que la mayoría de mis amigos nunca han pensado en este problema. Cada vez que lo usan, simplemente agréguelo directamente y nunca haya profundizado en los principios. Esto no es deseable para un excelente programador. No solo debemos conocer la verdad sino también la razón.
Ahora analicemos por qué necesita agregar la palabra clave final. En primer lugar, el ciclo de vida de la clase interna está a nivel de miembro, mientras que el ciclo de vida de las variables locales está en el cuerpo del método. En otras palabras, esta situación ocurrirá. Cuando se ejecuta el método MRUN, el nuevo hilo se ejecutará y el nuevo hilo dormirá por un segundo. El hilo principal continuará ejecutándose, Mrun se ejecuta y el ciclo de vida del atributo de nombre finaliza. Después de 1 segundo, se ejecuta syetem.out.printh (nombre). Sin embargo, en este momento, el nombre ha muerto y ya no está en la memoria. Java es eliminar este error y requiere estrictamente que las variables locales en las clases internas se modifiquen con las palabras clave finales. Después de que la variable local se modifique por final, una réplica local se conservará en la memoria. Cuando la clase interna accede, en realidad se accede. Esto es como hacer que el ciclo de vida de una variable local sea más largo. Después de todo, fue el ingeniero de Java quien nos completó este pozo de antemano, de lo contrario, me pregunto cuántos amigos se preocuparían por las variables locales internas.
4. Integer e int
Mira el siguiente código
Entero a = nuevo entero (1000); int b = 1000; Entero c = nuevo entero (10); Entero d = nuevo entero (10); System.out.println (a == b); System.out.println (c == d);
Esta pregunta es un seguimiento de la primera pregunta. Si puede obtener la respuesta a esta pregunta rápidamente, felicidades, incluso si ha dominado la función de comparación == más a fondo.
Revela la respuesta correcta: Verdadero, Falso
Muchos amigos están perplejos después de ver esta respuesta. Hablemos primero del segundo. Según la primera pregunta, ¿no ha almacenado en caché -128-127? Esto debería ser cierto, pero si miras de cerca, el entero aquí es creado por nosotros, sin usar caché, por lo que el resultado es falso. Ahora veamos por qué el primero es cierto nuevamente. En primer lugar, el valor aquí es 1000, que definitivamente no tiene nada que ver con el caché entero tal como lo conocemos. Dado que no tiene nada que ver con el caché, A es el objeto del nuevo nuevo, la entrada debe ser falsa. Pero tenga en cuenta que B es el tipo int aquí. Cuando int y entero comparan ==, Java se desanimará automáticamente entero, es decir, convertir entero en tipo int, por lo que el valor del tipo int se compara aquí, por lo que el resultado es verdadero.
Después de hacer algunas preguntas correctamente, date prisa y verifique si hay omisiones y complete los vacíos de acuerdo con tu propio nivel de prueba.