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.