romegames 1
romegames
Reklam vermek için turkmmo@gmail.com

Java Generics: Tip Güvenli Sınıf ve Metot Yapıları

image453b6030abaaadf7.jpg


Generics Kullanım Amacı

Generic yapılar, tip güvenliğini bozmadan bir kodu farklı veri tipleriyle tekrar tekrar kullanmanıza imkan tanır. Her veri tipi için ayrı ayrı IntBox, StringBox veya UserBox sınıfları oluşturmak yerine; T şeklinde bir yer tutucu kullanarak tek bir Box<T> sınıfı tanımlayabilirsiniz.

Aslında ArrayList<String> veya HashMap<String, Integer> gibi yapılar kullandığınızda zaten generics özelliğinden faydalanmış oluyorsunuz. Buradaki <...> ifadesi tip argümanını temsil eder. Bu ders kapsamında, kendi generic yapılarınızı nasıl kurgulayacağınızı öğreneceksiniz.

Alternatif bir yol olan her şeyi Object olarak saklama yöntemi, tip bilgisinin kaybolmasına yol açar ve hata yapmaya müsait, karmaşık tip dönüşümleri gerektirir:

Java:
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);
    }
}

Yukarıdaki örneğin son satırında gerçekleşen tip dönüşümü, çalışma zamanında ClassCastException hatasına neden olur. Generics yapısı, tam olarak bu tarz hataları engellemek amacıyla geliştirilmiştir.

Generic Sınıf Tanımlama

Generic bir sınıf oluştururken, sınıf isminin hemen ardından açılı ayraçlar içerisinde bir tip parametresi belirlenir. Genel kabul görmüş standartlara göre "type" (tip) için T, "element" (eleman) için E, anahtar ve değer çiftleri için ise K ve V harfleri kullanılır.

Java:
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 sınıfındaki her T ifadesi, sınıf çağrılırken belirtilen tip ile değiştirilir. Örneğin Box<String> yapısı, sadece String veri tipiyle çalışan bir kutu haline gelir. Bu sayede derleyici, kodu çalıştırdığınızda hata almanız yerine name.set(99) gibi hatalı kullanımları daha derleme aşamasında reddeder.

Kodda görülen boş <> (elmas operatörü), derleyicinin tip argümanını otomatik olarak anlamasını sağlar; böylece aynı tip ismini defalarca yazmanıza gerek kalmaz.

Generic Metotlar

Sınıfın genelinden bağımsız olarak, tek bir metodun kendi tip parametresine sahip olması mümkündür. Bunun için <T> parametresi, metodun dönüş tipinden önce tanımlanmalıdır:

Java:
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);
    }
}

Bu yapıda T tipini açıkça belirtmenize gerek yoktur; derleyici bunu iletilen argümana bakarak kendisi belirler. Generic metotlar; Collections.sort veya List.of gibi yardımcı araçların, farklı veri tipleriyle tip güvenli bir şekilde çalışmasını sağlayan yöntemlerdir.

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

Bazı durumlarda generic bir tipin sadece belirli sınıflar veya alt sınıflar için geçerli olması istenir. extends anahtar kelimesi kullanılarak parametre sınırlandırılabilir ve böylece belirlenen sınırın metodları kullanılabilir. Örneğin T extends Number ifadesi, T'nin Number sınıfı veya ondan türemiş bir alt sınıf (Integer, Double vb.) olması gerektiğini belirtir; bu sayede doubleValue() metodu çağrılabilir:

Java:
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 ifadesinin "bir alt tipidir" anlamına geldiğini ve hem sınıflar hem de arayüzler için geçerli olduğunu unutmayın. Özellikle elemanların karşılaştırılması gereken senaryolarda <T extends Comparable<T>> kullanımı oldukça yaygındır.

Joker Karakterler: ? extends ve ? super

Önemli bir detay: Integer sınıfı Number sınıfından türemiş olsa da, List<Integer> bir List<Number> değildir. Generics yapısı değişmezdir (invariant). Joker karakterler, yalnızca okuma veya yalnızca yazma yapılması gereken durumlarda bu katılığı esnetir.

Veri okunan üreticiler (producer) için ? extends T, veri yazılan tüketiciler (consumer) için ise ? super T kullanılır (PECS kuralı: Producer Extends, Consumer Super):

Java:
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);
    }
}

? extends Number olarak tanımlanan bir listedeki elemanlar Number olarak okunabilir ancak listeye yeni eleman eklenemez (çünkü derleyici gerçek tipi kesin olarak bilemez). Öte yandan ? super Integer olarak tanımlanan bir listeye Integer eklemek mümkündür, ancak okuma işlemi yapıldığında veriler Object olarak döner. Veri akışının yönüne göre uygun joker karakteri seçmelisiniz.

Tip Silme (Type Erasure) ve Kısıtlamalar

Generics, temel olarak derleme zamanında çalışan bir özelliktir. Derleme işlemi tamamlandığında tip parametreleri silinir; yani çalışma zamanında Box<String> ve Box<Integer> yapıları sadece Box olarak görülür. Bu durum, generics özelliğinin eski Java versiyonlarıyla uyumlu çalışmasını sağlar ancak bazı sınırlamaları beraberinde getirir.

Java:
// 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 bilgisi çalışma zamanında yok olduğu için reflection yöntemiyle "T hangi tipti?" şeklinde bir sorgulama yapılamaz. Ayrıca, sadece generic argümanları farklı olan metotlar aşırı yüklenemez (örneğin foo(List<String>) ve foo(List<Integer>) metotları derleme sonrası aynı imzaya sahip olur). Eğer çalışma zamanında tip bilgisine gerçekten ihtiyaç duyuyorsanız, yapıcı metoda veya metot parametresine bir Class<T> belirteci ekleyebilirsiniz.

Sıradaki Konu: Lambda İfadeleri

Generic metotların parametre olarak bir tip alabildiğini gördük. Bir sonraki adımda, davranışların parametre olarak nasıl aktarılacağını inceleyeceğiz. Lambda ifadeleri, bir fonksiyonu veya kod parçacığını metoda iletmenizi sağlar. Bu yöntem, öğrendiğiniz tip güvenli generic koleksiyonları filtrelemek, sıralamak ve dönüştürmek için kullanılan temel yoldur.
 

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Geri
Üst