Java Generics: Tip Güvenli Sınıflar ve Metotlar

Generics Neden Var

Generic bir tip, kodu bir kez yazıp tip güvenliğinden ödün vermeden birçok tip için yeniden kullanmanı sağlar. Ayrı ayrı bir IntBox, bir StringBox ve bir UserBox yazmak yerine, T'nin çağıranın doldurduğu bir yer tutucu olduğu tek bir Box<T> yazarsın.

Aslında her ArrayList<String> ya da HashMap<String, Integer> yazdığında generics kullandın. <...> kısmı bir tip argümanıdır. Bu sayfa kendi generic tiplerini nasıl yazacağını gösteriyor.

Alternatif - her şeyi Object olarak saklamak - tip bilgisini çöpe atar ve çirkin, hataya açık tip dönüşümlerini zorunlu kılar:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Object> raw = new ArrayList<>();
        raw.add("hello");
        raw.add(42);                       // bu hatayı hiçbir şey engellemez

        String first = (String) raw.get(0); // her okuma bir tip dönüşümü gerektirir
        String oops = (String) raw.get(1);  // derlenir, sonra çalışma zamanında çöker
        System.out.println(first + " " + oops);
    }
}

Son satırdaki o tip dönüşümü çalışma zamanında bir ClassCastException fırlatır - tam da generics'in imkansız kılmak için tasarlandığı türden bir hata.

Generic Bir Sınıf

Sınıf adından sonra açılı parantezler içinde bir tip parametresi tanımla. Geleneksel olarak tek bir büyük harf kullanılır: "type" (tip) için T, "element" (eleman) için E, anahtar/değer için K/V.

class Box<T> {
    private T value;

    Box(T value) { this.value = value; }

    T get() { return value; }
    void set(T value) { this.value = value; }
}

public class Main {
    public static void main(String[] args) {
        Box<String> name = new Box<>("Coddy");
        Box<Integer> count = new Box<>(3);

        String s = name.get();     // tip dönüşümü yok - derleyici bunun bir String olduğunu bilir
        int n = count.get();
        System.out.println(s + " x" + n);

        // name.set(99); // derlenmez - Box<String> yalnızca String kabul eder
    }
}

Box içinde her T, çağıranın sağladığı her ne ise ona dönüşür. Box<String> yalnızca String tutan ve döndüren bir kutudur. Derleyici, program daha çalışmadan name.set(99)'u reddeder.

Sağdaki boş <> (yani elmas operatörü) derleyicinin tip argümanını taraftan çıkarsamasını sağlar, böylece <String>'i iki kez tekrarlamazsın.

Generic Metotlar

Tek bir metot, sınıftan bağımsız olarak kendi tip parametresine sahip olabilir. <T> parametresini dönüş tipinden önce koy:

import java.util.List;

public class Main {

    // <T> tip parametresini tanımlar; T eleman tipidir
    static <T> T firstOrNull(List<T> items) {
        return items.isEmpty() ? null : items.get(0);
    }

    public static void main(String[] args) {
        List<String> words = List.of("alpha", "beta");
        List<Integer> nums = List.of(10, 20, 30);

        String w = firstOrNull(words);   // T, String olarak çıkarsanır
        Integer n = firstOrNull(nums);   // T, Integer olarak çıkarsanır
        System.out.println(w + " " + n);
    }
}

T'yi asla açıkça geçmezsin - derleyici onu argümandan çıkarsar. Generic metotlar, Collections.sort ya da List.of gibi yardımcı araçların herhangi bir eleman tipinde tip güvenli kalmasının yoludur.

Sınırlandırılmış Tip Parametreleri

Bazen generic bir tip yalnızca bazı tipler için anlamlıdır. extends parametreyi kısıtlar, böylece sınırın metotlarını çağırabilirsin. Burada T extends Number, T'nin Number ya da herhangi bir alt sınıf (Integer, Double, ...) olduğu anlamına gelir, dolayısıyla doubleValue() kullanılabilir:

import java.util.List;

public class Main {

    static <T extends Number> double sum(List<T> numbers) {
        double total = 0;
        for (T n : numbers) {
            total += n.doubleValue();   // geçerli çünkü T en azından bir Number
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(List.of(1, 2, 3)));        // Integers
        System.out.println(sum(List.of(1.5, 2.5)));       // Doubles
    }
}

Buradaki extends'in "bir alt tipidir" anlamına geldiğine ve hem sınıflar hem de arayüzler için çalıştığına dikkat et - elemanları karşılaştırman gerektiğinde <T extends Comparable<T>> son derece yaygındır.

Joker Karakterler: ? extends ve ? super

İnce bir tuzak: Integer bir Number olsa da, List<Integer> bir List<Number> değildir. Generics değişmezdir (invariant). Joker karakterler, yalnızca okuman ya da yalnızca yazman gerektiğinde bunu gevşetir.

Okuduğun bir üretici için ? extends T, yazdığın bir tüketici için ? super T kullan ("PECS" kuralı - Producer Extends, Consumer Super):

import java.util.ArrayList;
import java.util.List;

public class Main {

    // Number okur - List<Integer>, List<Double>, vb. kabul eder
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // Integer yazar - List<Integer>, List<Number>, List<Object> kabul eder
    static void addInts(List<? super Integer> dest) {
        dest.add(1);
        dest.add(2);
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        System.out.println(total(ints));      // ? extends sayesinde çalışır

        List<Number> bucket = new ArrayList<>();
        addInts(bucket);                       // ? super sayesinde çalışır
        System.out.println(bucket);
    }
}

Bir ? extends Number listesi elemanları Number olarak okumana izin verir ama ona ekleme yapmana izin vermez (derleyici tam eleman tipini bilemez). Bir ? super Integer listesi Integer eklemene izin verir ama okumalar Object olarak geri gelir. Verinin nasıl aktığına uyan joker karakteri seç.

Tip Silme ve Sınırları

Generics bir derleme zamanı özelliğidir. Derlemeden sonra tip parametresi silinir - çalışma zamanında Box<String> ve Box<Integer> ikisi de sadece Box'tır. Bu, generics'i eski kodla geriye dönük uyumlu tutar ama gerçek sınırlar getirir.

// Bunların hiçbiri derlenmez - tip parametresi çalışma zamanında var olmaz:
T value = new T();          // bir tip parametresi örneklenemez
T[] array = new T[10];      // generic bir dizi oluşturulamaz
if (list instanceof List<String>) { } // tip argümanı test edilemez

Tip çalışma zamanında yok olduğu için reflection aracılığıyla "T neydi?" diye soramazsın ve yalnızca generic argümanlarıyla ayrışan metotları aşırı yükleyemezsin (foo(List<String>) ve foo(List<Integer>) aynı imzaya silinir). Tipe gerçekten çalışma zamanında ihtiyacın olduğunda, bir Class<T> belirtecini yapıcı ya da metot parametresi olarak geç.

Sonraki: Lambda İfadeleri

Generic bir metodun parametre olarak bir tip aldığını gördün. Bir sonraki adım davranışı bir parametre olarak ele almaktır. Lambda ifadeleri bir kod parçasını - bir fonksiyonu - bir metoda geçirmeni sağlar; bu tam da yeni öğrendiğin tip güvenli generic koleksiyonları sıralamanın, filtrelemenin ve dönüştürmenin yoludur.