Java’da Değişkenler ve Kapsam (Scope)

Basitçe ifade etmek gerekirse, bir variable (değişken), program çalışırken verileri geçici olarak depolayan bir “isimli bellek konumu”dur. Scope ise, bu değişkenin programın hangi kısımlarından erişilebilir olduğunu belirleyen kurallar bütünüdür. Bir değişkeni kutuya benzetirsek, scope o kutunun hangi odalara konulabileceğini ve hangi odalardan erişilebileceğini belirleyen kuraldır.

Get Mehmet Reşit Çağan’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Şimdi, bu temel yapı taşlarını daha yakından inceleyelim.

Java’da Değişken Türleri

Değişkenler, tanımlandıkları yere göre üç ana kategoriye ayrılır. Bu ayrım, hem değişkenin yaşam döngüsünü hem de erişilebilirlik kurallarını doğrudan etkiler.

1. Yerel Değişkenler (Local Variables)

Yerel değişkenler, bir metodun, constructor’ın veya kod bloğunun (if, for gibi) içinde tanımlanırlar. En dar kapsama sahip değişkenlerdir ve sadece tanımlandıkları blok içinde yaşarlar.

• Yaşam Döngüsü: Blok başladığında oluşur, blok bittiğinde bellekten silinir.
• Önemli Not: Yerel değişkenlere bir değer atamadan doğrudan erişmeye çalışırsanız, derleme hatası alırsınız. Java, bu tür değişkenlere otomatik olarak varsayılan bir değer atamaz.

Örnek:

public void calculatePrice() {
    int quantity = 5; // Yerel değişken
    double unitPrice = 15.50; // Yerel değişken
    double totalPrice = quantity * unitPrice;

System.out.println("Toplam fiyat: " + totalPrice);
} 
// 'quantity', 'unitPrice' ve 'totalPrice' değişkenlerine bu metodun dışında erişilemez.

2. Instance Variables

Instance variables, bir sınıf içinde ancak herhangi bir metodun dışında tanımlanan değişkenlerdir. Her sınıf nesnesi (instance) için bellekte ayrı bir kopyası oluşturulur.

• Yaşam Döngüsü: Nesne oluşturulduğunda oluşur ve nesne yok edildiğinde bellekten silinir.
• Önemli Not: Java, bu değişkenlere otomatik olarak varsayılan bir değer atar (örneğin, int için 0, boolean için false, referans türleri için null).

Örnek:

public class Product {
    String name;  // Instance variable
    double price; // Instance variable

public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }
}
Product laptop = new Product("Laptop", 1200.00); // laptop nesnesinin kendine ait 'name' ve 'price' değişkenleri var.
Product phone = new Product("Telefon", 800.00);  // phone nesnesinin de kendine ait 'name' ve 'price' değişkenleri var.

3. Sınıf Değişkenleri (Static Variables)

Sınıf değişkenleri, static anahtar kelimesi ile tanımlanan ve bir sınıfa ait olan değişkenlerdir. Tüm nesneler tarafından ortaklaşa kullanılır ve bellekte sadece tek bir kopyası bulunur.

• Yaşam Döngüsü: Program başladığında bellekte yer alır ve program sonlanana kadar orada kalır.
• Önemli Not: static değişkenlere genellikle sınıfın adıyla erişilir (ClassName.variableName). Bu değişkenler, tüm nesnelerin ortaklaşa kullanması gereken veriler (örneğin, bir sayacın değeri) için idealdir.

Örnek:

public class Planet {
    public static int planetCount = 0; // Sınıf değişkeni

public Planet() {
        planetCount++; // Yeni bir nesne oluştuğunda sayacı artır.
    }
}
Planet earth = new Planet();
Planet mars = new Planet();
Planet venus = new Planet();
System.out.println(Planet.planetCount); // Çıktı: 3. Tüm nesneler aynı sayacı paylaşıyor.

Değişken Kapsamları (Variable Scopes)

Java’da, bir değişkenin “görünürlüğü” (visibility) veya erişilebilirliği, scope kurallarıyla belirlenir.

• Metot Kapsamı: Bir metodun içinde tanımlanan değişkenler, sadece o metot içinden erişilebilir.
• Sınıf Kapsamı: Sınıf içinde tanımlanan (ancak metot dışında) örnek ve sınıf değişkenleri, o sınıfa ait tüm metotlar tarafından görülebilir.
• Blok Kapsamı: Bir for döngüsü veya if bloğu gibi yapılar içinde tanımlanan değişkenler, sadece o blok içinde erişilebilir.

Kapsamları Gösteren Örnek:

public class ScopeExample {
    String classVariable = "Bu bir sınıf değişkenidir."; // Sınıf Kapsamı

public void myMethod(int parameter) { // 'parameter' metot kapsamında
        String localVariable = "Bu bir yerel değişkendir."; // Metot Kapsamı
        if (parameter > 0) {
            String blockVariable = "Bu bir blok değişkenidir."; // Blok Kapsamı
            System.out.println(blockVariable);
        }
        // 'blockVariable' değişkenine burada erişilemez.
        System.out.println(localVariable); // Erişim mümkün
        System.out.println(classVariable); // Erişim mümkün
    }
    public void anotherMethod() {
        // 'localVariable' değişkenine buradan erişilemez.
        System.out.println(classVariable); // Erişim mümkün
    }
}

Sonuç: Neden Scope Önemli?

Kapsam kuralları, programlamada bir dizi önemli fayda sağlar:

• Bellek Yönetimi: Değişkenlerin yalnızca ihtiyaç duyulduğunda var olmasını sağlayarak gereksiz bellek kullanımını önler.
• Hata Kontrolü: Değişkenlerin yanlışlıkla başka bir yerden değiştirilmesini engelleyerek beklenmedik hataların önüne geçer.
• Okunabilirlik: Kodun hangi kısmının hangi değişkenlerle çalıştığını netleştirerek kodun daha kolay anlaşılmasını sağlar.

Bu kavramlar, Java’nın modüler ve güvenli bir dil olmasının temelinde yatar. Bir sonraki kod satırını yazmadan önce düşünmek gereklidir.