1// Ornek1: Anonim sınıf — bir arayüzü/abstract sınıfı isim vermeden, ANINDA uygulamak.
2// Çalıştırma: java Ornek1.java
3import java.util.ArrayList;
4import java.util.Comparator;
5import java.util.List;
6
7public class Ornek1 {
8
9    interface Selamlayici { String selamla(String ad); }
10
11    abstract static class Hayvan {
12        abstract String ses();
13        void tanit() { System.out.println("Bu hayvan: " + ses()); }
14    }
15
16    public static void main(String[] args) {
17        // 1) Bir arayüzü anonim sınıfla uygula (tek kullanımlık).
18        Selamlayici resmi = new Selamlayici() {
19            @Override public String selamla(String ad) { return "Sayın " + ad + ", hoş geldiniz."; }
20        };
21        System.out.println(resmi.selamla("Ada"));
22
23        // 2) Bir abstract sınıfı anonim sınıfla uzat (lambda BUNU yapamaz; sınıf gerekir).
24        Hayvan kopek = new Hayvan() {
25            @Override String ses() { return "Hav hav"; }
26        };
27        kopek.tanit();
28
29        // 3) Comparator'ı anonim sınıfla (klasik kullanım).
30        List<String> sehirler = new ArrayList<>(List.of("İzmir", "Ankara", "Adana"));
31        sehirler.sort(new Comparator<String>() {
32            @Override public int compare(String a, String b) { return a.compareTo(b); }
33        });
34        System.out.println("Sıralı: " + sehirler);
35
36        System.out.println("""
37
38                --- Anonim sınıf ---
39                İsmi olmayan, BİR KEZ kullanılacak bir sınıfı tanımladığın yerde oluşturursun.
40                'new Tip() { ... }' söz dizimi: arayüzü uygular VEYA sınıfı uzatır + nesneyi yaratır.
41                Tek soyut metotlu arayüzlerde genelde LAMBDA daha kısadır (sonraki örnek);
42                ama abstract SINIF uzatmak veya birden çok metot gerektiğinde anonim sınıf şarttır.""");
43    }
44}

1// Ornek2: Anonim sınıf vs lambda — ne zaman hangisi?
2// Çalıştırma: java Ornek2.java
3import java.util.function.Function;
4
5public class Ornek2 {
6
7    public static void main(String[] args) {
8        // Tek soyut metotlu (functional) arayüz: anonim sınıf VE lambda ile yazılabilir.
9
10        // a) Anonim sınıf (uzun)
11        Function<Integer, Integer> kareAnonim = new Function<Integer, Integer>() {
12            @Override public Integer apply(Integer x) { return x * x; }
13        };
14
15        // b) Lambda (aynı şey, kısa) — functional interface'lerde TERCİH EDİLEN.
16        Function<Integer, Integer> kareLambda = x -> x * x;
17
18        System.out.println("anonim: " + kareAnonim.apply(5) + ", lambda: " + kareLambda.apply(5));
19
20        // 'this' farkı:
21        // - Anonim sınıfta 'this' ANONİM nesneyi gösterir.
22        // - Lambda'da 'this' ÇEVRELEYEN nesneyi gösterir (lambda ayrı bir kapsam açmaz).
23        new Ornek2().thisFarki();
24
25        System.out.println("""
26
27                --- Anonim sınıf mı, lambda mı? ---
28                LAMBDA kullan (kısa, okunaklı) eğer:
29                  - hedef TEK soyut metotlu bir functional interface ise.
30                ANONİM SINIF kullan eğer:
31                  - bir ABSTRACT SINIFI uzatman gerekiyorsa, VEYA
32                  - birden çok metot/ek alan (durum) gerekiyorsa, VEYA
33                  - 'this' anonim nesneyi göstermeli ise.
34                Tarihsel olarak anonim sınıflar yaygındı; Java 8 lambda'larla çoğu yerde sadeleşti.""");
35    }
36
37    void thisFarki() {
38        Runnable r = () -> System.out.println("\nlambda içindeki this -> çevreleyen sınıf: "
39                + this.getClass().getSimpleName());
40        r.run();
41    }
42}