Java 10 – local variable type inference

Jedną z najważniejszych nowości w nadchodzącej Java 10 będzie wprowadzenie local variable type inference – automatycznego wnioskowania typów zmiennych lokalnych. Ta funkcjonalność, dostępna przez słowo kluczowe var, może znacznie uprościć pisanie kodu Java.

Dlaczego to ważne?

Dotychczas w Javie musieliśmy zawsze jawnie deklarować typ każdej zmiennej. To często prowadziło do powtarzania się informacji – szczególnie gdy typ był oczywisty z kontekstu. Java 10 pozwala kompilatorowi samemu wywnioskować typ, co czyni kod bardziej czytelnym i łatwiejszym w utrzymaniu.

Czym jest local variable type inference?

Local variable type inference to mechanizm pozwalający kompilatorowi automatycznie określić typ zmiennej lokalnej na podstawie przypisanej jej wartości. W praktyce oznacza to, że zamiast pisać:

// Tradycyjna deklaracja
String name = "John";
List<String> names = new ArrayList<>();
Map<String, Integer> scores = new HashMap<>();

Możemy napisać krócej:

// Z var w Java 10
var name = "John";
var names = new ArrayList<String>();
var scores = new HashMap<String, Integer>();

Podstawowe użycie var

Najprościej var sprawuje się w oczywistych przypadkach:

public class VarExamples {
    public static void main(String[] args) {
        // Proste typy
        var number = 42;           // int
        var text = "Hello";        // String
        var flag = true;           // boolean
        var price = 19.99;         // double
        
        // Kolekcje
        var list = List.of("a", "b", "c");
        var set = Set.of(1, 2, 3);
        
        // Obiekty
        var date = new Date();
        var builder = new StringBuilder();
        
        System.out.println("Liczba: " + number);
        System.out.println("Lista: " + list);
    }
}

Kiedy var jest szczególnie przydatny?

Długie nazwy typów generycznych

Największą zaletę var widać przy skomplikowanych typach generycznych:

// Bez var - długi i powtarzający się kod
Map<String, List<Map<String, Object>>> complexData = 
    new HashMap<String, List<Map<String, Object>>>();

// Z var - znacznie czytelniej
var complexData = new HashMap<String, List<Map<String, Object>>>();

Iterowanie po kolekcjach

var users = List.of("John", "Jane", "Bob");

// Zamiast: for(String user : users)
for(var user : users) {
    System.out.println("User: " + user);
}

Stream API

W pracy ze Streamami var także się sprawdza:

var result = names.stream()
    .filter(name -> name.startsWith("J"))
    .collect(Collectors.toList());

Ograniczenia var

Tylko zmienne lokalne

var działa wyłącznie dla zmiennych lokalnych. Nie można używać go dla:

public class Example {
    // ❌ Nie można - pola klasy
    // var field = "test";
    
    // ❌ Nie można - parametry metod
    // public void method(var param) { }
    
    // ❌ Nie można - typ zwracany
    // public var getResult() { return "result"; }
    
    public void localMethod() {
        // ✅ OK - zmienne lokalne
        var localVar = "działa!";
    }
}

Inicjalizacja wymagana

Kompilator musi być w stanie wywnioskować typ, więc inicjalizacja jest obowiązkowa:

// ❌ Błąd kompilacji - brak inicjalizacji
// var uninitializedVar;

// ❌ Błąd kompilacji - null nie ma typu
// var nullVar = null;

// ✅ OK - typ jasny z inicjalizacji
var initialized = "Hello World";

Najlepsze praktyki

Kiedy używać var

// ✅ Dobry przykład - typ oczywisty
var users = new ArrayList<User>();
var config = ConfigurationBuilder.create();
var message = "Welcome " + userName;

// ✅ Dobry przykład - długie typy generyczne
var customerOrders = new HashMap<Customer, List<Order>>();

Kiedy NIE używać var

// ❌ Zły przykład - typ niejasny
var result = calculate();  // Co to zwraca?
var data = process();      // Jaki typ ma data?

// ❌ Zły przykład - sprawia, że kod jest mniej czytelny
var x = getValue();        // x to co?
var temp = method1().method2().method3();  // Za długo

var vs języki dynamiczne

Ważne jest zrozumienie, że Java z var wciąż jest językiem statycznie typowanym:

var number = 42;
// number = "text"; // ❌ Błąd! Typ już został ustalony jako int

// W przeciwieństwie do JavaScript:
// var number = 42;
// number = "text"; // ✅ OK w JS - zmienna może zmienić typ

Przykład praktyczny

Zobaczmy jak var sprawdza się w prawdziwym kodzie:

public class UserService {
    
    public void processUsers() {
        // Wczytaj dane użytkowników
        var users = loadUsersFromDatabase();
        
        // Przefiltruj aktywnych użytkowników
        var activeUsers = users.stream()
            .filter(User::isActive)
            .collect(Collectors.toList());
        
        // Grupuj według ról
        var usersByRole = activeUsers.stream()
            .collect(Collectors.groupingBy(User::getRole));
        
        // Przetwórz każdą grupę
        for(var entry : usersByRole.entrySet()) {
            var role = entry.getKey();
            var roleUsers = entry.getValue();
            
            System.out.println("Rola: " + role + ", użytkowników: " + roleUsers.size());
        }
    }
    
    private List<User> loadUsersFromDatabase() {
        // Implementacja wczytywania z bazy
        return List.of(
            new User("John", "ADMIN", true),
            new User("Jane", "USER", true),
            new User("Bob", "USER", false)
        );
    }
}

Przydatne zasoby:

• JEP 286: Local-Variable Type Inference
• Dokumentacja Java 10 (Oracle)
• Pobierz Java 10

Jak planujesz wykorzystać var w swoich projektach? Podziel się swoimi doświadczeniami w komentarzach!