Результаты прохождения теста Java основы пользователем Serjkee

Результат прохождения теста "Java основы" - Пройден

+108

  • Кто проходил: Serjkee
  • Дата прохождения: 05.04.2019
Какие изменения приведут к успешной компиляции следующего класса?
public class LocalVsInstance {     
   String s; 
 
   public static void main(String[] args) { 
       String s; 
       System.out.println(s.toUpperCase()); 
       LocalVsInstance localVsInstance = new  LocalVsInstance(); 
       System.out.println(localVsInstance.s.toUpperCase()); 
   } 
 
} 
Ваши ответы
присвоить значение, отличное от null локальной переменной s
присвоить любое значение локальной переменной s
Объяснение:

Для успешной компиляции надо явно инициализировать локальную переменную, null вполне сойдет. Переменная объекта s будет неявно инициализирована null'ом. NPE хоть и вылетит, но это уже ошибка времени выполнения.

Какой результат компиляции и запуска следующего кода с использованием параметров a = 0 , b = 3?
public void divide(int a, int b) { 
   try { 
       int c = a / b; 
   } catch (Exception e) { 
       System.out.print("Exception "); 
   } finally { 
       System.out.println("Finally"); 
   } 
} 
Ваши ответы
Будет выведено Finally
Объяснение:

Блок finally выполняется всегда за исключением некоторых вариантов
0/3 = 0 не выкидывает исключительной ситуации

Какой будет результат выполнения программы:
public class BooleanTest { 
  static boolean test1(int val) { 
       System.out.println("test1("+ val +")"); 
       System.out.println("результат: " + (val < 10)); 
       return val < 10; 
   } 
 
   static boolean test2(int val) { 
       System.out.println("test2("+ val +")"); 
       System.out.println("результат: " + (val < 20)); 
       return val < 20; 
   } 
 
   static boolean test3(int val) { 
       System.out.println("test3("+ val +")"); 
       System.out.println("результат: " + (val < 30)); 
       return val < 30; 
   } 
 
   public static void main(String[] args) { 
      if(test1(0) && test2(20) && test3(20)) 
          System.out.println("Выражение истинно"); 
      else 
          System.out.println("Выражение ложно"); 
   } 
} 
Ваши ответы
test1(0)
результат: true
test2(20)
результат: false
Выражение ложно
Объяснение:

Оператор && вычисляет операнды слева направо до тех пор, пока не сможет однозначно определить истинность всего выражения.
Поэтому в данном примере вызываются только два метода:
test1(0) – true
test2(20) – false
а в вызове test3() уже необходимости нет, поскольку вне зависимости от его результата уже ясно, что значение всего выражения будет false.

Что напечатает следущий код?
public class Test { 
   public static boolean methodOne() { 
       System.out.println("methodOne "); 
       return false; 
   } 
 
   public static boolean methodTwo() { 
       System.out.println("methodTwo "); 
       return true; 
   } 
 
   public static boolean methodThree() { 
       System.out.println("methodThree "); 
       return true; 
   } 
 
   public static void main(String[] args){ 
       System.out.println(Test.methodOne() || Test.methodTwo() || Test.methodThree()); 
   } 
}
Ваши ответы
methodOne
methodTwo
true
Объяснение:

Феномен "ускоренного вычисления" при работе с логическими выражениями. methodThree не будет вызван, т.к. результат уже не зависит от него.
Строки "methodOne" и "methodTwo" выводятся при вычислении значения выражения, затем выводится само значение выражения - true.

Что напечатает следующий код?
public class Test { 
   { 
       System.out.println("Block"); 
   } 
   int x = getX(); 
 
   static { 
       System.out.println("Static block"); 
   } 
 
   public int getX() { 
       System.out.println("X variable"); 
       return 5; 
   } 
 
   static int y = getY(); 
   public static int getY() { 
       System.out.println("Y variable"); 
       return 6; 
   } 
 
 
   public static void main(String[] args) { 
       Test m = new Test(); 
   } 
}  
Ваши ответы
Static block
Y variable
Block
X variable
Объяснение:

Сначала выполняются блоки статической инициализации и инициализируются статические поля (в том порядке, в котором они записаны), поэтому срабатывают "Static block" и "Y variable".
Затем выполняются простые блоки инициализации и инициализируются не-статические поля (в том порядке, в котором они записаны), поэтому срабатывают "Block" и "X variable"

Что будет выведено в результате выполнения данного кода?
String x = "Java"; 
x.concat(" Rules!"); 
System.out.println("x = " + x);   
x.toUpperCase(); 
System.out.println("x = " + x);   
x.replace('a', 'X'); 
System.out.println("x = " + x);   
Ваши ответы
x = Java
x = Java
x = Java
Объяснение:

Объекты String являются неизменяемыми, и, следовательно, вызов любых методов на объекте String не изменит его.

В каком порядке должны размещаться следующие операторы?
Ваши ответы
1. Package statement
2. Imports
3. Class or interface definitions
Что будет напечатано в результате выполнения данного кода?
public class MathTest { 
 public static void main(String... args) { 
   System.out.println((-7 % 5) > (7 % -5)); 
   System.out.println(Math.abs(Math.ceil(-2.5)) < Math.ceil(Math.abs(-2.5))); 
 } 
} 
Ваши ответы
false
true
Объяснение:

Знак остатка, возвращаемого оператором %, совпадает со знаком делимого. Поэтому
-7 % 5 = -2
7 % -5 = 2
и первое неравенство возвращает false.
Метод ceil() округляет в большую сторону. Поэтому
Math.ceil(-2.5) = -2, Math.abs(-2) = 2
Math.abs(-2.5) = 2.5, Math.ceil(2.5) = 3
и второе неравенство возвращает true.

Назовите дизассемблер Java, который входит в стандартную поставку JDK.
Ваши ответы
javap
Даны два примера кода. Что произойдёт при их исполнении. Пример №1:
public class Main { 
   public static void main(String[] args) { 
       new Thread(){ 
           { this.setDaemon(true); } 
 
           public void run() { 
               while(true) { 
                   System.out.println("Thread is running!"); 
               } 
           } 
       }.start(); 
   } 
} 
 
Пример №2:
public class Main { 
   public static void main(String[] args) { 
       new Thread() { 
 
           public void run() { 
               while(true) { 
                   System.out.println("Thread is running!"); 
               } 
           } 
       }.start(); 
   } 
} 
Ваши ответы
Поток создаваемый в примере №1 закончит свою работу с окончанием работы основного потока приложения. Поток создаваемый в примере №2 вызовет зацикливание.
Объяснение:

В примере №1 создаваемый поток имеет тип Daemon, это означает что он будет остановлен как только завершатся все пользовательские потоки приложения. В примере №2 поток не является "демоном" и будет выполняться до тех пор, пока не завершится его метод run(). А конструкция while(true) в методе run() приведёт к его зацикливанию.

Что будет выведено следующей программой?
public class Main { 
 { 
   System.out.print("1 "); 
 } 
 
 Main(){ 
   System.out.print("2 "); 
 } 
 
 public static void main(String[] args) { 
   System.out.print("3 "); 
   Main m = new Main(); 
   System.out.print("4 "); 
 } 
 
 static { 
   System.out.print("5 "); 
 } 
} 
Ваши ответы
5 3 1 2 4
Объяснение:

Первым инициализируется статический блок, далее управление передается main, вызывается конструктор и доинициализирует класс, вызывается функция внутри конструктора, окончание работы.

Что будет напечатано в результате компиляции и выполнения данного кода?
public class TestClass { 
   public static void main(String[] args) { 
       Base sub = new Sub(); 
       sub.test(); 
   } 
} 
 
class Base { 
   public static void test() { 
       System.out.println("Base.test()"); 
   } 
} 
 
class Sub extends Base { 
   public static void test() { 
       System.out.println("Sub.test()"); 
   } 
} 
Ваши ответы
Base.test()
Объяснение:

Для вызова статических методов используется механизм раннего связывания, при котором вызываемый метод определяется исходя из типа переменной-ссылки, а не из фактического типа присвоенного объекта.

Что выведется в консоль в результате компиляции и выполнения следующего кода:
public class A { 
   { 
       System.out.println("one"); 
   } 
 
   public static void main(String[] args) { 
       System.out.println("two"); 
   } 
 
   static { 
       System.out.println("three"); 
   } 
} 
Ваши ответы
three
two
Объяснение:

Статические блоки инициализации выполняются перед первым обращением к классу, т.е. перед вызовом метода main(). Поэтому сначала будет выведена строка "three", а затем "two".
Обычные блоки инициализации выполняются при создании экземпляра заданного класса, но в данном примере этого нет. Поэтому строка "one" выведена не будет.

Что выведет следующий код?
public class test { 
   static { 
       System.out.println("Bo-Bo!"); 
   } 
 
   public static void main(String[] args) { 
       System.out.println("Hello, World!"); 
   } 
 
   static { 
       System.out.println("Go-Go!"); 
       System.exit(0); 
   }  
} 
Ваши ответы
Bo-Bo!
Go-Go!
Какой будет результат компиляции и выполнения следующего кода?
public class Test { 
   public static void main(String[] args) { 
       for (final int i : new int[] { 1, 2, 3 }) { 
           System.out.println(i + 1); 
       } 
   } 
} 
Ваши ответы
Ошибка компиляции
Объяснение:

Этот цикл for разворачивается компилятором в примерно такую конструкцию: