1// Ornek1: Enum temelleri — tanım, switch ve values().
2// Çalıştırma: java Ornek1.java
3public class Ornek1 {
4
5    // Enum: sabit, sınırlı bir değer kümesi. Tip güvenlidir:
6    // sadece tanımlı değerler atanabilir, yanlış metin atanamaz.
7    enum Yon { KUZEY, GUNEY, DOGU, BATI }
8
9    static String aciklama(Yon yon) {
10        // switch ile enum: case'lerde enum adını sade yazarız (Yon.KUZEY değil, KUZEY).
11        return switch (yon) {
12            case KUZEY -> "yukarı";
13            case GUNEY -> "aşağı";
14            case DOGU  -> "sağa";
15            case BATI  -> "sola";
16        };
17    }
18
19    public static void main(String[] args) {
20        Yon y = Yon.DOGU;
21        System.out.println("Seçilen yön: " + y + " -> " + aciklama(y));
22
23        // values(): tüm enum değerlerini dizi olarak verir.
24        System.out.println("\nTüm yönler:");
25        for (Yon yon : Yon.values()) {
26            // ordinal(): tanım sırasındaki indeks; name(): metin adı.
27            System.out.printf("  %d) %s -> %s%n", yon.ordinal(), yon.name(), aciklama(yon));
28        }
29
30        // valueOf(): metinden enum'a çevirir (tam eşleşme gerekir).
31        Yon metindenGelen = Yon.valueOf("BATI");
32        System.out.println("\nvalueOf(\"BATI\") = " + metindenGelen);
33    }
34}

1// Ornek2: Davranışlı enum — alan, constructor ve metot içeren enum.
2// Çalıştırma: java Ornek2.java
3public class Ornek2 {
4
5    // Enum'lar yalnızca sabit değil; alan, constructor ve metot da içerebilir.
6    // Her sabit, kendi davranışını uygulayabilir.
7    enum Islem {
8        TOPLA("+") { public double uygula(double a, double b) { return a + b; } },
9        CIKAR("-") { public double uygula(double a, double b) { return a - b; } },
10        CARP("*")  { public double uygula(double a, double b) { return a * b; } },
11        BOL("/")   { public double uygula(double a, double b) { return a / b; } };
12
13        private final String sembol;
14
15        // Enum constructor'ı private'tır; her sabit kendi sembolünü taşır.
16        Islem(String sembol) { this.sembol = sembol; }
17
18        public String sembol() { return sembol; }
19
20        // Soyut enum metodu: her sabit kendi sürümünü verir.
21        public abstract double uygula(double a, double b);
22    }
23
24    public static void main(String[] args) {
25        double a = 12, b = 4;
26        System.out.println("a = " + a + ", b = " + b + "\n");
27
28        // Tüm işlemleri tek döngüde uygula.
29        for (Islem islem : Islem.values()) {
30            System.out.printf("%.1f %s %.1f = %.2f%n", a, islem.sembol(), b, islem.uygula(a, b));
31        }
32    }
33}

1// Ornek3: Wrapper sınıfları, autoboxing/unboxing, parsing ve Integer cache tuzağı.
2// Çalıştırma: java Ornek3.java
3import java.util.ArrayList;
4import java.util.List;
5
6public class Ornek3 {
7
8    public static void main(String[] args) {
9        // Wrapper: ilkel tiplerin nesne karşılığı (int->Integer, double->Double...).
10        // Koleksiyonlar ilkel tip tutamaz, wrapper tutar.
11        List<Integer> sayilar = new ArrayList<>();
12
13        // --- Autoboxing: int -> Integer otomatik ---
14        sayilar.add(5);       // 5 (int) otomatik Integer'a kutulanır
15        sayilar.add(10);
16
17        // --- Unboxing: Integer -> int otomatik ---
18        int ilk = sayilar.get(0); // Integer otomatik int'e açılır
19        System.out.println("Liste: " + sayilar + ", ilk eleman + 1 = " + (ilk + 1));
20
21        // --- Parsing: metinden sayıya ---
22        int x = Integer.parseInt("123");
23        double d = Double.parseDouble("3.14");
24        boolean b = Boolean.parseBoolean("true");
25        System.out.println("parseInt(\"123\")=" + x + ", parseDouble(\"3.14\")=" + d + ", parseBoolean=" + b);
26
27        // Wrapper sabitleri ve yardımcı metotlar:
28        System.out.println("Integer.MAX_VALUE = " + Integer.MAX_VALUE);
29        System.out.println("Integer.max(7, 3) = " + Integer.max(7, 3));
30
31        // --- Integer cache tuzağı ---
32        // Java, -128..127 arası Integer'ları önbelleğe alır; bu aralıkta == aynı nesneyi verir.
33        Integer a1 = 100, a2 = 100;       // önbellek aralığında
34        Integer b1 = 200, b2 = 200;       // önbellek dışında
35        System.out.println("\n--- Integer == tuzağı ---");
36        System.out.println("100 == 100 (Integer) : " + (a1 == a2)); // true (önbellek)
37        System.out.println("200 == 200 (Integer) : " + (b1 == b2)); // false (farklı nesne!)
38        System.out.println("200.equals(200)      : " + b1.equals(b2)); // true (doğrusu bu)
39        System.out.println("\nKural: Wrapper'ları DEĞER olarak karşılaştırırken equals() kullan.");
40    }
41}