Java Academy · Ders

Statik İç İçe Sınıflar

Kapsayan sınıf örneğine başvurmadan ilişkili yardımcı türler olarak statik iç içe sınıflar tanımlayın.

Statik İç İçe Sınıflar, CoddyKit'te ücretsiz bir Java Academy dersidir. Bu, 4 dersinin 1. 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.

Statik İç İçe Sınıflar

Statik iç içe sınıf, başka bir sınıfın içinde static anahtar sözcüğüyle tanımlanır. Kapsayan sınıf örneğine başvurusu yoktur; yalnızca onunla mantıksal olarak gruplanır.

Statik İç İçe Sınıf Tanımlama

İç içe sınıfa dışarıdan erişmek için dış sınıfın adını kullanın.

class LinkedList<T> {
    private Node<T> head;

    // Static nested class — no outer instance reference
    private static class Node<T> {
        T data;
        Node<T> next;
        Node(T data) { this.data = data; }
    }

    public void addFirst(T item) {
        Node<T> node = new Node<>(item);
        node.next = head;
        head = node;
    }
}

Dışarıdan Erişim

Herkese açık bir statik iç içe sınıfa OuterClass.InnerClass olarak başvurun.

class Builder {
    public static class Config {
        public final String host;
        public final int port;
        Config(String host, int port) {
            this.host = host; this.port = port;
        }
    }
}

Builder.Config config = new Builder.Config("localhost", 8080);
System.out.println(config.host + ":" + config.port); // localhost:8080

Statik İç İçe ve Inner Sınıflar

Temel fark şudur: statik iç içe sınıfların dış sınıf örneğine örtük bir başvurusu yoktur. Inner (statik olmayan) sınıflarda ise böyle bir başvuru DO bulunur.

class Outer {
    private int x = 10;

    // Static nested: no access to x
    static class StaticNested {
        void doSomething() {
            // System.out.println(x); // compile error — no outer reference!
            System.out.println("Static nested");
        }
    }

    // Inner class: has access to x
    class Inner {
        void doSomething() {
            System.out.println(x); // 10 — can access outer fields
        }
    }
}

Statik İç İçe Sınıfla Builder Örüntüsü

Klasik Builder örüntüsü, çağıranların bir oluşturucu oluşturmak için dış sınıf örneğine ihtiyaç duymaması amacıyla statik bir iç içe sınıf kullanır.

class Pizza {
    private final String size, crust;
    private final List<String> toppings;

    private Pizza(Builder b) {
        this.size = b.size; this.crust = b.crust; this.toppings = List.copyOf(b.toppings);
    }

    public static class Builder {
        private String size = "medium", crust = "thin";
        private List<String> toppings = new ArrayList<>();
        public Builder size(String s)    { this.size = s; return this; }
        public Builder crust(String c)   { this.crust = c; return this; }
        public Builder topping(String t) { this.toppings.add(t); return this; }
        public Pizza build()             { return new Pizza(this); }
    }
}

Haritalardaki Girdi

Map.Entry, anahtar-değer çiftleri üzerinde yineleme yapmak için kullanılan, iyi bilinen bir statik iç içe arayüzdür.

import java.util.*;

Map<String, Integer> scores = Map.of("Alice", 95, "Bob", 87, "Carol", 92);

for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.printf("%-10s: %d%n", entry.getKey(), entry.getValue());
}

// Modern: using var
for (var entry : scores.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

Statik İç İçe Sınıfla Sınama

Birim sınamalarında statik iç içe bir sınıf, sınama düzeneklerini veya sahte uygulamaları sınama sınıfının kapsamı içinde tutabilir.

class UserServiceTest {
    // Static nested fake/stub — no outer instance needed
    static class FakeUserRepository implements UserRepository {
        private final Map<Long, User> store = new HashMap<>();

        public void save(User u) { store.put(u.id(), u); }

        public Optional<User> findById(long id) {
            return Optional.ofNullable(store.get(id));
        }
    }

    // @Test methods use FakeUserRepository
    void testFindUser() {
        FakeUserRepository repo = new FakeUserRepository();
        // ...
    }
}

Alan Mantığı için Statik İç İçe Sınıflar

Alan modellerinde daha iyi bir düzen sağlamak için ilişkili türleri statik iç içe sınıfları kullanarak gruplayın.

class Order {
    private final long id;
    private final List<LineItem> items;

    // Static nested — logically belongs to Order, no outer reference needed
    public static class LineItem {
        public final String sku;
        public final int quantity;
        public final double unitPrice;

        public LineItem(String sku, int qty, double price) {
            this.sku = sku; this.quantity = qty; this.unitPrice = price;
        }

        public double total() { return quantity * unitPrice; }
    }

    // ...
}

Karşılaştırma: Statik İç İçe ve Üst Düzey

Bir sınıf yalnızca dış sınıf bağlamında kullanılıyorsa statik iç içe sınıfı tercih edin. Daha geniş bir kullanım alanına sahipse üst düzey sınıf kullanın.

Jeneriklerle Statik İç İçe Sınıflar

Statik iç içe sınıflar, tıpkı üst düzey sınıflar gibi jenerik türlere katılabilir.

class Pair<A, B> {
    // Static nested with its own type params
    public static class Mutable<X, Y> {
        public X first;
        public Y second;
        public Mutable(X first, Y second) {
            this.first = first; this.second = second;
        }
    }

    public static <X, Y> Mutable<X, Y> mutableOf(X x, Y y) {
        return new Mutable<>(x, y);
    }
}
Pair.Mutable<String, Integer> p = Pair.mutableOf("Alice", 30);
System.out.println(p.first + " is " + p.second); // Alice is 30

Bellek Verimliliği

Statik iç içe sınıflar dış sınıf örneğine başvuru tutmaz. Bu, uzun ömürlü yapılarda bellek sızıntılarına yol açabilecek şekilde dış nesnenin bellekte yanlışlıkla tutulmasını önler.

Kısa Kontrol

Statik iç içe sınıfı iç (statik olmayan) sınıftan ayıran nedir?

Özet: Statik İç İçe Sınıflar

Önemli noktalar:

Statik iç içe sınıflar dış sınıfla gruplanır, ancak dış sınıf örneğine başvurmaz
Dışarıdan erişim: OuterClass.NestedClass
Örtük başvurunun olmaması, dış sınıf örneğinin bellekte yanlışlıkla tutulmasını önler
Builder örüntüsü genellikle statik iç içe bir Builder sınıfı kullanır
Map.Entry, iyi bilinen bir statik iç içe arayüzdür
İç sınıfın dış sınıf örneğine erişmesi gerekmiyorsa statik iç içe sınıfı tercih edin

Sıkça Sorulan Sorular

“Statik İç İçe Sınıflar” dersi ücretsiz mi?

Evet — “Statik İç İçe Sınıflar” 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.

“Statik İç İçe Sınıflar” dersinde ne öğreneceğim?

Kapsayan sınıf örneğine başvurmadan ilişkili yardımcı türler olarak statik iç içe sınıflar tanımlayı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 1. dersidir.

“Statik İç İçe Sınıflar” 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