Java static İfadesi Nedir? Ne İçin Kullanılır?

Bu yazıda, Java programlarında sıkça karşılaştığımız static ifadesinin ne anlama geldiğini, nerelerde, ne için kullanıldığını ve static olanlar ile static olmayanlar ararsındaki farkların neler olduğunu anlatmaya çalışacağız.

Java’da static nedir? Ne anlama gelmektedir?

Java, değişkenlerin, metotların, class ve benzeri oluşumların bir program içerisinde nasıl hareket edeceğine, erişilebilirliğine, kullanımına ve daha pek çok özelliğine etki eden bazı anahtarlar kelimeler geliştirmiştir. Örneğin access modifier yani erişim belirteci olarak belirtilen ‘public’ anahtar kelimesi, bir variable, metot veya class’ın paket dışındakiler de dahil olmak üzere tüm class’lardan erişilebilmesine imkan sağlamaktadır. Buna benzer bir şekilde ‘final’ anahtar kelimesi, benzeri oluşumların nihai şeklini aldığını ve onların üzerine değişiklik yapmanın mümkün olmadığı anlamına gelmektedir.

static anahtar kelimesi de yukarıdakilere benzer bir görev üstlenmektedir. Java’da bir değişkenin, metodun veya static kullanımına açık bir yapının static ifadesi ile kullanılması, onu diğer objelerden bağımsız yapar ve yaratıldığı class’ın bir parçası haline getirir. Static olduğu belirtilen oluşumlar, herhangi bir objeye ihtiyaç duyulmaksızın, erişilebilir hale gelirler.

static ifadesi genellikle değişkenler ve metodlarlar birlikte kullanılırlar. Bunlarla bilikte kod blogları ve nested class’larla birlikte de kullanılabilirler.

Kısaca ifade etmek gerekirse static kelimesi, kullanıldığı yapıyı sınıf’a ait hale getir. static class elemanları, tüm objelerin ortak elemanı haline gelir. Static’ler üzerinde yapılan her değişiklik, tüm objeleri etkiler ve tüm objeler tarafından görülür.

Static ifadesi nerede ve nasıl kullanılır?

Yukarıda da ifade ettiğimiz üzere static keywordü, farklı yapılar için kullanılmaktadır. Bunları tek tek inceleyelim;

Static Variable (Static Değişken)

Bir sınıf içerisinde, static olarak belirtilen değişkenler ‘static variable’ olarak isimlendirilirler. Bu variable’lar aynı zamanda ‘class variable’ olarak da ifade edilir. Bir variable, static olarak belirtildikten sonra, bellekte ona yalnızca bir kere yer açılır, obje sayısı ne kadar çok olursa olsun, tüm objeler için tek bir değişken vardır ve burada yapılan tüm değişiklikler, diğer objeler tarafından görülür. Static variable’lar class’a bağlı değişkenler oldukları için onlara bir obje üzerinden değil, direkt olarak class üzerinden erişilir. (Obje üzerinden erişmek de mümkündür)

Static değişkenlere bir örnek; 

//Ornek isimli bir class oluşturalım, içerisine bir Constructor ekleyelim 
//Constructor her çalıştığında içerisindeki static ve non-static değişkenleri 
//bir artırmasını isteyelim. 

public class Ornek {
    int sayi1 = 0;
    static int sayi2 = 0;
    
    Ornek(){
        sayi1++;
        sayi2++;
    }
}

// Objelerimizi oluşturacağımız yeni bir runner class oluşturalım ve içerisinde 
//Ornek classından 3 yeni obje ekleyelim. 
//Böylelikle Constructor’umuz 3 defa çalışmış olacak. 

public class Runner {
    public static void main(String[] args) {
        Ornek obje1 = new Ornek();
        Ornek obje2 = new Ornek();
        Ornek obje3 = new Ornek();

        System.out.println(obje1.sayi1); //non-static: obje’ye bağlı olduğu için obje ile çağıralım. 
        System.out.println(Ornek.sayi2); // static: class’a bağlı olduğu için Class’la çağıralım. 
    }
}

//Output alt alta 1 ve 3 şeklinde olacak. 

//Static olmayan variable’larda yaptığımız değişiklikler yalnızca bir objeyi etkileyecek 
//diğer objeler ise bundan etkilenmeyecek. Dolayısı ile biz ne kadar obje oluşturursak oluşturalım, 
//her obje bize 1 sonucunu verecek. Çünkü hepsi non-static değeri 0 olarak alıp, 
//constractor ile onu 1 artırmış olacak ve diğer objeler bundan etkilenmeyecek.


//non-static olanların aksine sınıfın bir parçası olan static variable’lar ise 
//tüm objeler için ortak oldukları için ve onda yapılan tüm değişiklikler 
//bütün objeleri etkileyeceği için bize 3 sonucunu verecek. 
//Zira biz her obje oluşturduğumuzda constructor static değişkeni 1 artıracak. 
//Böylelikle static değişkenimiz son çalıştırma ile birlike 3 değerine ulaşmış olacak. 

Ornek’te de görülebileceği üzere Java programlarında static oldukça büyük bir öneme sahiptir. Zira static olmayan değişkenler, objeye bağlı oldukları için, yapılan değişiklikler yalnızca bir obje’de kendini gösterecek ve diğer objeler bundan etkilenmeyecektir. Dolayısı ile bir programda bir sayaça ihtiyaç duyduğunuzu düşünürsek, static ifadesini kullanarak, oluşturulan her obje için sayacınızı 1 artırabilir ve güncel sayıyı tüm objelerde geçerli olacak şekilde kullanabilirsiniz.

Static Metod

Java’da bir metodun return type’ından önce static kelimesi yazmak onu static yapar. Tıpkı static variable’larda (static değişkenlerde) olduğu gibi, static ifadesi bir metodu class elemanı yapar. Dolayısı ile bir class’taki static metodu çağırmak için herhangi bir objeye ihtiyaç duyulmaz. Static metodlar, class’ta yer alan diğer staticlere erişebilir ve onların değerini değiştirebilir. Static bir metod’da ‘this’ veya ‘super’ ifadeleri kullanılmaz, bu hataya yol açar. Static metotlar, static olmayan diğer değişken ve metotları kullanamazlar.

Static metoda bir örnek

class Main
{
    // static değişken
    static int staticSayi = 5;

    // non-satatic değişken
    int nonStaticSayi = 10;

    // static method
    static void printStatic()
    {
        staticSayi = 20;
        System.out.println(staticSayi);
        //Metodu calıstırdığımızda ekrana 20 yazdıracaktır. 

// b = 20; // Aynı işlemi static olmayan bir değer için yaptığımızda
// ise bize hata mesajı verecektir. 

    }

    public static void main(String[] args)
    {
        printStatic();
    }
}

Static Metodlar Overloading ve Overriding Edililir mi?

Overloading ve Overriding Nesne Yönelimli Programlama ve buna bağlı olarak Polymorphsim’in en önemli unsurları arasında yer alıyor. Bu konularla ilgili sitemizde yer alan diğer yazılarda da ifade ettiğimiz üzere;

static metotlar, overloading kurallarına bağlı kalmak şartıyla overloading edilebilirler. Fakat oluşturulan tüm metotların static olma konusunda bir birine uyması gerekir. Yani ana metodumuz static ise diğer metotların da static olması gerekir.

Overriding’de ise durum bunun tersidir. Yani static metotlar overriding edilemezler, zira overriding işlemini objelerden bağımsız düşünmek mümkün değildir.

Static Blok ve Static Class

C++, C# dillerinde olduğu gibi Java da özel kod bloklarının static olarak etiketlenmesine izin vermektedir. Bu kod blokları genellikle, static bir data ile ilişkilidir. Örneğin, static değişkenlerinizi çalıştırmadan önce onları static bir blok içerisinde hesaplayabilir daha sonra main metot içerisinde çalışmasını sağlayabilirsiniz.

class Main
{
    // static değişkenler
    static int a = 10;
    static int b;

    // static blok
    static {
        System.out.println("Static blok çalıştırıldı.");
        b = a * 4;
    }

    public static void main(String[] args)
    {
        System.out.println("Main Metod: ");
        System.out.println("Değer a : "+a);
        System.out.println("Değer b : "+b);
    }
}

Bir class yalnızca nested class olursa static olarak nitelendirilebilir. Bunun dışında bir class static olarak etiketlenemez.

class Main{
    private static String str = "Testings.dev";

    //Static nested class
    static class NestedClass{
        //non-static method
        public void goster() {

            System.out.println("NestedClass dışında yer alan static string: " + str);
        }

    }
    public static void main(String args[])
    {
        Main.NestedClass obj = new Main.NestedClass();
        obj.goster();

    }
}

Static ve Non-Static Farkları

Static olan ve static olmayanlar arasındaki farkları şu şekilde sıralamak mümkün;