Что такое отладка кода?

Отладка кода

Отладка кода (debugging) — это процесс выявления, локализации и исправления ошибок (bagов) в программе. Это критичный навык для разработчика, который позволяет быстро находить причины неправильного поведения приложения и устранять проблемы.

Типы ошибок

1. Syntax Errors — ошибки синтаксиса (выявляются на этапе компиляции)

int x = 5  // ❌ Отсутствует точка с запятой
System.out.println(x)

1. Runtime Errors — ошибки, которые происходят во время выполнения

int[] array = new int[5];
System.out.println(array[10]);  // ❌ ArrayIndexOutOfBoundsException

String str = null;
str.length();  // ❌ NullPointerException

1. Logic Errors — логические ошибки, которые не вызывают исключений

public int calculateTotal(int price, int quantity) {
    return price * quantity;  // ❌ Забыли учесть налог!
}

Инструменты отладки

1. System.out.println() — простейший способ

public class SimpleDebug {
    public static void main(String[] args) {
        int result = 0;
        for (int i = 1; i <= 5; i++) {
            result += i;
            System.out.println("i = " + i + ", result = " + result);  // Отладка
        }
    }
}

// Вывод:
// i = 1, result = 1
// i = 2, result = 3
// i = 3, result = 6
// i = 4, result = 10
// i = 5, result = 15

2. Logger (SLF4J + Logback)

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class UserService {
    private static final Logger log = LoggerFactory.getLogger(UserService.class);
    
    public User createUser(String email, String password) {
        log.debug("Creating user with email: {}", email);
        
        if (email == null || email.isEmpty()) {
            log.warn("Email is empty for user creation");
            throw new IllegalArgumentException("Email cannot be empty");
        }
        
        try {
            User user = new User(email, password);
            log.info("User created successfully with id: {}", user.getId());
            return user;
        } catch (Exception e) {
            log.error("Failed to create user", e);
            throw e;
        }
    }
}

3. Debugger IDE (IntelliJ IDEA, Eclipse)

public class DebuggerExample {
    public static void main(String[] args) {
        // Установи breakpoint на строке ниже (Ctrl+F8 в IntelliJ)
        int x = 10;
        int y = 20;
        int sum = calculateSum(x, y);  // Breakpoint здесь
        System.out.println("Sum: " + sum);
    }
    
    static int calculateSum(int a, int b) {
        return a + b;  // Шаг в функцию (Step Into)
    }
}

Возможности Debugger:

• Breakpoints — остановка выполнения на конкретной строке
• Step Over — выполнение строки и переход на следующую
• Step Into — вход в функцию
• Step Out — выход из функции
• Watch — отслеживание значения переменной
• Evaluate — выполнение кода во время остановки

Частые ошибки и их диагностика

1. NullPointerException

// ❌ Проблема
User user = getUserById(123);
String email = user.getEmail();  // ❌ NPE если user == null

// ✅ Решение
User user = getUserById(123);
if (user != null) {
    String email = user.getEmail();
} else {
    log.warn("User not found");
}

// ✅ Или использовать Optional
Optional<User> user = getUserByIdOptional(123);
user.ifPresent(u -> log.info("User: {}", u.getEmail()));

2. IndexOutOfBoundsException

// ❌ Проблема
List<String> names = Arrays.asList("Alice", "Bob");
String thirdName = names.get(2);  // ❌ Index 2 не существует (только 0, 1)

// ✅ Решение
if (names.size() > 2) {
    String thirdName = names.get(2);
}

// ✅ Или использовать Stream
String thirdName = names.stream()
    .skip(2)
    .findFirst()
    .orElse(null);

3. ConcurrentModificationException

// ❌ Проблема
List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
for (Integer num : numbers) {
    if (num == 3) {
        numbers.remove((Integer) 3);  // ❌ Ошибка!
    }
}

// ✅ Решение 1: использовать Iterator
List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Iterator<Integer> iterator = numbers.iterator();
while (iterator.hasNext()) {
    Integer num = iterator.next();
    if (num == 3) {
        iterator.remove();  // ✅ Правильное удаление
    }
}

// ✅ Решение 2: использовать removeIf
numbers.removeIf(num -> num == 3);

Exception Handling

public class ExceptionHandling {
    private static final Logger log = LoggerFactory.getLogger(ExceptionHandling.class);
    
    public void processUser(User user) {
        try {
            // Код, который может выбросить исключение
            validateUser(user);
            saveUser(user);
            log.info("User processed successfully");
        } catch (IllegalArgumentException e) {
            // Специфичное исключение
            log.warn("Validation error: {}", e.getMessage());
            // Обработка или пробросить дальше
        } catch (IOException e) {
            // Другое исключение
            log.error("IO error while saving user", e);
        } catch (Exception e) {
            // Общий catch (в конце)
            log.error("Unexpected error", e);
        } finally {
            // Код, который выполняется в любом случае
            log.debug("Processing finished");
        }
    }
    
    private void validateUser(User user) throws IllegalArgumentException {
        if (user == null) {
            throw new IllegalArgumentException("User cannot be null");
        }
    }
    
    private void saveUser(User user) throws IOException {
        // Сохранение
    }
}

Stack Trace — анализ ошибок

public class StackTraceExample {
    public static void main(String[] args) {
        divide(10, 0);  // Вызовет исключение
    }
    
    static void divide(int a, int b) {
        System.out.println(a / b);  // ArithmeticException: / by zero
    }
}

// Stack Trace:
// Exception in thread "main" java.lang.ArithmeticException: / by zero
//     at StackTraceExample.divide(StackTraceExample.java:8)
//     at StackTraceExample.main(StackTraceExample.java:5)

// Как читать:
// 1. Тип исключения: ArithmeticException
// 2. Сообщение: / by zero
// 3. Место: StackTraceExample.java строка 8
// 4. Вызов из: main() строка 5

Assertions для отладки

public class AssertionExample {
    public int divide(int a, int b) {
        assert b != 0 : "Divisor cannot be zero";  // Проверка в режиме отладки
        return a / b;
    }
    
    public static void main(String[] args) {
        // Запуск с assertions: java -ea AssertionExample
        AssertionExample calc = new AssertionExample();
        System.out.println(calc.divide(10, 2));
        System.out.println(calc.divide(10, 0));  // AssertionError
    }
}

Стратегии отладки

1. Воспроизведи ошибку — найди точные шаги для повторения проблемы
2. Изолируй проблему — сузь область поиска
3. Выдвигай гипотезы — какая часть кода может быть виновата?
4. Проверяй переменные — используй debugger или log для отслеживания значений
5. Разбей на части — используй divide-and-conquer approach

Best Practices отладки

// ❌ Плохо: оставить debug code в production
public void saveUser(User user) {
    System.out.println("DEBUG: user = " + user);
    // ... код
}

// ✅ Хорошо: использовать proper logging
public void saveUser(User user) {
    log.debug("Saving user: {}", user);
    // ... код
}

// ✅ Очень хорошо: использовать логирование с уровнями
log.trace("Entering saveUser");
log.debug("User data: {}", user);
log.info("User saved successfully");
log.warn("Unusual condition occurred");
log.error("Error saving user", exception);

Инструменты для отладки

• IDE Debugger — встроенный в IntelliJ IDEA, Eclipse
• JVM Debugger — jdb (Java Debugger)
• Profilers — YourKit, JProfiler (для анализа производительности)
• Memory Analyzers — для поиска memory leaks
• Log Aggregation — ELK Stack, Splunk (для анализа логов в production)
• APM Tools — New Relic, Datadog (для мониторинга приложения)

Отладка многопоточных приложений

public class ThreadDebug {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("[" + Thread.currentThread().getName() + "] i = " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    log.error("Thread interrupted", e);
                }
            }
        });
        
        thread.setName("Worker-1");  // Понятное имя потока
        thread.start();
    }
}

Отладка — это критичный навык, который отличает опытных разработчиков. Хороший отладчик может быстро и эффективно находить даже самые сложные баги.