Как инициализировать переменную

Инициализация переменных в Java

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

1. Локальные переменные

Обязательно инициализируй перед использованием:

// НЕПРАВИЛЬНО — использование до инициализации
int count;
System.out.println(count); // Ошибка компиляции!

// ПРАВИЛЬНО — явная инициализация
int count = 0;
int sum = count + 10;

// При объявлении
String name = "John";
double price = 99.99;
boolean isActive = true;

Локальные переменные НЕ получают значения по умолчанию — компилятор их отслеживает.

2. Переменные класса (static fields)

Получают значения по умолчанию автоматически:

public class Config {
    static int port;           // 0
    static String apiKey;      // null
    static boolean debug;      // false
    static double timeout;     // 0.0
    static List<?> items;      // null
    
    // Явная инициализация
    static int maxRetries = 3;
    static String VERSION = "1.0.0";
    
    // Статический блок — для сложной инициализации
    static {
        apiKey = System.getenv("API_KEY");
        if (apiKey == null) {
            apiKey = "default-key";
        }
    }
}

3. Переменные объекта (instance fields)

Также инициализируются по умолчанию, но лучше быть явным:

public class User {
    private String name;           // null
    private int age;               // 0
    private boolean isActive;      // false
    private List<String> roles;    // null
    
    // Явная инициализация в объявлении
    private String email = "";
    private List<String> permissions = new ArrayList<>();
    private Map<String, String> metadata = new HashMap<>();
    
    public User(String name) {
        this.name = name;
        this.email = name + "@example.com";
    }
    
    // Инициализирующий блок (выполняется ДО конструктора)
    {
        System.out.println("Object created");
        roles = new ArrayList<>();
    }
}

4. Безопасная инициализация

Для многопоточного кода используй volatile и final:

public class AppConfig {
    // Ленивая инициализация с двойной проверкой (Double-Checked Locking)
    private static volatile Database database;
    
    public static Database getDatabase() {
        if (database == null) {
            synchronized (AppConfig.class) {
                if (database == null) {
                    database = new Database();
                }
            }
        }
        return database;
    }
    
    // Более безопасно — использование static inner class (Bill Pugh Singleton)
    private static class DatabaseHolder {
        static final Database INSTANCE = new Database();
    }
    
    public static Database getDatabaseSafe() {
        return DatabaseHolder.INSTANCE;
    }
}

5. Инициализация коллекций

// Пустые коллекции
List<String> emptyList = new ArrayList<>();
Set<Integer> emptySet = new HashSet<>();
Map<String, String> emptyMap = new HashMap<>();

// С начальными данными (Java 9+)
List<String> langs = List.of("Java", "Kotlin", "Go"); // Неизменяемая
Set<String> tags = Set.of("backend", "database"); // Неизменяемая
Map<String, Integer> scores = Map.of("Alice", 95, "Bob", 87);

// Изменяемая инициализация (Java 8 и ранее)
List<String> mutableList = new ArrayList<>(List.of("a", "b", "c"));

// Double brace initialization (не рекомендуется, создаёт анонимный класс)
List<String> items = new ArrayList<String>() {{
    add("item1");
    add("item2");
}};

6. Инициализация массивов

// Примитивные типы (автоматически нулевые значения)
int[] numbers = new int[5];        // [0, 0, 0, 0, 0]
boolean[] flags = new boolean[3];  // [false, false, false]

// Объектные типы (null)
String[] names = new String[3];    // [null, null, null]

// С инициализацией
int[] sequence = {1, 2, 3, 4, 5};
String[] colors = {"red", "green", "blue"};
Object[] mixed = {1, "two", 3.0, true};

// Многомерные
int[][] matrix = new int[3][3];
int[][] triangular = {
    {1},
    {2, 3},
    {4, 5, 6}
};

7. Инициализация с помощью конструкторов и setters

public class Product {
    private String name;
    private double price;
    private int stock;
    
    // Конструктор
    public Product(String name, double price) {
        this.name = name;
        this.price = price;
        this.stock = 0; // Явная инициализация
    }
    
    // Builder Pattern — удобнее для многих параметров
    public static class Builder {
        private String name;
        private double price = 0.0;
        private int stock = 0;
        
        public Builder name(String name) {
            this.name = name;
            return this;
        }
        
        public Builder price(double price) {
            this.price = price;
            return this;
        }
        
        public Product build() {
            return new Product(this);
        }
    }
    
    private Product(Builder builder) {
        this.name = builder.name;
        this.price = builder.price;
        this.stock = builder.stock;
    }
}

// Использование
Product product = new Product.Builder()
    .name("Laptop")
    .price(999.99)
    .build();

Правила инициализации (порядок выполнения):

1. Статические переменные → Статические блоки
2. Переменные объекта → Инициализирующие блоки
3. Конструктор

Это важно для понимания lifecycle'а объекта в Java.