🚀 BAŞTAN SONA JAVA DİLİ BÖLÜM-18: Lambda Expressions, Functional Interfaces ve Metot Referansları ⚡

🚀 BAŞTAN SONA JAVA DİLİ BÖLÜM-18: Lambda Expressions, Functional Interfaces ve Metot Referansları ⚡

Selamlar! Serimizin 18. bölümüne hoş geldiniz.

Önceki bölümde `Generics` yapısını, tip güvenliğini, Bounded Types sınırlamalarını ve Wildcard (`?`) kullanımını detaylarıyla incelemiştik. Bu bölümde ise Java 8 ile birlikte dile dahil olan ve modern Java geliştirme tarzını tamamen değiştiren **Lambda Expressions (Lambda İfadeleri)**, **Fonksiyonel Arayüzleri (Functional Interfaces)** ve **Metot Referanslarını (Method References)** öğreneceğiz.

---

📌 1. Lambda Expression Nedir? ⚡

Lambda ifadesi; isimsiz (anonymous), bir sınıfa ait olmak zorunda kalmadan parametre alıp değer döndürebilen **isimsiz bir fonksiyondur**.

Java'yı nesne odaklı hantal yapıdan kurtarıp **Fonksiyonel Programlama (Functional Programming)** paradigmasına yaklaştırmıştır.

### Sözdizimi (Syntax):
`(parametreler) -> { çalışacak kod bloğu }`

Ok Operatörü (`->`): Parametre listesi ile fonksiyon gövdesini birbirine bağlar.

---

🏗️ 2. Fonksiyonel Arayüz (Functional Interface) 🏛️

Bir Lambda ifadesinin kullanılabilmesi için hedefte bir **Fonksiyonel Arayüz** bulunmalıdır.

Fonksiyonel Arayüz: İçerisinde **yalnızca TEK BİR soyut (abstract) metot** barındıran arayüzlerdir.
Anlam karmaşasını önlemek için sınıflara `@FunctionalInterface` anotasyonu eklenir.

### Anonim Sınıf vs Lambda İfadesi Karşılaştırması:

@FunctionalInterface
interface MatematikIslemi {
int islem(int a, int b);
}

public class Main {
public static void main(String[] args) {
// YÖNTEM 1: Java 8 Öncesi Anonim Sınıf (Hantal Yapı)
MatematikIslemi eskiToplama = new MatematikIslemi() {
@Override
public int islem(int a, int b) {
return a + b;
}
};

// YÖNTEM 2: Java 8+ Lambda İfadesi (Tek Satır!)
MatematikIslemi yeniToplama = (a, b) -> a + b;
MatematikIslemi carpma = (a, b) -> a * b;

System.out.println("Toplama Sonucu: " + yeniToplama.islem(10, 20)); // 30
System.out.println("Çarpma Sonucu : " + carpma.islem(5, 4)); // 20
}
}

---

🧩 3. Hazır Fonksiyonel Arayüzler (`java.util.function`) 🧰

Java 8, en sık ihtiyaç duyulan fonksiyonel kalıplar için paket içinde hazır arayüzler sunar:

### A. `Predicate<T>` (Koşul Testi)
Bir `T` değeri alır, geriye `boolean` döndürür. Metodu: `boolean test(T t)`

import java.util.function.Predicate;

public class Main {
public static void main(String[] args) {
Predicate<Integer> ciftMi = sayi -> sayi % 2 == 0;

System.out.println("8 Çift Mi?: " + ciftMi.test(8)); // true
System.out.println("7 Çift Mi?: " + ciftMi.test(7)); // false
}
}

### B. `Consumer<T>` (Veri Tüketici)
Bir `T` değeri alır, işlem yapar fakat geriye bir şey **döndürmez (`void`)**. Metodu: `void accept(T t)`

import java.util.function.Consumer;

public class Main {
public static void main(String[] args) {
Consumer<String> yazdir = mesaj -> System.out.println("LOG: " + mesaj);
yazdir.accept("Kullanıcı giriş yaptı.");
}
}

### C. `Supplier<T>` (Veri Sağlayıcı)
Parametre **almaz**, geriye `T` tipinde bir değer üretip döndürür. Metodu: `T get()`

import java.util.function.Supplier;

public class Main {
public static void main(String[] args) {
Supplier<Double> rastgeleSayi = () -> Math.random();
System.out.println("Rastgele Sayı: " + rastgeleSayi.get());
}
}

### D. `Function<T, R>` (Dönüştürücü)
`T` tipinde bir girdi alır, işler ve geriye `R` tipinde bir çıktı döner. Metodu: `R apply(T t)`

import java.util.function.Function;

public class Main {
public static void main(String[] args) {
// String veriyi alıp karakter uzunluğunu (Integer) dönen fonksiyon
Function<String, Integer> uzunlukHesapla = metin -> metin.length();
System.out.println("Uzunluk: " + uzunlukHesapla.apply("Java Dili")); // 9
}
}

---

🔗 4. Metot Referansları (Method References) `::` 📍

Metot Referansı, var olan bir metodu Lambda ifadesi yerine doğrudan çağırmak için kullanılan ve sözdizimini daha da kısaltan `::` operatörüdür.

Eğer bir Lambda ifadesi sadece mevcut bir metodu tetikliyorsa, Lambda yerine Metot Referansı yazılır.

### 4 Farklı Metot Referansı Türü:

import java.util.Arrays;
import java.util.List;

public class Main {
public static void main(String[] args) {
List<String> isimler = Arrays.asList("Ahmet", "Ayşe", "Mehmet");

// 1. Lambda İfadesi İle:
isimler.forEach(isim -> System.out.println(isim));

// 2. Metot Referansı İle (`Class::staticMethod` veya `instance::method`):
isimler.forEach(System.out:rintln);
}
}

---

📝 Bölüm Özeti ve Gelecek Bölüm 🔮

Bu bölümde Lambda İfadelerini, Fonksiyonel Arayüzleri (`Predicate`, `Consumer`, `Supplier`, `Function`) ve Metot Referansı (`::`) kullanımını öğrendik.

👉 **Bölüm 19'da Bizi Ne Bekliyor?**
• Modern Java'nın Gücü: **Stream API** 🌊
• Koleksiyonlar Üzerinde Filtreleme (`filter`), Dönüştürme (`map`) ve Sıralama (`sorted`)
• Terminal Operatörler (`collect`, `forEach`, `red
uce`, `count`)
• Parallel Streams İle Performans Artışı

Sorularınızı konu altından iletebilirsiniz. Bir sonraki bölümde görüşmek üzere! ☕✨

🔒 Bu içeriği görmek için giriş yapın

Giriş Yap Forum Kayıt Ol Telegram Grubumuza Katıl