Quantas das quatro perguntas básicas do Java você pode contar?
1. Uso de == símbolo
Primeiro, veja um código mais interessante
Número inteiro a = 1000, b = 1000; Número inteiro c = 100, d = 100; public void mrun (nome da string final) {new runnable () {public void run () {System.out.println (nome); }}; } System.out.println (a == b); System.out.println (c == d); Se você pode obter a resposta correta para esta pergunta e entender o princípio. Isso significa que seu básico está bem. Se sua resposta for verdadeira e verdadeira, sua fundação estará faltando.
Primeiro, publique a resposta, execute o código e seremos falsos verdadeiros. Sabemos que == compara as referências dos dois objetos. O ABCD aqui são objetos recém -criados. Em teoria, o falso deve ser inserido. Esta é a coisa interessante sobre essa pergunta. Seja a pergunta da entrevista ou a área de discussão do fórum, a taxa de aparência dessa questão é muito alta. O princípio é realmente muito simples. Vejamos a aula Integer.java e você o entenderá.
public estático inteiro valueof (int i) {return i> = 128 || Eu <-128? novo número inteiro (i): small_values [i + 128]; } / ** * Um cache de instâncias usadas por {@link Integer#valueof (int)} e boxing automático * / Inteiro final estático privado [] small_values = new integer [256]; estático {for (int i = -128; i <128; i ++) {small_values [i+128] = new Integer (i); }} Quando declaramos um número inteiro c = 100;. Neste momento, a operação automática de boxe será executada. Para simplificar, significa converter o tipo de dados básico em um objeto inteiro e convertê -lo em um objeto inteiro é o método ValueOf chamado. Você pode ver que -128-127 está em cache em número inteiro. A explicação oficial é que pequenos números são usados com mais frequência; portanto, para otimizar o desempenho, os números entre eles são armazenados em cache. É por isso que a resposta a esta pergunta é falsa e terminada. Quando o valor do objeto inteiro declarado está entre -128-127, o mesmo objeto é referenciado, portanto o resultado é verdadeiro.
2. String
Em seguida, olhe para o código
String s1 = "abc"; String s2 = "abc"; String S3 = new String ("ABC"); System.out.println (S1 == S2); System.out.println (S1 == S3); Vamos adivinhar qual é a resposta para esta pergunta?
De acordo com a sintaxe de ==, antes de tudo, S1, S2 e S3 são três objetos diferentes. Senso comum, a saída será falsa. No entanto, os resultados em execução do programa são realmente verdadeiros e falsos. A segunda saída falsa é compreensível e a primeira saída é intrigante novamente. Sabemos que algumas variáveis básicas e variáveis de referência do objeto são alocadas na memória da pilha da função, enquanto novos objetos e matrizes são armazenados na memória da heap. No entanto, além disso, há outra área chamada piscina constante. Como geralmente queremos string s1 = "abc";, o valor do objeto String declarado é armazenado em um pool constante. Quando criamos um objeto como String S1 = "ABC", "ABC" é armazenado no pool constante (também chamado de pool de cordas). Quando criamos uma string de referência S2 = "ABC", a camada Java subjacente priorizará a descoberta se "ABC" existe no pool constante. Se houver, vamos apontar para esse valor e não o recriará. Se não houver um pool constante, ele será criado e adicionado à piscina. É por isso que as respostas são verdadeiras e falsas.
3. Palavra -chave final <BR /> Vejamos um pedaço de código
public void mrun (nome da string final) {new runnable () {public void run () {try {thread.sleep (1000); } catch (interruptedException e) {// TODO BLOCO DE CATCH AUTOGERATIDO E.PRINTSTACKTRACE (); } System.out.println (nome); } }.começar(); } Eu acredito que todo mundo escreveu muito desse tipo de código. Quando as classes internas acessam variáveis locais, elas precisam adicionar um modificador final antes das variáveis locais, caso contrário, o compilador relatará um erro. Normalmente fazemos o mesmo. OK, a segunda pergunta é: por que adicionar o modificador final? Acredito que a maioria dos meus amigos nunca pensou sobre esse problema. Sempre que o usam, basta adicioná -lo diretamente e nunca se aprofundou nos princípios. Isso não é desejável para um excelente programador. Não devemos apenas saber a verdade, mas também o motivo.
Agora, vamos analisar por que você precisa adicionar palavras -chave finais. Primeiro de tudo, o ciclo de vida da classe interna está no nível do membro, enquanto o ciclo de vida das variáveis locais está no corpo do método. Em outras palavras, essa situação ocorrerá. Quando o método MUN for executado, o novo thread será executado e o novo thread dormirá por um segundo. O encadeamento principal continuará sendo executado, o MRUN é executado e o ciclo de vida do atributo de nome termina. Após 1 segundo, syetem.out.printth (nome) é executado. No entanto, neste momento, o nome morreu e não está mais na memória. O Java deve eliminar esse erro e exige estritamente variáveis locais em classes internas a serem modificadas com palavras -chave finais. Depois que a variável local é modificada por final, uma réplica local será mantida na memória. Quando a classe interna acessa, ele é realmente acessado. É como tornar o ciclo de vida de uma variável local por mais tempo. Afinal, foi o engenheiro de Java que preencheu este poço para nós com antecedência, caso contrário, me pergunto quantos amigos se preocupariam com variáveis locais internas.
4. Inteiro e int
Veja o seguinte código
Inteiro a = novo número inteiro (1000); int b = 1000; Número inteiro c = novo número inteiro (10); Número inteiro d = novo número inteiro (10); System.out.println (a == b); System.out.println (c == d);
Esta pergunta é um acompanhamento da primeira pergunta. Se você pode obter a resposta para esta pergunta rapidamente, parabéns, mesmo que você tenha dominado a função de comparação == mais minuciosamente.
Revelar a resposta correta: verdadeiro, falso
Muitos amigos ficam intrigados depois de ver essa resposta. Vamos falar sobre o segundo primeiro. De acordo com a primeira pergunta, o número inteiro não armazenou em cache -128-127? Isso deve ser verdadeiro, mas se você olhar de perto, o número inteiro aqui será criado por nós, não usando o cache, portanto o resultado é falso. Agora vamos ver por que o primeiro é verdadeiro novamente? Primeiro de tudo, o valor aqui é 1000, que definitivamente não tem nada a ver com o cache inteiro como o conhecemos. Como não tem nada a ver com cache, A é o objeto do novo novo, a entrada deve ser falsa. Mas observe que B é o tipo int aqui. Quando o INT e o número inteiro comparar ==, o Java será automaticamente unbox inteiro, ou seja, converter o número inteiro em tipo int; portanto, o valor do tipo int é comparado aqui, portanto o resultado é verdadeiro.
Depois de fazer algumas perguntas corretamente, apresse -se e verifique as omissões e preencha as lacunas de acordo com o seu próprio nível de teste!