Java Academy · Ders

İç Sınıflar ve Dış Sınıfa Erişim

Dış sınıf örneğine başvuru tutan statik olmayan iç sınıfları kullanın.

İç Sınıflar ve Dış Sınıfa Erişim, CoddyKit'te ücretsiz bir Java Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Java Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Java Academy kursu toplamda 4 dersten oluşur.

Inner Sınıflar

Statik olmayan bir Inner sınıf, kapsayan dış sınıf örneğine örtük bir başvuru tutar. Özel üyeler de dâhil olmak üzere dış sınıfın tüm üyelerine erişebilir.

Inner Sınıfı Tanımlama ve Kullanma

Bir Inner sınıf örneğini yalnızca outer.new InnerClass() kullanarak bir dış sınıf örneği üzerinden oluşturun.

class BankAccount {
    private double balance;
    private String owner;

    BankAccount(String owner, double initial) {
        this.owner = owner; this.balance = initial;
    }

    class Transaction {
        void deposit(double amount) {
            balance += amount; // accesses outer field directly
            System.out.println(owner + " deposited " + amount);
        }
    }
}

BankAccount acct = new BankAccount("Alice", 500);
BankAccount.Transaction tx = acct.new Transaction();
tx.deposit(100); // Alice deposited 100.0

Dış Sınıf Üyelerine Erişim

Inner sınıflar, özel alanlar ve metotlar da dâhil olmak üzere dış sınıfın tüm üyelerine erişebilir.

class Encryption {
    private final String secretKey = "s3cr3t"; // private!

    class Encryptor {
        String encrypt(String data) {
            // Inner class accesses private outer field
            return data + "|" + secretKey.hashCode();
        }
    }

    class Decryptor {
        String decrypt(String encrypted) {
            int idx = encrypted.lastIndexOf('|');
            return encrypted.substring(0, idx);
        }
    }
}

this ile Gölgeleme

Bir Inner sınıfında dış sınıfla aynı ada sahip bir alan olduğunda, dış sınıftaki alana başvurmak için OuterClass.this.field kullanın.

class Outer {
    int value = 10;

    class Inner {
        int value = 20; // shadows outer.value

        void printBoth() {
            System.out.println("Inner value: " + value);         // 20
            System.out.println("Outer value: " + Outer.this.value); // 10
        }
    }
}

new Outer().new Inner().printBoth();
// Inner value: 20
// Outer value: 10

Inner Sınıfla Yineleyici Örüntüsü

Klasik bir kullanım alanı, kapsayan koleksiyonun özel verilerine erişen bir Inner sınıf olarak yineleyici uygulamaktır.

class NumberRange implements Iterable<Integer> {
    private final int start;
    private final int end;

    NumberRange(int start, int end) {
        this.start = start; this.end = end;
    }

    @Override
    public java.util.Iterator<Integer> iterator() {
        return new RangeIterator(); // inner class instance
    }

    private class RangeIterator implements java.util.Iterator<Integer> {
        private int current = start; // accesses outer start

        public boolean hasNext() { return current <= end; }
        public Integer next()    { return current++; }
    }
}

for (int n : new NumberRange(1, 5)) System.out.print(n + " ");
// 1 2 3 4 5

Olay Dinleyicileri için Inner Sınıflar

GUI ve olay güdümlü programlamada, kapsayan kullanıcı arayüzü bileşeninin durumuna erişen olay dinleyicilerini uygulamak için yaygın olarak Inner sınıflar kullanılır.

// Swing-style example (conceptual)
class LoginPanel {
    private String username = "";

    class LoginButtonListener {
        void onButtonClicked() {
            if (username.isEmpty()) {
                System.out.println("Please enter username"); // accesses outer field
            } else {
                System.out.println("Logging in as: " + username);
            }
        }
    }

    void setUsername(String name) { this.username = name; }
}
LoginPanel panel = new LoginPanel();
panel.setUsername("alice");
panel.new LoginButtonListener().onButtonClicked();
// Logging in as: alice

Koleksiyonlarda Inner Sınıf

Bazı koleksiyon uygulamaları, kapsayan koleksiyon tarafından desteklenen imleçleri veya görünümleri tutmak için Inner sınıflar kullanır.

class SimpleStack<T> {
    private Object[] elements;
    private int size = 0;

    SimpleStack(int capacity) {
        elements = new Object[capacity];
    }

    void push(T item) {
        if (size >= elements.length) throw new StackOverflowError();
        elements[size++] = item;
    }

    T pop() {
        if (size == 0) throw new java.util.EmptyStackException();
        T item = (T) elements[--size];
        elements[size] = null;
        return item;
    }

    int size() { return size; }
}

Bellek Sızıntısı Uyarısı

Inner sınıf örnekleri dış sınıf örneğine başvuru tutar. Inner sınıf outer sınıfın dışına çıkarsa (örneğin uzun ömürlü bir koleksiyonda saklanırsa), dış sınıf örneği çöp toplayıcı tarafından geri alınamaz.

// Memory leak: anonymous inner class (implicit outer ref) stored statically
class LeakExample {
    byte[] data = new byte[1024 * 1024]; // 1MB

    // BAD: this Runnable holds a reference to LeakExample.this
    Runnable leak = new Runnable() {
        public void run() { System.out.println(data.length); }
    };
}
// If 'leak' is stored somewhere, LeakExample (and its 1MB) is never GC'd

// FIX: use a static nested class or a lambda that captures only needed values
static Runnable noLeak(byte[] data) {
    return () -> System.out.println(data.length); // captures array, not outer
}

Inner Sınıf ve Lambda Karşılaştırması

Modern Java lambda ifadeleri, tek metotlu arayüzler için çoğu zaman anonim Inner sınıfların yerini alır. Lambda ifadeleri daha kısadır, ancak kendilerine ait bir this değerleri DO yoktur.

// Old way: anonymous inner class
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running (inner class) — this is the Runnable");
    }
};

// Modern: lambda
Runnable r2 = () -> System.out.println("Running (lambda)");

r1.run();
r2.run();

// Lambda this = enclosing class (not the Runnable)
// Inner class this = the Runnable instance itself

Inner Sınıflar Ne Zaman Kullanılmalı

Şu durumlarda statik olmayan Inner sınıfları kullanın:

Sınıfın kapsayan örneğin özel durumuna erişmesi gerektiğinde
Her Inner örneği mantıksal olarak belirli bir dış sınıfa bağlı olduğunda
Geçiş mantığını kapsüllemek için Yineleyici örüntüsü kullanıldığında

Pratik: Paginator

İç sınıfın sayfa durumunu tuttuğu ve dış sınıfın veri listesine eriştiği pratik bir sayfalayıcı.

import java.util.*;

class Paginator<T> {
    private final List<T> items;
    private final int pageSize;

    Paginator(List<T> items, int pageSize) {
        this.items = items; this.pageSize = pageSize;
    }

    class Page {
        private int pageIndex = 0;

        List<T> current() {
            int start = pageIndex * pageSize;
            int end = Math.min(start + pageSize, items.size()); // outer
            return start < items.size() ? items.subList(start, end) : List.of();
        }
        boolean hasNext() { return (pageIndex + 1) * pageSize < items.size(); }
        void next() { if (hasNext()) pageIndex++; }
    }
}
Paginator<String> p = new Paginator<>(List.of("a","b","c","d","e"), 2);
Paginator.Page page = p.new Page();
System.out.println(page.current()); // [a, b]
page.next();
System.out.println(page.current()); // [c, d]

Hızlı Kontrol

Bir iç (statik olmayan) sınıf, statik iç içe bir sınıfta bulunmayan neyi barındırır?

Özet: İç Sınıflar ve Dış Sınıfa Erişim

Temel çıkarımlar:

Statik olmayan iç sınıflar, kendilerini çevreleyen dış sınıf örneğine örtük bir başvuru tutar
İç sınıf örneklerini yalnızca bir dış sınıf örneği üzerinden oluşturun: outer.new Inner()
İç sınıflar, private alanlar da dâhil olmak üzere dış sınıfın tüm üyelerine erişebilir
Gölgeleme oluşan alanları ayırt etmek için Outer.this.field kullanın
En uygun kullanım alanları: Iterator, olay dinleyicileri ve iç veri yapıları
Risk: İç sınıf örnekleri, dış sınıf örneklerinin çöp toplayıcı tarafından geri kazanılmasını engeller

Sıkça Sorulan Sorular

“İç Sınıflar ve Dış Sınıfa Erişim” dersi ücretsiz mi?

Evet — “İç Sınıflar ve Dış Sınıfa Erişim” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Java Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Java Academy kursu toplamda 4 dersten oluşur.

“İç Sınıflar ve Dış Sınıfa Erişim” dersinde ne öğreneceğim?

Dış sınıf örneğine başvuru tutan statik olmayan iç sınıfları kullanın. Java Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Java Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Java Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“İç Sınıflar ve Dış Sınıfa Erişim” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Java Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Java Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Java Academy Sayfasına Dön