Primitive ve Class Type

              Java dilinde, değişkenler, temel veri tipleri olarak anılırlar. Bu anlamda Java'da iki veri tipi olduğunu söyleyebiliriz. Değişkenlerin tanımlanması için kullanılan Temel Veri Tipleri(Primitive) ve nesnelerin tanımlanması için kullanılan Referans Tipleri. C# dilinde'de bu böyledir zaten. Temel veri tipinden elde edilen değişkenler, bellekte yığın(stack) adı verilen bir bölgede tutulurlar. Oysa referans tiplerin tutuluş şekli daha farklı. Referans tipinden bir nesne, sahip olduğu üyelerin tutulduğu  bellek bölgesindeki alanların başlangıç adresine işaret eder ki bu tip nesneler yığında tutulurken, sahip oldukları içerik öbekte(heap) tutulur.


              Burada aslında önemli bir noktada her veri tipi için bir sınıfın var olması. Dolayısıyla bir değişken tanımlamasını iki şekilde yapma imkanına sahibiz. Örneğin aşağıdaki kod parçasında, int (integer-tamsayı) veri tipinden iki değişkenin farklı şekillerde tanımlandığını görüyoruz.


public class DegTan
{
    public static void main(String[] args)
    {
        int deger1=45;
        Integer deger2=new Integer(50);

        System.out.println("deger1 "+deger1);
        System.out.println("deger2 "+deger2);
    }
}

       Bu uygulamayı çalıştırdığımızda aşağıdaki sonucu elde ederiz.

deger1   45

deger2   50

     Sonuçta iki tane integer tipinde değişken tanımladık ancak bu tanımlamalar arasında büyük farklar var. Bu durumda deger2 değerinin bellekte tutuluş şekli, deger1'den farklı olmaktadır. Diğer yandan tüm temel veri tiplerinin birer sınıfı mevcuttur ve bu sınıflar java.lang adı verilen bir pakette bulunmaktadırlar.

      Bunu açıklamak için örnekler geliştirmek sanıyorum ki en doğrusu olucaktır. Bu örnekte yapmak istediğim, bir sınıf hazırlamak ve bu sınıf içinde değişkenler tanımlamak. Sonra  bu sınıfa ait bir nesne örneği yaratacak ve onu aynı sınıftan türetilen başka bir sınıfa atayacağım. Bu işlemlerin gerçekleşmesi halinde bellekteki oluşucak hareketleri ise şekille göstermeye çalışacağım. Öncelikle örneğimi geliştireyim. İlk önce nesnelerim için kullanacağım sınıfımı oluşturuyorum.

public class Sinifim
{
    public int Deger1;
    public int Deger2;

    public Sinifim()
    {
        Deger1=0;
        Deger2=0;
    }

    public Sinifim(int d1,int d2)
    {
        Deger1=d1;
        Deger2=d2;
    }

    public void Yaz()
    {
        System.out.println("Deger1 :"+Deger1);
        System.out.println("Deger2 :"+Deger2);
    }
}


public class Program
{
    public static void main(String args[])
    {
        Sinifim sf1=new Sinifim(10,20);
        System.out.println("Sf1 nesnesi için");
        sf1.Yaz();

        Sinifim sf2=new Sinifim();
        System.out.println("Sf2 nesnesi için");
        sf2.Yaz();

        System.out.println("sf1 nesnesi, Sf2 nesnesine aktarılıyor");
        sf2=sf1;
        sf2.Yaz();

    }
}

Bu kodlarla göstermek istediğim, referans tipleri arasındaki atamalar sonucu oluşan ilişkidir. Program içinde, önce sf1 isimli bir nesne örneği oluşturuluyor ve bu nesne içindeki Deger1 ve Deger2 integer değişkenlerine 10 ile 20 değerleri atanıyor. Bu durumda belleğin durumu aşağıdakine benzer olucaktır.

Daha sonraki adımda ise, sf2 isimli başka bir Sinifim nesne örneğini oluşturuyoruz. Bu kez nesneyi, Sinifim sınıfının varsayılan yapıcı metodu ile oluşturuyor ve değişkenlerimize 0 değerini atıyoruz. Bu halde, belleğin durumu şu şekilde olucaktır. Bellekte Sinifim, sınıfı türünden iki adet nesne örneği mevcuttur.

Buraya kadar herşey normal. Ancak son adımda, sf1 , nesnesini sf2 nesnesine atıyoruz. İşte bu durumda olay biraz daha değişik bir hal oluyor. Nitekim, sf1 nesnemiz artık sf2 nesnemize işaret ediyor.

Şimdi örneğimizi biraz değiştirelim ve Sinifim sınıfına aşağıdaki DegerAta isimli metodu ve kod satırlarını ekleyelim.

public void DegerAta(int d1,int d2)
{
    Deger1=d1;
    Deger2=d2;
}

Şimdide Program sınıfına aşağıdaki kod satırlarını ekleyelim.

sf1.DegerAta(1,2);
sf1.Yaz();
sf2.Yaz();

Bu haldeyken, Program dosyasını çalıştırdığımda, her iki nesne örneğininde aynı değerleri yazdırdığını görürüz. Bu şu anlama geliyor. Atama işleminden sonra, öbekteki aynı bölgeyi işaret eden bu iki nesneden birisinin içindeki değerlerin değiştirilmesi, diğer nesneninde aynı değişiklikleri işaret etmesi anlamına gelmektedir. Sonuç aşağıdaki gibi olucaktır.

Değişkenler arası atamalara gelince. Burada durum referans tiplere göre daha farklı. Çünkü değişkenler oluşturuldukları isim ile bellekte tutulur. Kısa ve basit bir örnek bize yeterli olucaktır sanırım.

public class Program2
{
    public static void main(String args[])
    {
        int Deger1=50;
        int Deger2=0;

        System.out.println("Deger1 :"+Deger1);
        System.out.println("Deger2 :"+Deger2);

        Deger2=Deger1;
        System.out.println("Deger1 :"+Deger1);
        System.out.println("Deger2 :"+Deger2);

        Deger1=48;
        System.out.println("Deger1 :"+Deger1);
        System.out.println("Deger2 :"+Deger2);

    }
}

Şimdi uygulamamı çalıştırdığımda aşağıdaki sonuçlar ile karşılaştım.

          İlk olarak Deger1 ve Deger2 değişkenlerimizi tanımlıyor ve bunlara ilk değer olarak sırasıyla 50 ve 0 değerlerini atıyoruz. Bu noktada belleğin durumu aşağıdaki tasvirde olduğu gibi olucaktır. İki ayrı integer tipte değişken belleğin yığın bölgesinde yerlerini almıştır.

Daha sonraki adımda ise, Deger1 değişkeninin değeri Deger2'ye atanıyor. Bu durumda Deger1'in sahip olduğu 50 değeri, Deger2 değişkenine atanmış ve belleğin görünümü aşağıdaki şekilde olmuş oluyor.

Son adımda ise, Deger1' değişkenine 48 değerini atıyoruz ve bellekteki Deger1 değişkeninin değerinin değişmesine neden oluyoruz. Referans tiplerinde olduğu gibi, değişken tanımlamalarında, atamadan sonraki değişiklikler, değişkenlerin birbirlerini etkilemesine neden olmamaktadır.

Sanıyorumki değişken tipleri ve referans tipleri arasındaki farkları daha iyi anladık.