Java'da iç içe sınıfların türleri nelerdir?

Question

Accepted Answer

Bir **iç içe sınıf** (nested class), başka bir sınıf içinde tanımlanan bir sınıftır. Java'da dört tür vardır — **static iç içe**, **inner (static olmayan)**, **yerel** ve **anonim** — her biri dış sınıfa farklı erişime ve farklı kullanım durumlarına sahiptir.

## 1. Static iç içe sınıf — bir örneğinden bağımsız

```java
public class Outer {
    private static int data = 10;

static class Nested {            // static → no reference to an Outer INSTANCE
        void show() {
            System.out.println(data);  // can access static members of Outer only
        }
    }
}
Outer.Nested n = new Outer.Nested();   // created without an Outer instance
```

Bir `static` iç içe sınıf, en üst düzey bir sınıf gibi davranır ancak dış sınıf içinde ad alanı ile sınırlıdır. Bir dış örneğe referans **tutmaz** — yardımcı sınıfları gruplandırmak için kullanılır (örn. bir `Builder`, veri yapısındaki `Node`).

## 2. Inner (static olmayan) sınıf — bir örneğe bağlı

```java
public class Outer {
    private int value = 5;

class Inner {                     // non-static → has an implicit reference to Outer
        void show() {
            System.out.println(value); // can access Outer's INSTANCE members (even private)
        }
    }
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();   // needs an Outer instance to create
```

Static olmayan bir **inner** sınıf, kapsayan örneğine örtük bir referans tutar, bu nedenle dış nesnenin örnek alanlarına erişebilir. (Uyarı: bu referans, inner örneği dış örneği aşarsa **bellek sızıntısı** oluşturabilir.)

## 3. Yerel sınıf — bir metot içinde tanımlanan

```java
void process() {
    class Helper {                    // local to this method
        void run() { ... }
    }
    new Helper().run();
}
```

Nadir kullanılan; metotla sınırlı kapsamı vardır.

## 4. Anonim sınıf — tek seferlik uygulama, isimsiz

```java
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) { handleClick(); }
});

Runnable task = new Runnable() {
    public void run() { System.out.println("running"); }
};
```

Bir **anonim** sınıf, bir arayüzün veya sınıfın tek seferlik uygulaması olup, aynı anda tanımlanır ve örneklendirilir — tarihsel olarak olay işleyicileri ve geri çağrılar için yaygındır. Modern Java, hedef bir işlevsel arayüz olduğunda bunları sıklıkla **lambda** ile değiştirir:

```java
button.addActionListener(e -> handleClick());   // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
```

## Neden önemli

İç içe sınıflar, yalnızca bir bağlamda kullanılan sınıfları **mantıksal olarak gruplandırmak** için kullanışlı bir araçtır ve kapsüllemeyi ve okunabilirliği artırır.

Türleri anlamak — özellikle **static ve inner ayrımı** (static = bağımsız, inner = kapsayan örneğe referans tutar) — hem tasarım hem de hataları önlemek için önemlidir: inner sınıfların örtük dış referansı bellek sızıntısı oluşturabilir ve dış örneğine ihtiyaç duymadığınızda static seçmek daha temiz bir varsayılandır.

Anonim sınıflar, satır içi uygulamalar sağlamanın klasik yoluydu (olay işleyicileri, karşılaştırıcılar) ve bunların işlevsel arayüzler için büyük ölçüde lambda tarafından değiştirildiğini bilmek, modern Java yetkinliğini yansıtır.

Bunlar standart kütüphane boyunca görülür (örn. `Map.Entry` iç içe bir arayüz, builders statik iç içe sınıflardır), bu onları pratik, sık karşılaşılan bilgi haline getirir.