☕ Вопросы интервью по Java

Ответ: Fail-Fast и Fail-Safe - это два типа итераторов в Java коллекциях. Они отличаются в том, как ведут себя при модификации коллекции во время итерации.

Выбрасывает ConcurrentModificationException если коллекция модифицируется после создания итератора (кроме вызова remove() самого итератора).

• Выбрасывает ConcurrentModificationException при структурной модификации
• Работает напрямую с оригинальной коллекцией
• Используется ArrayList, HashMap, HashSet

HashMap<Integer, String> map = new HashMap<>();
map.put(1, "one");
map.put(2, "two");

Iterator<Integer> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
    Integer key = iterator.next();
    // Выбросит ConcurrentModificationException
    if (key == 1) {
        map.remove(1);
    }
}
                

Работает с копией (снимком) коллекции вместо оригинала. Модификации не влияют на итерацию.

• Не выбрасывает ConcurrentModificationException
• Итерирует клонированную копию коллекции
• Используется CopyOnWriteArrayList, ConcurrentHashMap

ConcurrentHashMap<Integer, String> map = new ConcurrentHashMap<>();
map.put(1, "one");
map.put(2, "two");

Iterator<Integer> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
    Integer key = iterator.next();
    // Не выбросит исключение
    if (key == 1) {
        map.remove(1);
    }
}
                

Ответ: Exception Handling - это механизм в Java для обработки ошибок и непредвиденных ситуаций, которые прерывают нормальный ход выполнения программы.

• Сбой оборудования (Device failure)
• Потеря сетевого соединения (Loss of Network Connection)
• Ошибки в коде (Code Errors)
• Открытие недоступного файла (Opening an Unavailable file)
• Некорректный ввод пользователя (Invalid User Input)
• Физические ограничения (Physical Limitations - out of disk memory)

try {
    // Код который может выбросить исключение
    int result = 10 / 0;
} catch (ArithmeticException e) {
    // Обработка исключения
    System.out.println("Ошибка: " + e.getMessage());
} finally {
    // Выполняется всегда
    System.out.println("Очистка ресурсов");
}
                

Ответ: Существует два основных типа исключений в Java:

Встроенные исключения предоставляются библиотеками Java и делятся на две категории:

• Checked Exceptions (Проверяемые):
  • IOException
  • FileNotFoundException
  • SQLException
  • ClassNotFoundException
• Unchecked Exceptions (Непроверяемые):
  • NullPointerException
  • ArrayIndexOutOfBoundsException
  • ArithmeticException
  • ClassCastException

Пользовательские исключения определяются программистами для обработки специфических ситуаций, не покрытых встроенными исключениями. Создаются расширением подходящего класса исключения:

// Пользовательское исключение
class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

// Использование
try {
    int age = 10;
    if (age < 18) {
        throw new InvalidAgeException("Возраст должен быть >= 18");
    }
} catch (InvalidAgeException e) {
    System.out.println(e.getMessage());
}
                

Ответ: Error и Exception - это два разных типа проблем в Java, но они часто путаются:

• StackOverflowError - переполнение стека (бесконечная рекурсия)
• OutOfMemoryError - недостаточно памяти
• VirtualMachineError - ошибка JVM
• LinkageError - ошибка связывания классов

• NullPointerException - обращение к null
• IOException - ошибка ввода/вывода
• SQLException - ошибка базы данных
• FileNotFoundException - файл не найден

Error: Не обрабатывайте Error в вашем коде. Это системные ошибки, которые указывают на критические проблемы в JVM или окружении.

Exception: Обрабатывайте исключения в своем коде с помощью try-catch или throws.

Ответ: Иерархия исключений Java - это структура классов, которая организует все исключения и ошибки под классом Throwable. Она помогает Java классифицировать и обрабатывать различные типы проблем во время выполнения эффективно.

• Throwable - это корневой класс иерархии исключений
• Он имеет два основных подкласса: Exception и Error
• Exception включает проверяемые и непроверяемые исключения (RuntimeException и его подклассы)

// Checked Exception - должен быть обработан
try {
    FileInputStream fis = new FileInputStream("file.txt");
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

// Unchecked Exception - может быть обработан или нет
try {
    int[] arr = new int[5];
    System.out.println(arr[10]);  // ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index out of bounds");
}

// Error - не обрабатывается
// StackOverflowError произойдет при бесконечной рекурсии
                

Ответ: Runtime Exceptions - это исключения, которые возникают во время выполнения программы и не проверяются компилятором. Они обычно результат ошибок программирования или неправильной логики.

• Являются подклассами RuntimeException
• Не требуют явной обработки с помощью try-catch или объявления с помощью throws
• Возникают из-за ошибок в коде программиста
• Проверяются только во время выполнения, а не при компиляции

// RuntimeException - не требует обработки, но может быть обработано
public class RuntimeExceptionExample {
    public static void main(String[] args) {
        // NullPointerException
        try {
            String str = null;
            System.out.println(str.length());  // Выбросит NPE
        } catch (NullPointerException e) {
            System.out.println("NullPointerException caught!");
        }
        
        // ArithmeticException
        try {
            int result = 10 / 0;  // Выбросит ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero!");
        }
        
        // ArrayIndexOutOfBoundsException
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[10]);  // Выбросит ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index out of bounds!");
        }
    }
}
                

Ответ: NullPointerException - это тип runtime исключения, которое выбрасывается, когда программа пытается использовать ссылку на объект, которая имеет значение null.

• При обращении к методу null объекта
• При обращении к полю null объекта
• При получении длины null массива
• При обращении к элементу null массива
• При выбросе null исключения

Основное назначение NullPointerException - указать, что никакое значение не присвоено переменной ссылки. Также оно используется для реализации структур данных, таких как связные списки и деревья.

// Пример 1: Обращение к методу null объекта
String str = null;
System.out.println(str.length());  // NullPointerException

// Пример 2: Обращение к полю null объекта
class Person {
    public String name;
}
Person person = null;
System.out.println(person.name);  // NullPointerException

// Пример 3: Синхронизация на null объекте
Object obj = null;
synchronized(obj) {  // NullPointerException
    // код
}

// Пример 4: Throw null исключения
try {
    throw null;  // NullPointerException
} catch (Exception e) {
    e.printStackTrace();
}
                

// 1. Проверка перед использованием
String str = null;
if (str != null) {
    System.out.println(str.length());
}

// 2. Использование Optional (Java 8+)
Optional<String> optional = Optional.ofNullable(str);
optional.ifPresent(s -> System.out.println(s.length()));

// 3. Инициализация значением по умолчанию
String str = "default";

// 4. Использование Objects.requireNonNull()
import java.util.Objects;
String str = Objects.requireNonNull(inputStr, "String cannot be null");
                

Ответ: ArrayStoreException выбрасывается, когда предпринимается попытка сохранить неправильный тип объекта в массиве объектов.

• При попытке сохранить объект несовместимого типа в типизированном массиве
• Это runtime исключение (подкласс RuntimeException)
• Возникает только при работе с массивами объектов, а не примитивных типов

// Java программа для демонстрации ArrayStoreException
public class GFG {
    public static void main(String args[])
    {
        // Поскольку Double класс расширяет Number класс
        // только значения типа Double
        // могут быть сохранены в этом массиве
        Number[] a = new Double[2];
        
        // Попытка сохранить значение Integer
        // в этом массиве типа Double
        try {
            a[0] = new Integer(4);
        } catch (ArrayStoreException e) {
            System.out.println("ArrayStoreException caught!");
            System.out.println("Cannot store Integer in Double array");
        }
    }
}
                

ArrayStoreException caught!
Cannot store Integer in Double array
                

• Убедитесь, что тип сохраняемого объекта совместим с типом массива
• Используйте Generics (List<Double> вместо массива) для типобезопасности на этапе компиляции
• Проверяйте тип перед сохранением: if (obj instanceof Double) { a[0] = (Double) obj; }
• Используйте Generics Lists вместо массивов когда возможно: List<Double> list = new ArrayList<>();

Ответ: Checked и Unchecked Exceptions отличаются в том, как компилятор их обрабатывает. Checked исключения проверяются во время компиляции, а unchecked исключения возникают во время выполнения.

Checked Exceptions:

• Должны быть обработаны в try-catch блоке
• Или объявлены в методе с помощью throws
• Обычно связаны с внешними ресурсами (файлы, сеть, база данных)
• Компилятор выдаст ошибку, если они не обработаны

Unchecked Exceptions:

• Не требуют явной обработки или объявления
• Возникают из-за ошибок в коде программиста
• Можно обработать, но это не обязательно
• Компилятор не требует их обработки

// Checked Exception - ОБЯЗАТЕЛЬНО обработать
import java.io.*;

public class CheckedExceptionExample {
    public static void main(String[] args) {
        // FileNotFoundException - это Checked Exception
        // Компилятор требует обработки
        try {
            FileInputStream fis = new FileInputStream("file.txt");
        } catch (FileNotFoundException e) {
            System.out.println("File not found!");
            e.printStackTrace();
        }
    }
    
    // ИЛИ объявить в методе
    public static void readFile() throws FileNotFoundException {
        FileInputStream fis = new FileInputStream("file.txt");
    }
}
                

// Unchecked Exception - ОПЦИОНАЛЬНО обработать
public class UncheckedExceptionExample {
    public static void main(String[] args) {
        // NullPointerException - это Unchecked Exception
        // Компилятор НЕ требует обработки, но можно обработать
        
        // Вариант 1: Без обработки (компилятор согласен)
        String str = null;
        // System.out.println(str.length());  // Выбросит NPE
        
        // Вариант 2: С обработкой (опционально)
        try {
            System.out.println(str.length());
        } catch (NullPointerException e) {
            System.out.println("String is null!");
        }
    }
}
                

Checked Exception: Используйте когда код может выбросить исключение из-за внешних факторов, которые вне контроля программы.

Unchecked Exception: Используйте когда исключение результат ошибки в коде, которую можно предотвратить проверками.

Ответ: Базовым классом для Error и Exception является java.lang.Throwable.

• Error: Незаконная операция, выполняемая пользователем, которая вызывает ненормальность в программе. Error возникает из-за проблем с JVM, которые мы не можем контролировать.
• Exception: Непредвиденные события или условия, которые возникают при выполнении программы. Exception нарушает нормальный ход выполнения инструкций программы.

java.lang.Throwable - это суперкласс всех ошибок и исключений в иерархии исключений Java. Он содержит общие методы для обработки исключений:

// Методы Throwable класса
public String getMessage()              // Возвращает сообщение об ошибке
public void printStackTrace()            // Выводит trace ошибки
public String toString()                // Возвращает строковое представление
public Throwable getCause()             // Возвращает причину исключения
public StackTraceElement[] getStackTrace() // Возвращает stack trace
                

public class ThrowableExample {
    public static void main(String[] args) {
        try {
            // Может выбросить Exception
            int result = 10 / 0;
        } catch (Throwable t) {  // Catching Throwable (родитель Exception)
            System.out.println("Caught: " + t.getClass().getName());
            t.printStackTrace();
            System.out.println("Message: " + t.getMessage());
        }
    }
}

// Вывод:
// Caught: java.lang.ArithmeticException
// java.lang.ArithmeticException: / by zero
// Message: / by zero
                

• Throwable
  • Exception - Можем обработать
    • Checked Exception (IOException, SQLException)
    • RuntimeException (NullPointerException, ArithmeticException)
  • Error - Не можем обработать
    • VirtualMachineError
    • LinkageError
    • AssertionError