Сколько из четырех основных вопросов Java вы можете сказать?
1. Использование символа ==
Во -первых, посмотрите на более интересный код
Целое число a = 1000, b = 1000; Целое число C = 100, D = 100; public void mrun (final String name) {new Runnable () {public void run () {System.out.println (name); }}; } System.out.println (a == b); System.out.println (c == d); Если вы можете получить правильный ответ на этот вопрос и понять принцип. Это означает, что ваши основы в порядке. Если ваш ответ верен и правдив, ваш основание будет отсутствовать.
Во -первых, опубликуйте ответ, запустите код, и мы получим False True. Мы знаем, что == сравнивает ссылки двух объектов. ABCD здесь - оба недавно созданные объекты. Теоретически, ложь должен быть введен. Это интересная вещь в этом вопросе. Будь то вопрос собеседования или область обсуждения на форуме, уровень внешнего вида этого вопроса очень высок. Принцип на самом деле очень прост. Давайте посмотрим на класс Integer.java, и вы это поймете.
Public Static Integer Valueof (int i) {return i> = 128 || я <-128? Новое целое число (i): small_values [i + 128]; } / ** * Кэш экземпляров, используемые {@link Integer#valueOf (int)} и автоматического бокса * / частное статическое окончательное целое число [] small_values = new Integer [256]; static {for (int i = -128; i <128; i ++) {small_values [i+128] = new Integer (i); }} Когда мы объявляем целое число C = 100;. В настоящее время будет выполнена автоматическая операция по боксу. Проще говоря, это означает преобразование основного типа данных в целочисленный объект, а преобразование его в целочисленный объект - это значение вызываемого значения. Вы можете видеть, что -128-127 кэшируется в целом. Официальное объяснение заключается в том, что небольшие числа используются чаще, поэтому для оптимизации производительности цифры между ними кэшируются. Вот почему ответ на этот вопрос является ложным и туре. Когда объявленное значение целочисленного объекта находится между -128-127, упоминается один и тот же объект, поэтому на результат верно.
2. Строка
Затем посмотрите на код
Строка S1 = "ABC"; Строка S2 = "ABC"; String s3 = new String ("ABC"); System.out.println (S1 == S2); System.out.println (S1 == S3); Давайте догадаемся, в чем ответ на этот вопрос?
Согласно синтаксису ==, прежде всего, S1, S2 и S3 - три разных объекта. Здравый смысл, выход будет ложным. Тем не менее, результаты работы программы действительно верны и ложны. Второй выходной лодский вывод понятен, и первый вывод True снова озадачивает. Мы знаем, что некоторые основные переменные типа и эталонные переменные объекта выделяются в памяти стека функции, в то время как новые объекты и массивы хранятся в памяти кучи. Однако, в дополнение к этому, есть еще одна область, называемая постоянным бассейном. Как мы обычно хотим, чтобы строка S1 = "ABC";, значение объявленного объекта строки хранится в постоянном пуле. Когда мы создаем такой объект, как String S1 = «ABC», «ABC» хранится в постоянном пуле (также называемом пулом строк). Когда мы создаем эталонную строку S2 = «ABC», лежа, лежащий в основе Java будет определять приоритет, обнаруживает, существует ли «ABC» в постоянном пуле. Если он существует, пусть S2 указывает на это значение и не будет воссоздать его. Если нет постоянного бассейна, он будет создан и добавлен в бассейн. Вот почему ответы верны и ложны.
3. Окончательное ключевое слово <br /> давайте посмотрим на кусок кода
public void mrun (final String name) {new Runnable () {public void run () {try {thread.sleep (1000); } catch (прерванная экспрессия e) {// todo автоматически сгенерированный блок e.printstacktrace (); } System.out.println (name); } }.начинать(); } Я считаю, что все написали много такого кода. Когда внутренние классы получают доступ к локальным переменным, им необходимо добавить окончательный модификатор перед локальными переменными, в противном случае компилятор сообщит об ошибке. Обычно мы делаем то же самое. Хорошо, второй вопрос: зачем добавлять окончательный модификатор? Я считаю, что большинство моих друзей никогда не думали об этой проблеме. Всякий раз, когда они используют его, просто добавляйте его напрямую и никогда не углубились в принципы. Это нежелательно для отличного программиста. Мы должны знать не только правду, но и причину.
Теперь давайте проанализируем, почему вам нужно добавить окончательное ключевое слово. Прежде всего, жизненный цикл внутреннего класса находится на уровне члена, в то время как жизненный цикл локальных переменных находится в организме метода. Другими словами, эта ситуация произойдет. Когда метод MRUN будет выполнен, новый поток будет работать, а новый поток будет спать на секунду. Основной поток будет продолжать выполнять, выполняется MRUN, а жизненный цикл атрибута имени заканчивается. Через 1 секунду выполняется 1 секунду. Однако в настоящее время имя умерло и больше не в памяти. Java должна устранить эту ошибку и строго требует, чтобы локальные переменные во внутренних классах были изменены с помощью окончательных ключевых слов. После того, как локальная переменная изменяется в финале, локальная копия будет сохранена в памяти. Когда внутренний класс обращается к ней, он фактически доступен. Это все равно, что делать жизненный цикл местной переменной дольше. В конце концов, это был инженер Java, который заполнил эту яму для нас заранее, иначе мне интересно, сколько друзей беспокоится о внутренних локальных переменных.
4. целое число и int
Посмотрите на следующий код
Целое число a = новое целое число (1000); int b = 1000; Целое число C = новое целое число (10); Целое число d = новое целое число (10); System.out.println (a == b); System.out.println (c == d);
Этот вопрос является продолжением первого вопроса. Если вы можете быстро получить ответ на этот вопрос, то поздравляю, даже если вы освоили функцию сравнения == более тщательно.
Раскрыть правильный ответ: верно, ложь
Многие друзья озадачены после того, как увидели этот ответ. Давайте сначала поговорим о втором. Согласно первому вопросу, разве INTEGER CACHED -128-127? Это должно быть правдой, но если вы присмотритесь, целое число здесь создается здесь, не используя кэш, поэтому результат неверно. Теперь посмотрим, почему первый снова правда? Прежде всего, значение здесь составляет 1000, что определенно не имеет ничего общего с целочисленным кэшем, как мы его знаем. Поскольку это не имеет ничего общего с кэшем, A является объектом из нового нового, вход должен быть ложным. Но обратите внимание, что B - тип Int здесь. Когда int и Integer сравнится ==, Java автоматически разбивает целое число, то есть преобразовать целое число в тип int, поэтому здесь сравнивается значение типа int, поэтому результат правда.
После того, как вы делаете несколько вопросов правильно, поторопитесь и проверьте упущения и заполните пробелы в соответствии с вашим собственным тестовым уровнем!