1import java.lang.annotation.ElementType;
2import java.lang.annotation.Repeatable;
3import java.lang.annotation.Retention;
4import java.lang.annotation.RetentionPolicy;
5import java.lang.annotation.Target;
6import java.util.ArrayList;
7import java.util.List;
8
9/**
10 * ============================================================================
11 *  REPEATABLE ANNOTATIONS ve TYPE ANNOTATIONS - Java 8
12 * ============================================================================
13 *
14 * 1) REPEATABLE ANNOTATIONS (Tekrarlanabilir Anotasyonlar)
15 *    NEDİR? Aynı anotasyonu aynı eleman üzerinde BİRDEN FAZLA kez kullanabilme.
16 *    NEDEN GELDİ? Java 8 öncesinde bir anotasyon bir elemana sadece BİR kez
17 *      konabilirdi. Birden fazla değer için elle bir "kapsayıcı (container)"
18 *      anotasyon dizisi yazmak gerekiyordu (örn: @Schedules({@Schedule(...),
19 *      @Schedule(...)})). Bu çirkin ve zahmetliydi. @Repeatable bunu temizler.
20 *
21 * 2) TYPE ANNOTATIONS (Tip Anotasyonları)
22 *    NEDİR? Anotasyonların artık SADECE bildirimlere değil, TİPİN KULLANILDIĞI
23 *      her yere konabilmesi (ElementType.TYPE_USE).
24 *    NEDEN GELDİ? Daha güçlü statik analiz / null güvenliği araçları (örn:
25 *      Checker Framework) için. Örn: @NonNull String, List<@NonNull String>.
26 */
27public class AnnotationOrnekleri {
28
29    public static void main(String[] args) throws Exception {
30
31        System.out.println("=== 1. REPEATABLE ANNOTATION ===\n");
32        // Gorev sinifindaki tekrarlanan @Zamanlama anotasyonlarini oku
33        Zamanlama[] zamanlamalar = Gorev.class.getAnnotationsByType(Zamanlama.class);
34        System.out.println("Gorev uzerindeki zamanlamalar:");
35        for (Zamanlama z : zamanlamalar) {
36            System.out.println("   gun=" + z.gun() + ", saat=" + z.saat());
37        }
38
39        System.out.println("\n=== 2. TYPE ANNOTATION (TYPE_USE) ===\n");
40        // @NotNull bir tip kullanımı üzerinde; çalışma zamanında özel bir etki
41        // yapmaz ama statik analiz araçları bunu okur. Burada sadece derlenip
42        // kod içinde kullanılabildiğini gösteriyoruz.
43        @NotNull String mesaj = "Bu deger null olmamali (statik analiz ipucu)";
44        List<@NotNull String> liste = new ArrayList<>();
45        liste.add("eleman1");
46        liste.add("eleman2");
47        System.out.println("TYPE_USE annotation ile tanimlanan deger: " + mesaj);
48        System.out.println("List<@NotNull String> icerigi: " + liste);
49
50        System.out.println("\n=== 3. GERÇEK HAYAT: Cron benzeri zamanlama ===\n");
51        // Tekrarlanabilir anotasyonlar, bir gorevin birden fazla calisma
52        // zamanini deklaratif olarak tanimlamak icin idealdir.
53        System.out.println("Rapor gorevi su zamanlarda calisacak:");
54        for (Zamanlama z : Gorev.class.getAnnotationsByType(Zamanlama.class)) {
55            System.out.println("   -> Her " + z.gun() + " gunu saat " + z.saat());
56        }
57    }
58
59    // --- Repeatable annotation tanımı ---
60    // @Repeatable, kapsayıcı (container) anotasyonu işaret eder.
61    @Repeatable(Zamanlamalar.class)
62    @Retention(RetentionPolicy.RUNTIME)
63    @Target(ElementType.TYPE)
64    @interface Zamanlama {
65        String gun();
66        String saat();
67    }
68
69    // Kapsayıcı (container) anotasyon - derleyici tekrarları buraya toplar
70    @Retention(RetentionPolicy.RUNTIME)
71    @Target(ElementType.TYPE)
72    @interface Zamanlamalar {
73        Zamanlama[] value();
74    }
75
76    // --- Type annotation tanımı (TYPE_USE) ---
77    @Retention(RetentionPolicy.RUNTIME)
78    @Target(ElementType.TYPE_USE)
79    @interface NotNull {
80    }
81
82    // Aynı anotasyonu birden fazla kez kullanıyoruz (Java 8 öncesi imkansızdı)
83    @Zamanlama(gun = "Pazartesi", saat = "09:00")
84    @Zamanlama(gun = "Carsamba", saat = "14:00")
85    @Zamanlama(gun = "Cuma", saat = "17:30")
86    static class Gorev {
87    }
88}

1import java.util.Arrays;
2import java.util.DoubleSummaryStatistics;
3import java.util.List;
4import java.util.Map;
5import java.util.TreeMap;
6import java.util.stream.Collectors;
7
8/**
9 * ============================================================================
10 *  COLLECTORS ve GRUPLAMA (groupingBy / partitioningBy / joining) - Java 8
11 * ============================================================================
12 *
13 * NEDİR?
14 *   Collectors, Stream'in collect() terminal işleminde kullanılan HAZIR
15 *   "toplayıcı reçeteleridir". Bir akışın elemanlarını listeye, kümeye,
16 *   haritaya (Map) toplamayı; gruplamayı; saymayı; ortalama almayı; metne
17 *   birleştirmeyi sağlar.
18 *
19 * NEDEN GELDİ?
20 *   Eskiden "ürünleri kategoriye göre grupla" gibi bir iş için elle Map
21 *   oluşturup, her eleman için "anahtar var mı, yoksa yeni liste aç" mantığını
22 *   tekrar tekrar yazmak gerekiyordu. Çok tekrar eden, hataya açık koddu.
23 *   Collectors bunları tek satırlık deklaratif ifadelere indirger.
24 *
25 * NE İŞE YARAR / NEREDE: Raporlama, istatistik, kategorize etme, özetleme.
26 *   Örn: departman bazlı maaş ortalaması, kategori bazlı stok, müşteri
27 *   segmentasyonu.
28 */
29public class CollectorsGruplama {
30
31    public static void main(String[] args) {
32
33        List<Calisan> calisanlar = Arrays.asList(
34                new Calisan("Ahmet", "Yazilim", 45000, 28),
35                new Calisan("Zeynep", "Yazilim", 62000, 35),
36                new Calisan("Mehmet", "Pazarlama", 38000, 41),
37                new Calisan("Ayse", "Pazarlama", 52000, 30),
38                new Calisan("Burak", "Finans", 71000, 45),
39                new Calisan("Elif", "Yazilim", 48000, 26));
40
41        System.out.println("=== 1. toList / toSet / toMap ===\n");
42        List<String> isimler = calisanlar.stream()
43                .map(c -> c.isim)
44                .collect(Collectors.toList());
45        System.out.println("Isimler (List): " + isimler);
46
47        // toMap: isim -> maas haritası
48        Map<String, Double> isimMaas = calisanlar.stream()
49                .collect(Collectors.toMap(c -> c.isim, c -> c.maas));
50        System.out.println("Isim->Maas (Map): " + isimMaas);
51
52        System.out.println("\n=== 2. groupingBy : Anahtara göre gruplama ===\n");
53        // ESKİ YÖNTEM elle Map yönetmek gerekirdi; YENİ tek satır:
54        Map<String, List<Calisan>> departmana = calisanlar.stream()
55                .collect(Collectors.groupingBy(c -> c.departman));
56        departmana.forEach((dep, liste) -> {
57            System.out.println(dep + ":");
58            liste.forEach(c -> System.out.println("   " + c.isim));
59        });
60
61        System.out.println("\n=== 3. groupingBy + counting : Grup sayıları ===\n");
62        Map<String, Long> departmanSayilari = calisanlar.stream()
63                .collect(Collectors.groupingBy(c -> c.departman, Collectors.counting()));
64        System.out.println("Departman bazli calisan sayisi: " + departmanSayilari);
65
66        System.out.println("\n=== 4. groupingBy + averagingDouble : Grup ortalaması ===\n");
67        Map<String, Double> departmanMaasOrt = calisanlar.stream()
68                .collect(Collectors.groupingBy(c -> c.departman,
69                        Collectors.averagingDouble(c -> c.maas)));
70        departmanMaasOrt.forEach((dep, ort) ->
71                System.out.printf("%-12s ortalama maas: %.2f TL%n", dep, ort));
72
73        System.out.println("\n=== 5. groupingBy + summingDouble / mapping ===\n");
74        // Departman bazlı toplam maaş
75        Map<String, Double> toplamMaas = calisanlar.stream()
76                .collect(Collectors.groupingBy(c -> c.departman,
77                        Collectors.summingDouble(c -> c.maas)));
78        System.out.println("Departman toplam maas: " + toplamMaas);
79
80        // groupingBy + mapping: departmana göre SADECE isimleri topla
81        Map<String, List<String>> departmanIsimleri = calisanlar.stream()
82                .collect(Collectors.groupingBy(c -> c.departman,
83                        Collectors.mapping(c -> c.isim, Collectors.toList())));
84        System.out.println("Departman isimleri: " + departmanIsimleri);
85
86        System.out.println("\n=== 6. partitioningBy : İkiye bölme (true/false) ===\n");
87        // Maaşı 50000'den yüksek olanlar / olmayanlar
88        Map<Boolean, List<Calisan>> bolme = calisanlar.stream()
89                .collect(Collectors.partitioningBy(c -> c.maas >= 50000));
90        System.out.println("Yuksek maaslilar (>=50000):");
91        bolme.get(true).forEach(c -> System.out.println("   " + c.isim + " - " + c.maas));
92        System.out.println("Dusuk maaslilar (<50000):");
93        bolme.get(false).forEach(c -> System.out.println("   " + c.isim + " - " + c.maas));
94
95        System.out.println("\n=== 7. joining : Metinleri birleştirme ===\n");
96        String tumIsimler = calisanlar.stream()
97                .map(c -> c.isim)
98                .collect(Collectors.joining(", ", "[", "]")); // ayirici, onek, sonek
99        System.out.println("Birlestirilmis: " + tumIsimler);
100
101        System.out.println("\n=== 8. summarizingDouble : Tek seferde istatistik ===\n");
102        DoubleSummaryStatistics maasIstatistik = calisanlar.stream()
103                .collect(Collectors.summarizingDouble(c -> c.maas));
104        System.out.println("Calisan sayisi : " + maasIstatistik.getCount());
105        System.out.println("Toplam maas    : " + maasIstatistik.getSum());
106        System.out.println("Ortalama       : " + maasIstatistik.getAverage());
107        System.out.println("En yuksek      : " + maasIstatistik.getMax());
108        System.out.println("En dusuk       : " + maasIstatistik.getMin());
109
110        System.out.println("\n=== 9. GERÇEK HAYAT: Çok seviyeli gruplama ===\n");
111        // Departman -> (40 yaş üstü mü?) -> isimler
112        Map<String, Map<Boolean, List<String>>> cokSeviyeli = calisanlar.stream()
113                .collect(Collectors.groupingBy(
114                        c -> c.departman,
115                        Collectors.groupingBy(
116                                c -> c.yas >= 40,
117                                Collectors.mapping(c -> c.isim, Collectors.toList()))));
118        cokSeviyeli.forEach((dep, yasMap) -> {
119            System.out.println(dep + ":");
120            System.out.println("   40+ : " + yasMap.getOrDefault(true, Arrays.asList()));
121            System.out.println("   <40 : " + yasMap.getOrDefault(false, Arrays.asList()));
122        });
123
124        System.out.println("\n=== 10. Sıralı grup (TreeMap supplier) ===\n");
125        // groupingBy ile harita tipini TreeMap olarak belirleyip alfabetik sirala
126        Map<String, Long> sirali = calisanlar.stream()
127                .collect(Collectors.groupingBy(c -> c.departman,
128                        TreeMap::new, Collectors.counting()));
129        System.out.println("Alfabetik sirali departmanlar: " + sirali);
130    }
131
132    static class Calisan {
133        String isim, departman;
134        double maas;
135        int yas;
136
137        Calisan(String isim, String departman, double maas, int yas) {
138            this.isim = isim;
139            this.departman = departman;
140            this.maas = maas;
141            this.yas = yas;
142        }
143    }
144}

1import java.util.Arrays;
2import java.util.List;
3import java.util.concurrent.CompletableFuture;
4import java.util.concurrent.ExecutionException;
5import java.util.concurrent.ExecutorService;
6import java.util.concurrent.Executors;
7import java.util.stream.Collectors;
8
9/**
10 * ============================================================================
11 *  CompletableFuture - ASENKRON PROGRAMLAMA - Java 8
12 * ============================================================================
13 *
14 * NEDİR?
15 *   CompletableFuture<T>, "ileride tamamlanacak bir hesabın sonucunu" temsil
16 *   eden bir sınıftır. Asenkron (eş zamanlı olmayan) işleri başlatır ve
17 *   sonuçlarını ZİNCİRLEYEREK (callback'lerle) işlemeyi sağlar.
18 *
19 * NEDEN GELDİ? (Eski Future'ın sorunları)
20 *   Java 5'teki java.util.concurrent.Future yetersizdi:
21 *     - Sonucu almak için get() ile BLOKLANMAK gerekiyordu (thread bekler).
22 *     - İki future'ı birleştirmek (combine) mümkün değildi.
23 *     - Tamamlandığında otomatik callback çalıştırılamıyordu.
24 *     - Hata yönetimi (exception handling) zincirleme yapılamıyordu.
25 *
26 *   CompletableFuture bunların hepsini çözer: bloklamadan, zincirleyerek,
27 *   hataları yöneterek asenkron akışlar kurarsın.
28 *
29 * NE İŞE YARAR: Web servis çağrıları, veritabanı sorguları, dosya okuma gibi
30 *   I/O ağırlıklı işleri paralel yürütüp sonuçları birleştirme.
31 *
32 * TEMEL METOTLAR:
33 *   supplyAsync  : asenkron başlat (değer üretir)
34 *   thenApply    : sonucu dönüştür (map gibi)
35 *   thenCompose  : başka bir future ile zincirle (flatMap gibi)
36 *   thenCombine  : iki future'ı birleştir
37 *   thenAccept   : sonucu tüket (Consumer)
38 *   exceptionally: hata olursa yedek değer
39 *   allOf/anyOf  : birden fazla future'ı bekle
40 */
41public class CompletableFutureOrnekleri {
42
43    public static void main(String[] args) throws Exception {
44
45        System.out.println("=== 1. supplyAsync + thenApply + thenAccept ===\n");
46        CompletableFuture<String> akis = CompletableFuture
47                .supplyAsync(() -> {
48                    uyut(300);
49                    return "ham veri";
50                })
51                .thenApply(veri -> veri.toUpperCase())     // dönüştür
52                .thenApply(veri -> "[islenmis] " + veri);  // tekrar dönüştür
53        // thenAccept ile sonucu tüket (geri dönüş yok)
54        akis.thenAccept(sonuc -> System.out.println("Sonuc: " + sonuc));
55        akis.join(); // demo için ana thread'in bitmesini beklet
56
57        System.out.println("\n=== 2. thenCombine : İki asenkron işi birleştir ===\n");
58        // Senaryo: Fiyat servisi ve vergi servisi paralel calisir, sonra toplanir
59        CompletableFuture<Double> fiyatF = CompletableFuture.supplyAsync(() -> {
60            uyut(200);
61            System.out.println("   Fiyat servisi tamam");
62            return 1000.0;
63        });
64        CompletableFuture<Double> vergiF = CompletableFuture.supplyAsync(() -> {
65            uyut(250);
66            System.out.println("   Vergi servisi tamam");
67            return 180.0;
68        });
69        CompletableFuture<Double> toplamF = fiyatF.thenCombine(vergiF,
70                (fiyat, vergi) -> fiyat + vergi);
71        System.out.println("Toplam (fiyat+vergi): " + toplamF.get() + " TL");
72
73        System.out.println("\n=== 3. thenCompose : Bağımlı asenkron zincir ===\n");
74        // Önce kullanıcı id'sini al, SONRA o id ile siparişleri çek (sıralı bağımlılık)
75        CompletableFuture<String> siparisler = kullaniciIdGetir("ahmet")
76                .thenCompose(id -> siparisleriGetir(id));
77        System.out.println(siparisler.get());
78
79        System.out.println("\n=== 4. exceptionally : Hata yönetimi ===\n");
80        CompletableFuture<Integer> hataliAkis = CompletableFuture
81                .<Integer>supplyAsync(() -> {
82                    throw new RuntimeException("Servis cokmesi!");
83                })
84                .exceptionally(ex -> {
85                    System.out.println("   Hata yakalandi: " + ex.getMessage());
86                    return -1; // yedek (fallback) deger
87                });
88        System.out.println("Hatadan sonra deger: " + hataliAkis.get());
89
90        System.out.println("\n=== 5. allOf : Birden fazla işi paralel bekle ===\n");
91        // 3 farklı servisi aynı anda çağır, hepsi bitince devam et
92        long baslangic = System.currentTimeMillis();
93        CompletableFuture<String> s1 = servisCagir("Servis-A", 300);
94        CompletableFuture<String> s2 = servisCagir("Servis-B", 200);
95        CompletableFuture<String> s3 = servisCagir("Servis-C", 400);
96
97        CompletableFuture<Void> hepsi = CompletableFuture.allOf(s1, s2, s3);
98        hepsi.join(); // hepsi bitene kadar bekle
99
100        // Sonuçları topla
101        List<String> sonuclar = Arrays.asList(s1, s2, s3).stream()
102                .map(CompletableFuture::join)
103                .collect(Collectors.toList());
104        long sure = System.currentTimeMillis() - baslangic;
105        System.out.println("Tum servisler tamam: " + sonuclar);
106        // 300+200+400=900ms degil; paralel oldugu icin ~400ms (en yavasi kadar)
107        System.out.println("Toplam sure (paralel): ~" + sure + " ms (sirali olsa ~900ms)");
108
109        System.out.println("\n=== 6. Özel ExecutorService ile ===\n");
110        ExecutorService havuz = Executors.newFixedThreadPool(2);
111        CompletableFuture<String> ozel = CompletableFuture.supplyAsync(() -> {
112            return "Ozel thread havuzunda calisti: " + Thread.currentThread().getName();
113        }, havuz);
114        System.out.println(ozel.get());
115        havuz.shutdown();
116    }
117
118    static CompletableFuture<String> kullaniciIdGetir(String kullaniciAdi) {
119        return CompletableFuture.supplyAsync(() -> {
120            uyut(150);
121            return "ID-" + kullaniciAdi.hashCode();
122        });
123    }
124
125    static CompletableFuture<String> siparisleriGetir(String id) {
126        return CompletableFuture.supplyAsync(() -> {
127            uyut(150);
128            return id + " icin siparisler: [S100, S101, S102]";
129        });
130    }
131
132    static CompletableFuture<String> servisCagir(String ad, int gecikme) {
133        return CompletableFuture.supplyAsync(() -> {
134            uyut(gecikme);
135            return ad + "(" + gecikme + "ms)";
136        });
137    }
138
139    static void uyut(long ms) {
140        try {
141            Thread.sleep(ms);
142        } catch (InterruptedException e) {
143            Thread.currentThread().interrupt();
144        }
145    }
146}

1/**
2 * ============================================================================
3 *  INTERFACE'LERDE DEFAULT ve STATIC METOTLAR - Java 8
4 * ============================================================================
5 *
6 * NEDİR?
7 *   Java 8 ile arayüzler (interface), gövdesi olan iki yeni metot türü
8 *   içerebilir:
9 *     - default metot : Bir varsayılan uygulama (implementation) sağlar.
10 *                       Uygulayan sınıflar override etmek zorunda DEĞİLDİR.
11 *     - static metot  : Arayüze bağlı yardımcı (utility) metot. Örnek üzerinden
12 *                       değil, arayüz adıyla çağrılır.
13 *
14 * NEDEN GELDİ? (Hangi problemi çözdü?)
15 *   "Interface Evolution" (arayüz evrimi) problemi: Bir arayüzü yayınladıktan
16 *   sonra yeni bir metot eklersen, o arayüzü uygulayan TÜM mevcut sınıflar
17 *   derlenemez hale gelirdi (her birine metodu eklemek gerekirdi). Bu, geriye
18 *   dönük uyumluluğu bozardı.
19 *
20 *   Asıl tetikleyici: Java 8'in Stream API'si. List, Collection gibi mevcut
21 *   arayüzlere forEach(), stream(), removeIf() gibi metotlar eklenmesi
22 *   gerekiyordu. Eğer bunlar normal (soyut) metot olsaydı, dünyadaki tüm
23 *   Collection uygulamaları bozulurdu. DEFAULT metotlar sayesinde bu metotlar
24 *   varsayılan gövdeyle eklendi ve hiçbir mevcut kod bozulmadı.
25 *
26 * NE İŞE YARAR: Kütüphane geliştiricilerine, mevcut kullanıcıları kırmadan
27 *   arayüzlere yeni yetenek ekleme imkânı verir.
28 */
29public class DefaultStaticMetotlar {
30
31    public static void main(String[] args) {
32
33        System.out.println("=== 1. default Metot: Varsayılan Uygulama ===\n");
34        Arac araba = new Araba();
35        araba.calistir();        // Araba'nin kendi (override) uygulamasi
36        araba.kornaCal();        // arayuzden gelen DEFAULT uygulama
37
38        Arac bisiklet = new Bisiklet();
39        bisiklet.calistir();
40        bisiklet.kornaCal();     // Bisiklet bunu OVERRIDE etti
41
42        System.out.println("\n=== 2. static Metot: Arayüz Yardımcısı ===\n");
43        // Arayüz adıyla çağrılır, örnek gerekmez
44        System.out.println(Arac.aracTipiAciklamasi());
45
46        System.out.println("\n=== 3. GERÇEK HAYAT: Ödeme yöntemleri ===\n");
47        OdemeYontemi krediKarti = new KrediKarti();
48        OdemeYontemi havale = new Havale();
49
50        krediKarti.ode(1000);
51        // logla() -> arayuzden gelen ortak default davranis (her ikisi de kullanir)
52        krediKarti.logla(1000);
53        havale.ode(500);
54        havale.logla(500);
55
56        // static metot: komisyon hesaplama yardımcısı
57        System.out.println("1000 TL icin standart komisyon: "
58                + OdemeYontemi.komisyonHesapla(1000) + " TL");
59
60        System.out.println("\n=== 4. Çoklu Kalıtım Çakışması (Diamond Problem) ===\n");
61        // A ve B arayüzlerinin ikisinde de aynı isimli default metot var.
62        // C sınıfı bunu çözmek için override etmek ZORUNDADIR (derleyici zorlar).
63        C c = new C();
64        c.selam();  // C'nin cozumledigi versiyon
65    }
66
67    /** default ve static metot içeren arayüz. */
68    interface Arac {
69        // Soyut metot (uygulayan sınıf MUTLAKA yazmalı)
70        void calistir();
71
72        // DEFAULT metot: gövdeli, override zorunlu değil
73        default void kornaCal() {
74            System.out.println("   Bip bip! (varsayilan korna)");
75        }
76
77        // STATIC metot: arayuz duzeyinde yardimci
78        static String aracTipiAciklamasi() {
79            return "Bu bir kara tasiti arayuzudur.";
80        }
81    }
82
83    static class Araba implements Arac {
84        @Override
85        public void calistir() {
86            System.out.println("Araba motoru calisti (vroom).");
87        }
88        // kornaCal override edilmedi -> default kullanilir
89    }
90
91    static class Bisiklet implements Arac {
92        @Override
93        public void calistir() {
94            System.out.println("Bisiklet pedallari donuyor.");
95        }
96        @Override
97        public void kornaCal() {
98            System.out.println("   Cling cling! (bisiklet zili - override)");
99        }
100    }
101
102    interface OdemeYontemi {
103        void ode(double tutar);
104
105        // Ortak loglama davranışı - tüm ödeme yöntemleri ücretsiz miras alır
106        default void logla(double tutar) {
107            System.out.println("   [LOG] " + tutar + " TL odeme kaydedildi.");
108        }
109
110        static double komisyonHesapla(double tutar) {
111            return tutar * 0.015; // %1.5 standart komisyon
112        }
113    }
114
115    static class KrediKarti implements OdemeYontemi {
116        @Override
117        public void ode(double tutar) {
118            System.out.println("Kredi karti ile " + tutar + " TL odendi.");
119        }
120    }
121
122    static class Havale implements OdemeYontemi {
123        @Override
124        public void ode(double tutar) {
125            System.out.println("Havale/EFT ile " + tutar + " TL gonderildi.");
126        }
127    }
128
129    // --- Diamond problem örneği ---
130    interface A {
131        default void selam() { System.out.println("A'dan selam"); }
132    }
133    interface B {
134        default void selam() { System.out.println("B'den selam"); }
135    }
136    // Hem A hem B'yi uygular; iki default metot çakışır -> override ZORUNLU
137    static class C implements A, B {
138        @Override
139        public void selam() {
140            A.super.selam(); // istersek belirli birini çağırabiliriz
141            B.super.selam();
142            System.out.println("C, cakismayi cozumledi.");
143        }
144    }
145}

1import java.util.Arrays;
2import java.util.List;
3import java.util.function.BiFunction;
4import java.util.function.BinaryOperator;
5import java.util.function.Consumer;
6import java.util.function.Function;
7import java.util.function.Predicate;
8import java.util.function.Supplier;
9import java.util.function.UnaryOperator;
10
11/**
12 * ============================================================================
13 *  FONKSİYONEL ARAYÜZLER (FUNCTIONAL INTERFACES) - Java 8
14 * ============================================================================
15 *
16 * NEDİR?
17 *   İçinde TEK BİR soyut metot bulunan arayüzdür (Single Abstract Method - SAM).
18 *   Lambda ifadeleri ve method reference'lar, ancak bir fonksiyonel arayüz
19 *   tipine atanabilir. Yani lambda'nın "tipi" daima bir fonksiyonel arayüzdür.
20 *
21 *   @FunctionalInterface anotasyonu derleyiciye "bu arayüzde tam olarak 1 soyut
22 *   metot olmalı" der; yanlışlıkla ikinci bir soyut metot eklenirse DERLEME
23 *   HATASI verir. (Zorunlu değildir ama tavsiye edilir.)
24 *
25 * NEDEN GELDİ?
26 *   Java zaten Runnable, Comparator, Callable gibi tek metotlu arayüzlere
27 *   sahipti ama her ihtiyaç için yeni arayüz tanımlamak zahmetliydi. Java 8,
28 *   java.util.function paketinde HAZIR, genel amaçlı fonksiyonel arayüzler
29 *   getirdi. Böylece kendi arayüzünü yazmadan davranış geçirebilirsin.
30 *
31 * EN ÇOK KULLANILANLAR:
32 *   - Function<T,R>      : T alır, R döndürür           (apply)
33 *   - Consumer<T>        : T alır, hiçbir şey döndürmez  (accept)
34 *   - Supplier<T>        : Parametre almaz, T üretir     (get)
35 *   - Predicate<T>       : T alır, boolean döndürür       (test)
36 *   - BiFunction<T,U,R>  : İki girdi (T,U), R döndürür    (apply)
37 *   - UnaryOperator<T>   : T alır, T döndürür             (Function özel hali)
38 *   - BinaryOperator<T>  : İki T alır, T döndürür         (BiFunction özel hali)
39 */
40public class FonksiyonelArayuzler {
41
42    public static void main(String[] args) {
43
44        System.out.println("=== 1. Function<T,R> : Dönüştürme ===\n");
45        // Bir String'i uzunluğuna dönüştür
46        Function<String, Integer> uzunluk = s -> s.length();
47        System.out.println("'Merhaba' uzunlugu: " + uzunluk.apply("Merhaba"));
48
49        // andThen / compose ile fonksiyon zincirleme
50        Function<Integer, Integer> ikiyleCarp = x -> x * 2;
51        Function<Integer, Integer> birEkle = x -> x + 1;
52        // önce çarp sonra ekle:  (5*2)+1 = 11
53        System.out.println("andThen (carp->ekle): " + ikiyleCarp.andThen(birEkle).apply(5));
54        // önce ekle sonra çarp:  (5+1)*2 = 12
55        System.out.println("compose (ekle->carp): " + ikiyleCarp.compose(birEkle).apply(5));
56
57        System.out.println("\n=== 2. Consumer<T> : Tüketme (yan etki) ===\n");
58        Consumer<String> yazdir = s -> System.out.println("Tuketildi: " + s);
59        yazdir.accept("Java 8");
60        // andThen ile iki consumer'ı sırayla çalıştır
61        Consumer<String> buyukYaz = s -> System.out.println("BUYUK: " + s.toUpperCase());
62        yazdir.andThen(buyukYaz).accept("zincir");
63
64        System.out.println("\n=== 3. Supplier<T> : Üretme ===\n");
65        Supplier<Double> rastgele = () -> Math.random();
66        System.out.println("Rastgele uretildi: " + rastgele.get());
67        // Lazy (tembel) değer üretiminde çok kullanışlıdır.
68
69        System.out.println("\n=== 4. Predicate<T> : Koşul testi ===\n");
70        Predicate<Integer> ciftMi = n -> n % 2 == 0;
71        Predicate<Integer> pozitifMi = n -> n > 0;
72        System.out.println("4 cift mi?          " + ciftMi.test(4));
73        // and / or / negate ile birleştirme
74        System.out.println("6 cift VE pozitif?  " + ciftMi.and(pozitifMi).test(6));
75        System.out.println("-3 cift DEGIL mi?   " + ciftMi.negate().test(-3));
76
77        System.out.println("\n=== 5. BiFunction<T,U,R> : İki girdi ===\n");
78        BiFunction<Integer, Integer, Integer> topla = (a, b) -> a + b;
79        System.out.println("3 + 4 = " + topla.apply(3, 4));
80        BiFunction<String, String, String> birlestir = (a, b) -> a + " " + b;
81        System.out.println(birlestir.apply("Merhaba", "Dunya"));
82
83        System.out.println("\n=== 6. UnaryOperator & BinaryOperator ===\n");
84        UnaryOperator<String> kucult = s -> s.toLowerCase();
85        System.out.println("Kucult: " + kucult.apply("JAVA"));
86        BinaryOperator<Integer> maks = (a, b) -> a > b ? a : b;
87        System.out.println("Maks(10, 25): " + maks.apply(10, 25));
88
89        System.out.println("\n=== 7. GERÇEK HAYAT: Ürün Filtreleme (E-ticaret) ===\n");
90        List<Urun> urunler = Arrays.asList(
91                new Urun("Telefon", 15000, true),
92                new Urun("Kulaklik", 800, false),
93                new Urun("Laptop", 32000, true),
94                new Urun("Mouse", 350, true));
95
96        // Predicate'leri yeniden kullanılabilir kurallar olarak tanımla
97        Predicate<Urun> stokta = u -> u.stoktaVar;
98        Predicate<Urun> pahali = u -> u.fiyat > 1000;
99
100        System.out.println("Stokta OLAN ve PAHALI urunler:");
101        for (Urun u : urunler) {
102            // İş kurallarını birleştir: stokta VE pahalı
103            if (stokta.and(pahali).test(u)) {
104                System.out.println("   " + u);
105            }
106        }
107
108        // Function ile vergi hesaplama kuralı
109        Function<Urun, Double> kdvliFiyat = u -> u.fiyat * 1.20;
110        System.out.println("\nKDV'li fiyatlar:");
111        urunler.forEach(u ->
112                System.out.printf("   %-10s : %.2f TL%n", u.ad, kdvliFiyat.apply(u)));
113
114        System.out.println("\n=== 8. ÖZEL @FunctionalInterface Tanımlama ===\n");
115        IndirimKurali yuzde10 = fiyat -> fiyat * 0.90;
116        IndirimKurali sabit50 = fiyat -> fiyat - 50;
117        System.out.println("1000 TL'ye %10 indirim: " + yuzde10.uygula(1000));
118        System.out.println("1000 TL'ye 50 TL indirim: " + sabit50.uygula(1000));
119    }
120
121    /**
122     * Kendi fonksiyonel arayüzümüz. @FunctionalInterface sayesinde ikinci bir
123     * soyut metot eklersek derleyici hata verir (güvenlik).
124     */
125    @FunctionalInterface
126    interface IndirimKurali {
127        double uygula(double fiyat);
128    }
129
130    static class Urun {
131        String ad;
132        double fiyat;
133        boolean stoktaVar;
134
135        Urun(String ad, double fiyat, boolean stoktaVar) {
136            this.ad = ad;
137            this.fiyat = fiyat;
138            this.stoktaVar = stoktaVar;
139        }
140
141        @Override
142        public String toString() {
143            return ad + " - " + fiyat + " TL (stok: " + (stoktaVar ? "var" : "yok") + ")";
144        }
145    }
146}

1import java.util.Arrays;
2import java.util.Random;
3
4/**
5 * ============================================================================
6 *  JVM DEĞİŞİKLİKLERİ ve YARDIMCI YENİLİKLER - Java 8
7 * ============================================================================
8 *
9 * Bu dosya iki konuyu örnekler:
10 *   A) Arrays.parallelSort  : Büyük dizileri çoklu çekirdekte sıralama
11 *   B) PermGen -> Metaspace  : JVM bellek modeli değişikliği (anlatım + kanıt)
12 *
13 * ----------------------------------------------------------------------------
14 * A) Arrays.parallelSort
15 *   NEDİR? Diziyi paralel (fork/join havuzu ile) sıralayan metot.
16 *   NEDEN GELDİ? Arrays.sort tek iş parçacığında çalışır. Çok büyük dizilerde
17 *     çok çekirdekli işlemcileri kullanmak için parallelSort eklendi.
18 *   NE İŞE YARAR: Büyük veri kümelerinde sıralamayı hızlandırır.
19 *   DİKKAT: Küçük dizilerde ek yük nedeniyle normal sort daha hızlı olabilir.
20 *
21 * ----------------------------------------------------------------------------
22 * B) PermGen Kaldırıldı -> Metaspace Geldi (JVM iç değişikliği)
23 *   ESKİ (Java 7 ve öncesi): PermGen (Permanent Generation) adında SABİT
24 *     boyutlu bir bellek alanı vardı. Sınıf metadata'sı (yüklenen sınıf
25 *     bilgileri) burada tutulurdu. Çok sayıda sınıf yükleyen uygulamalarda
26 *     (özellikle uygulama sunucuları, sık deploy yapan sistemler) sıkça
27 *     "java.lang.OutOfMemoryError: PermGen space" hatası alınırdı.
28 *     -XX:MaxPermSize ile boyut elle ayarlanırdı; ayarlamak zordu.
29 *
30 *   YENİ (Java 8): PermGen tamamen KALDIRILDI. Yerine METASPACE geldi.
31 *     - Metaspace, JVM heap'inde DEĞİL, yerel (native) bellekte tutulur.
32 *     - Varsayılan olarak boyutu OTOMATİK büyür (sınırı yalnızca işletim
33 *       sistemi belleğidir; -XX:MaxMetaspaceSize ile sınırlanabilir).
34 *     - Sonuç: "PermGen space" hatası tarihe karıştı; sınıf metadata yönetimi
35 *       daha esnek ve daha az sorunlu hale geldi.
36 */
37public class JvmVeYardimcilar {
38
39    public static void main(String[] args) {
40
41        System.out.println("=== A) Arrays.parallelSort vs Arrays.sort ===\n");
42
43        int boyut = 2_000_000;
44        int[] dizi1 = rastgeleDizi(boyut);
45        int[] dizi2 = Arrays.copyOf(dizi1, dizi1.length); // ayni veri
46
47        // ESKİ/Klasik: tek iş parçacıklı sort
48        long t1 = System.currentTimeMillis();
49        Arrays.sort(dizi1);
50        long sureSort = System.currentTimeMillis() - t1;
51
52        // YENİ: paralel sort (fork/join)
53        long t2 = System.currentTimeMillis();
54        Arrays.parallelSort(dizi2);
55        long sureParalel = System.currentTimeMillis() - t2;
56
57        System.out.println("Dizi boyutu        : " + boyut);
58        System.out.println("Arrays.sort        : " + sureSort + " ms");
59        System.out.println("Arrays.parallelSort: " + sureParalel + " ms");
60        System.out.println("Cekirdek sayisi    : " + Runtime.getRuntime().availableProcessors());
61        System.out.println("Iki sonuc esit mi? : " + Arrays.equals(dizi1, dizi2));
62        System.out.println("(Not: kucuk dizilerde paralel daha YAVAS olabilir.)");
63
64        System.out.println("\n=== B) PermGen -> Metaspace (JVM bellek bilgisi) ===\n");
65        // Çalışılan JVM sürümü hakkında bilgi - Java 8'de PermGen yoktur
66        System.out.println("Java surumu        : " + System.getProperty("java.version"));
67        System.out.println("JVM adi            : " + System.getProperty("java.vm.name"));
68
69        long maxHeap = Runtime.getRuntime().maxMemory();
70        System.out.printf("Max heap (yaklasik): %.0f MB%n", maxHeap / (1024.0 * 1024.0));
71
72        System.out.println();
73        System.out.println("Java 7'de sinif metadata'si SABIT boyutlu PermGen'de tutulurdu");
74        System.out.println("ve 'OutOfMemoryError: PermGen space' sik gorulurdu.");
75        System.out.println("Java 8'de PermGen kaldirildi; metadata artik native bellekteki");
76        System.out.println("METASPACE'te tutulur ve otomatik buyur. Bu hata tarihe karisti.");
77    }
78
79    static int[] rastgeleDizi(int boyut) {
80        Random r = new Random(42); // sabit tohum -> tekrarlanabilir
81        int[] dizi = new int[boyut];
82        for (int i = 0; i < boyut; i++) {
83            dizi[i] = r.nextInt();
84        }
85        return dizi;
86    }
87}