Java’da Sınıf ve Nesne Kavramı

Nesne Yönelimli Programlama (Object-Oriented Programming – OOP), modern yazılım geliştirme dünyasında karmaşık sistemleri yönetilebilir parçalara ayırmak için kullanılan en yaygın yaklaşımdır. Java dili de tamamen bu mimari üzerine kurgulanmıştır. Java ekosisteminde yazılan neredeyse her kod parçası bir sınıfın içinde yer alır ve çalışma zamanında bu sınıflardan türetilen nesneler üzerinden işlenir. Bu yapıyı tam anlamıyla kavramak, yalnızca temel Java yazmayı değil, ileri seviye tasarım desenlerini ve mimari yaklaşımları anlamayı da kolaylaştırır.

Sınıf (Class) Nedir?

Sınıf, gerçek dünyadaki bir varlığın, bir sistem bileşeninin ya da soyut bir sürecin yazılım ortamındaki şablonudur. Bir sınıf; nesnelerin hangi özelliklere (alanlar/fields) ve hangi işlevlere (metotlar/methods) sahip olacağını önceden tanımlayan kurallar bütünüdür.

Mühendislik dünyasından bir benzetme yaparsak; bir sınıf, inşa edilecek bir sunucunun veya bir binanın teknik çizim planıdır. Planda binanın kaç odasının olacağı, kapıların konumu ve kablolama kanalları bellidir. Ancak bu plan üzerinde yürüyemez veya içinde bir işlem çalıştıramazsınız. Plan yalnızca ortaya çıkacak yapının özelliklerini belgeler. Java’da da sınıf tek başına canlı bir veri taşımaz; yalnızca üretilecek verinin biçimini belirler.

Bir Sınıfın Temel Bileşenleri

Bir Java sınıfı genel olarak üç ana bileşenden meydana gelir:

• Alanlar (Fields): Nesnenin durumunu (state) saklayan değişkenlerdir.
• Metotlar (Methods): Nesnenin gerçekleştirebileceği işlevleri (behavior) tanımlayan fonksiyonel bloklardır.
• Kurucu Metotlar (Constructors): Nesne ilk kez oluşturulurken çalışan ve nesneye ilk değerlerini atayan özel bloklardır.

Aşağıdaki kod bloğunda temel bir sunucu donanımını modelleyen bir sınıf tanımı yer almaktadır:

public class Sunucu {
    String hostname;
    String ipAdresi;
    int ramMiktariGB;
    boolean calisiyorMu;

    void baslat() {
        calisiyorMu = true;
        System.out.println(hostname + " baslatildi. IP: " + ipAdresi);
    }

    void durdur() {
        calisiyorMu = false;
        System.out.println(hostname + " durduruldu.");
    }
}

Bu örnekte yer alan hostname, ipAdresi, ramMiktariGB ve calisiyorMu değişkenleri sunucu sınıfının durumunu belirleyen alanlardır. baslat ve durdur metotları ise bu sınıfın sahip olduğu davranışları temsil eder.

Nesne (Object) Nedir?

Nesne, tanımlanan bir sınıf şablonu referans alınarak bellekte fiziksel olarak oluşturulan somut bir örnektir (instance). Bir sınıftan ihtiyaç duyulduğu kadar bağımsız nesne türetilebilir. Türetilen her nesne, sınıfta belirtilen alanların kendi kopyalarına sahip olur ve birbirinin durumunu doğrudan etkilemez.

Plan örneğine geri dönersek; aynı sunucu planı kullanılarak veri merkezinde yüzlerce fiziksel makine kurulabilir. Bu makinelerin hepsinin donanım mimarisi aynı plana dayansa da birinin IP adresi, diğerinin adı veya o anki çalışma durumu birbirinden tamamen bağımsızdır. İşte kurulan her bir makine birer nesnedir.

Nesne Oluşturma ve Bellek Mimarisi

Java’da bir sınıftan nesne üretmek için new anahtar kelimesi kullanılır. Bu işlem sırasında bellekte iki kritik alan devreye girer:

• Stack Bellek: Nesneye erişimi sağlayan referans değişkenini ve yerel değişkenleri barındırır.
• Heap Bellek: new operatörü ile tahsis edilen nesnenin gerçek verilerini, alan değerlerini barındırır.

Aşağıdaki kod parçası, daha önce tanımladığımız Sunucu sınıfından iki farklı nesne üretir ve bunları çalıştırır:

public class Main {
    public static void main(String[] args) {
        Sunucu webSunucusu = new Sunucu();
        webSunucusu.hostname = "web-prod-01";
        webSunucusu.ipAdresi = "192.168.1.10";
        webSunucusu.ramMiktariGB = 32;

        Sunucu veritabaniSunucusu = new Sunucu();
        veritabaniSunucusu.hostname = "db-prod-01";
        veritabaniSunucusu.ipAdresi = "192.168.1.20";
        veritabaniSunucusu.ramMiktariGB = 64;

        webSunucusu.baslat();
        veritabaniSunucusu.baslat();
    }
}

Burada webSunucusu ve veritabaniSunucusu değişkenleri Stack bölgesinde tutulan birer referanstır. Bu referanslar, Heap bölgesinde bağımsız olarak yer tahsis edilmiş iki farklı Sunucu nesnesini işaret eder. Birinin bellekteki değerini değiştirmek diğerini etkilemez.

Kurucu Metotlar (Constructors)

Bir nesne oluşturulurken alanlara tek tek elle değer atamak pratik olmadığı gibi hatalara da açıktır. Kurucu metotlar, nesne örneklendiği anda devreye girerek gerekli ilk değer atamalarını zorunlu kılmak için kullanılır.

Kurucu metotların iki temel kuralı vardır:

• İsimleri sınıf ismiyle birebir aynı olmak zorundadır.
• Geri dönüş tipleri (void dahi) bulunmaz.

Geliştirici açıkça bir kurucu tanımlamazsa, Java derleyicisi arka planda parametresiz ve içi boş bir varsayılan kurucu (default constructor) tanımlar.

this Anahtar Kelimesi

Metot veya kurucu parametrelerinin isimleri sınıfın alan isimleriyle aynı olduğunda derleyicinin hangisini kastettiğimizi anlaması gerekir. this anahtar kelimesi, o an işlem yapılan geçerli nesnenin kendisine işaret eder. Böylece parametre ile alan ismi arasındaki çakışma ortadan kalkar.

Kapsamlı Uygulama: Güvenlik Duvarı Kuralı Modellemesi

Ağ güvenliği alanında sıkça karşılaşılan filtreleme kurallarını nesne yönelimli olarak modelleyelim. Bu örnek kurucu metot, this kullanımı ve nesne davranışlarını bir arada sunar:

public class FirewallRule {
    String ruleName;
    String sourceIp;
    int targetPort;
    String action;

    public FirewallRule(String ruleName, String sourceIp, int targetPort, String action) {
        this.ruleName = ruleName;
        this.sourceIp = sourceIp;
        this.targetPort = targetPort;
        this.action = action;
    }

    public void evaluateTraffic(String incomingIp, int incomingPort) {
        if (this.sourceIp.equals(incomingIp) && this.targetPort == incomingPort) {
            System.out.println("[" + this.ruleName + "] Eslesme bulundu. Uygulanan Eylem: " + this.action);
        } else {
            System.out.println("[" + this.ruleName + "] Kural eslesmedi. Paket gecirildi.");
        }
    }
}

Bu kural sınıfını çalıştırmak ve trafiği denetlemek için ana sınıfımızı oluşturalım:

public class NetworkSecurity {
    public static void main(String[] args) {
        FirewallRule sshRule = new FirewallRule("SSH-Block", "10.0.0.5", 22, "DROP");
        FirewallRule webRule = new FirewallRule("HTTP-Allow", "0.0.0.0", 80, "ACCEPT");

        sshRule.evaluateTraffic("10.0.0.5", 22);
        sshRule.evaluateTraffic("192.168.1.50", 22);
        webRule.evaluateTraffic("0.0.0.0", 80);
    }
}

Bu senaryoda FirewallRule sınıfı sayesinde güvenlik kuralları düzenli, doğrulanabilir ve yeniden kullanılabilir nesneler haline getirilmiştir. Kurucu metot aracılığıyla her nesne oluşturulurken kural parametreleri eksiksiz bir şekilde atanmıştır.

Sınıf ve Nesne Arasındaki Temel Farklar

Kavramsal kafa karışıklığını önlemek için iki terim arasındaki ayrımları netleştirmek gerekir:

• Sınıf mantıksal bir tasarımdır; nesne bu tasarımın bellekte hayat bulmuş fiziksel durumudur.
• Sınıf kaynak kod seviyesinde bildirilir; nesne ise program çalışırken new ifadesi ile dinamik olarak tahsis edilir.
• Bir sınıf projenizde bir defa yazılır; ancak o sınıftan belleğin elverdiği ölçüde sınırsız sayıda nesne üretilebilir.
• Sınıf tek başına sistem kaynaklarını (Heap alanı gibi) doğrudan tüketmez; nesne bellekte doğrudan veri kaplar.

Özet ve Sonraki Adımlar

Java’da sınıf ve nesne kavramları, uygulamanın mimari iskeletini oluşturur. Sınıflarla sistemin şablonunu çizer, nesnelerle bu şablonları yaşayan verilere dönüştürürüz. Nesne yönelimli programlamanın sunduğu esnekliği tam olarak kullanabilmek için bir sonraki aşamada alanları koruma altına alan Kapsülleme (Encapsulation), kod tekrarını önleyen Kalıtım (Inheritance) ve esnekliği artıran Çok Biçimlilik (Polymorphism) prensiplerini incelemeniz önerilir.