Какое значение по умолчанию имеет переменная boolean?

# Значение boolean по умолчанию в Java

Краткий ответ

Значение boolean по умолчанию = false

Контекст: примитив vs объект

Важно различать два типа boolean:

1. Примитивный тип boolean

public class DefaultBooleanExample {
    // На уровне класса
    private boolean flag;  // Default: false
    static boolean globalFlag;  // Default: false
    
    public static void main(String[] args) {
        // На уровне метода (локальная переменная)
        boolean localFlag;  // НЕ инициализирована, нельзя использовать
        // System.out.println(localFlag);  // Ошибка компиляции!
    }
}

public class DefaultBooleanTest {
    private boolean flag;
    
    public static void main(String[] args) {
        DefaultBooleanTest test = new DefaultBooleanTest();
        System.out.println(test.flag);  // false
    }
}

// Вывод: false

Правило:

• Поле класса boolean → инициализируется false
• Локальная переменная boolean → НЕ инициализируется, нужна явная инициализация

2. Объектная обёртка Boolean

public class BooleanObjectExample {
    // Объектная обёртка
    private Boolean flag;  // Default: null
    
    public static void main(String[] args) {
        BooleanObjectExample test = new BooleanObjectExample();
        System.out.println(test.flag);  // null
        
        // Автобоксинг
        Boolean boxedTrue = true;   // new Boolean(true)
        Boolean boxedFalse = false; // new Boolean(false)
        Boolean boxedNull = null;   // null
    }
}

// Вывод: null

Подробный разбор

Примитив boolean в разных контекстах

public class BooleanDefaults {
    
    // 1. Поле экземпляра
    private boolean instanceField;  // false
    
    // 2. Статическое поле
    static boolean staticField;     // false
    
    // 3. Поле в интерфейсе (всегда static)
    interface MyInterface {
        boolean CONSTANT = false;  // false
    }
    
    public void demonstrateDefaults() {
        // 4. Параметр метода (нет "по умолчанию", передаётся явно)
        printBoolean(true);  // должны передать
        printBoolean(false);
        
        // 5. Возвращаемое значение (нет default)
        boolean result = getFlag();  // должны вернуть true или false
    }
    
    private void printBoolean(boolean flag) {}
    private boolean getFlag() { return false; }
    
    public static void main(String[] args) {
        BooleanDefaults test = new BooleanDefaults();
        System.out.println("Instance field: " + test.instanceField);  // false
        System.out.println("Static field: " + staticField);           // false
    }
}

// Вывод:
// Instance field: false
// Static field: false

Логика значения false

Почему именно false?

// Логический смысл:
// false = "ничего не активировано", "не инициализировано", "отрицание"
// true  = "что-то активировано", "да", "истина"

// Примеры:
public class FeatureFlags {
    private boolean isEnabled = false;      // "выключено" по умолчанию
    private boolean isActive = false;       // "неактивно" по умолчанию
    private boolean hasPermission = false;  // "нет прав" по умолчанию
    
    // Принцип безопасности: "deny by default"
    // Лучше задать явно true, чем забыть и получить уязвимость
}

Массивы boolean

public class BooleanArrayExample {
    public static void main(String[] args) {
        // Все элементы массива инициализируются false
        boolean[] flags = new boolean[5];
        
        for (int i = 0; i < flags.length; i++) {
            System.out.println("flags[" + i + "] = " + flags[i]);  // false
        }
    }
}

// Вывод:
// flags[0] = false
// flags[1] = false
// flags[2] = false
// flags[3] = false
// flags[4] = false

Таблица значений по умолчанию всех типов

public class DefaultValues {
    // Примитивные типы
    private byte byteField;        // 0
    private short shortField;      // 0
    private int intField;          // 0
    private long longField;        // 0L
    private float floatField;      // 0.0f
    private double doubleField;    // 0.0d
    private boolean booleanField;  // false ← ВОТ
    private char charField;        // '\u0000' (null character)
    
    // Объектные типы
    private String stringField;    // null
    private Object objectField;    // null
    private Boolean booleanObj;    // null
    private Integer integerObj;    // null
    
    public static void main(String[] args) {
        DefaultValues test = new DefaultValues();
        System.out.println("boolean: " + test.booleanField);      // false
        System.out.println("Boolean: " + test.booleanObj);        // null
        System.out.println("int: " + test.intField);              // 0
        System.out.println("String: " + test.stringField);        // null
    }
}

Частые ошибки

Ошибка 1: Забыть инициализировать локальную переменную

public void incorrectExample() {
    boolean flag;  // НЕ инициализирована
    
    // ❌ Ошибка компиляции!
    if (flag) {    // "Variable 'flag' might not have been initialized"
        System.out.println("Flag is true");
    }
}

public void correctExample() {
    boolean flag = false;  // ✅ Инициализирована
    
    if (flag) {
        System.out.println("Flag is true");
    }
}

Ошибка 2: Путать Boolean и boolean

public void nullPointerExample() {
    Boolean flag = null;  // Может быть null
    
    // ❌ NullPointerException
    if (flag) {  // Автоунбоксинг null → NullPointerException
        System.out.println("Flag is true");
    }
}

public void safeExample() {
    Boolean flag = null;
    
    // ✅ Безопасно
    if (Boolean.TRUE.equals(flag)) {
        System.out.println("Flag is true");
    }
}

Ошибка 3: Неправильное сравнение

public void comparisonExample() {
    boolean flag1 = false;
    boolean flag2 = false;
    
    // ✅ Правильно
    if (flag1 == flag2) {  // true
        System.out.println("Both false");
    }
    
    Boolean obj1 = false;
    Boolean obj2 = false;
    
    // ❌ Осторожно с объектами
    if (obj1 == obj2) {  // Может быть false (разные объекты)
        System.out.println("Objects equal");
    }
    
    // ✅ Правильно для объектов
    if (obj1.equals(obj2)) {  // true
        System.out.println("Objects equal");
    }
}

Практические примеры

Пример 1: Флаги конфигурации

public class Configuration {
    private boolean debugMode = false;           // По умолчанию выключен
    private boolean useCache = false;            // По умолчанию нет
    private boolean enableLogging = false;       // По умолчанию нет
    
    public Configuration() {
        // Инициализация из переменных окружения
        String debug = System.getenv("DEBUG_MODE");
        if ("true".equalsIgnoreCase(debug)) {
            this.debugMode = true;
        }
    }
}

Пример 2: Состояния объекта

public class User {
    private String name;
    private boolean isActive = false;    // По умолчанию неактивен
    private boolean isVerified = false;  // По умолчанию не верифицирован
    private boolean isPremium = false;   // По умолчанию не премиум
    
    public void activate() {
        this.isActive = true;
    }
    
    public void verify() {
        this.isVerified = true;
    }
    
    public void upgradeToPremium() {
        this.isPremium = true;
    }
}

Пример 3: Условная логика

public class PaymentProcessor {
    private boolean transactionSucceeded = false;  // По умолчанию не успешна
    
    public void processPayment(Payment payment) {
        try {
            // Попытка обработать платёж
            callPaymentGateway(payment);
            transactionSucceeded = true;  // Только если успешно
        } catch (PaymentException e) {
            transactionSucceeded = false;  // Остаётся false
            logger.error("Payment failed", e);
        }
    }
    
    public boolean isSuccessful() {
        return transactionSucceeded;
    }
}

Пример 4: Фильтрация с boolean флагами

public class UserFilter {
    private boolean filterActiveOnly = false;   // По умолчанию нет фильтра
    private boolean filterVerifiedOnly = false; // По умолчанию нет фильтра
    
    public List<User> filter(List<User> users) {
        return users.stream()
            .filter(u -> !filterActiveOnly || u.isActive())
            .filter(u -> !filterVerifiedOnly || u.isVerified())
            .collect(Collectors.toList());
    }
    
    public void setFilterActiveOnly(boolean active) {
        this.filterActiveOnly = active;
    }
}

Резюме

Главное: примитив boolean всегда инициализируется false, а объект Boolean инициализируется null. Локальные переменные требуют явной инициализации.