Conrad

E-Güven: (4/100)

Java ile Programlama (24 Bölümlük Ders)


İstanbulda soğuk bir kış günüydü, odamın camından lapa lapa yağan kar yağışını seyrediyordum. Her yer bembeyaz olmuştu. Evden çıkmak bile bu tipide delilik olurdu. Ama gelişmelerin beni evden çıkartacağını bilemezdim. Elimdeki bir fincan kahveyi yudumlarken, aklıma bugüne kadar uğraştığım programlama dilleri geldi. Üniversitede Delphi, sonra C++ ve son olarakta C#. Aralarda ufak çaplı olsada, Visual Basic ilede ilgilenmiştim. Son kahvemden bir yudum daha aldım ve aklıma ilginç bir fikir geliverdi. Neden Java ile hiç uğraşmamıştım. C dilinin kurallarına ve yazım tarzına çok benzeyen gerçek anlamda nesne yönelimli, performansı yüksek, platform bağımısız olan bir dil.

__________________

Conrad

E-Güven: (4/100)

Geçtiğim hafta boyunca, Java ile ilgili kaynakları ve dökümanları incelemeye devam ettim. Her programlama dili için olmassa olmaz gerekli olan bir takım temel bilgileri araştırıyordum. Bunlar bir programcı için, dilin temel kullanımında ihtiyacı olduğu materyallerdir. Genelde her programlama dili için bunlar gereklidir. Ancak elbette bunlar programlama dilleri arasında farklılık gösterebilir. Bahsettiğim konu, değişkenler, koşullu ifadeler ve döngüler. Bu kahve molasında bunları işlemeye çalışacağım.

Java programlama dilinde değişkenlerin neler olduğunu bir tablo halinde hazırladım. Genelde programlama dilllerinde bu tip değişken tipleri hep tablolar halinde sunulur. Değişkenleri sıkça kullandıkça, bunların alt sınır, üst sınır ve alan büyüklükleri gibi bilgileri zamanla unutabiliriz. Şahsen ben hep unuturum. Ancak programlarımızı hazırlarken nerede en uygun değişken kullanılır bunuda bilmek isteriz. Ben oldum olası bu tip tabloları ezberleyemem. Zaten ezberleme taraftarı değilim. O nedenle bir sürü not defterim vardır ve taşıdığım çanta genelde ağır olur. Java dilinde kullanılan değişkenler içinde aynı şeyleri hissediyorum. Sanıyorumki bir tablo hazırlayacağım ve bunun güzel bir karton baskısını yanımda taşıyacağım.
Esasen 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ımanması 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 adı verilen bir bölgede tutulurlar. Oysa referans tiplerin tutuluş şekli daha farklı. Referans tipinden bir nesne, sahip olduğu üyülerin tutulduğu bellek bölgesindeki alanların başlangıç adresine işaret ederki bu tip nesneler yığında tutulurken, sahip oldukları içerik öbekte tululur. Java programlama dilinde Temel Veri Türleri aşağıdaki tabloda olduğu gibidir.



Görüldüğü gibi temel veri tipleri bunlar. Aslında bu tabloda birde alt aralık ve üst aralık bilgilerinin olması gerekiyordu. Ancak bunlar genelde kaynaklarda üstsel bilgi olarak gösterilmiş. Gerçekte, bu veri tiplerinin en üst ve en alt sınır bilgilerini küçük bir program kodu yazarakta öğrenebilirim. İşte küçük programım.
public class Sinirlar
{
public static void main(String[] args)
{
System.out.println("Integer veri tipi");
System.out.println("Integer alt sınır :"+Integer.MAX_VALUE);
System.out.println("Integer ust sınır :"+Integer.MIN_VALUE);
System.out.println("---");

System.out.println("Double veri tipi");
System.out.println("Double alt sınır :"+Double.MAX_VALUE);
System.out.println("Double ust sınır :"+Double.MIN_VALUE);
System.out.println("---");

System.out.println("Float veri tipi");
System.out.println("Float alt sınır :"+Float.MAX_VALUE);
System.out.println("Float ust sınır :"+Float.MIN_VALUE);
System.out.println("---");

System.out.println("Long veri tipi");
System.out.println("Long alt sınır :"+Long.MAX_VALUE);
System.out.println("Long ust sınır :"+Long.MIN_VALUE);
System.out.println("---");

System.out.println("Short veri tipi");
System.out.println("Short alt sınır :"+Short.MAX_VALUE);
System.out.println("Short ust sınır :"+Short.MIN_VALUE);
System.out.println("---");

System.out.println("Byte veri tipi");
System.out.println("Byte alt sınır :"+Byte.MAX_VALUE);
System.out.println("Byte ust sınır :"+Byte.MIN_VALUE);
System.out.println("---");
}
}
Şimdi yazdığım uygulamayı Java Derleyicisi ile derliyorum. Hayret, her hangibir hata vermeden derledi. Daha sonrada programı çalıştırıyorum. Sonuç gayet güzel oldu. Tam istediğim gibi, temel veri türlerine ait alt ve üst sınır değerlerini elde etmeyi başardım. Bunu yaparken, bu veri tipleri için Java içinde geliştirilmiş hazır sınıfları kullandım. Örneğin int veri tipi için Integer sınıfını kullandım. Aslında tüm temel veri tipleri için sınıflar mevcut. Tek yaptığım bu sınıfların MAX_VALUE ve MIN_VALUE özelliklerinin değerlerini ekrana yazdırmak oldu. Bu kadar basit.



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 sahibim. Ö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ığımda aşağıdaki sonucu elde ettim.



Sonuçta iki tane integer tipinde değişken tanımlamıştım, ancak bu tanımlamalar arasında büyük farklar olduğuna inanıyorum. Şimdi bunu araştırmam gerektiğini düşünüyorum. İlk başta gözüme çarpan, Integer sınıfını kullanarak, integer tipte veriyi barındıran Deger2 isimli bir nesne tanımlamamız. 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. Kaynaklardan edindiğim bilgiye göre, burada adı geçen paket kavramının, C#’taki namespace (ad alanı) kavramı ile aynı olduğu sonucuna vardım. Bu bilgiye ulaşmak benim için internette biraz zaman harcamak ile gerçekleşti. Java için herzaman elimizin altında bulunması gereken yardım dokumantasyonu olan Java 2 Platform Std.Ed. Documentation v1.3.1’ i
[Bu Linki Görüntüleyebilmeniz İçin Üye Olmanız Gerekiyor. ]
adresinden indirdim. Bu döküman yaklaşık olarak 22 megabyte’lık bir zip dosyası. Açıldığında, html dokumatasyonuna ulaşabiliyorsunuz. Burada aradığım hemen her konuya ait bilgi mevcut. Ancak bazı konuların yanında web pages yazılı. Bunlar internetten online olarak bakılabilecek yada indirilebilecek adreslere işaret ediyor. İşte, java.lang paketinin içeriğinede bu dokmantasyondan ulaştım. Temel veri tiplerine ait sınıfları kullanarak pek çok fonksiyonu kullanma şansına sahip olduğumu gördüm. Örneğin, ilk örneğimizde kullandığımız MAX_VALUE ve MIN_VALUE özellikleri gibi. Yada integer değeri String’e dönüştürmek için kullanılan toString metodu ve daha pek çok sayısız metod yer alıyor.
Bir diğer konuda, Java’daki temel veri türünden değişkenler ile, referans türünden nesneler arasındaki temel farklılıklar. Burada önemli olan konu, bu iki veri türününde bellekte farklı şekillerde tutuluyor olması. Temel veri türünden olan değişkenler bellekte kendi isimleri ile stack(yığın) adı verilen bölgede tutuluyorlar. Referans tipinden olan nesneler ise, belleğin heap(öbek) adı verilen bölgesinde tutuluyor. Tanımlanan referans tipindeki nesne, öbekte yer alan verilerine işaret eden ve yığında tutulan bir değişken adına sahip oluyor. Bu kavramlar aslında karmaşık gibi görünsede, nesneler arasındaki atamalarda önemli sonuçlar doğuruyor. Bunu açıklamak için örnekler geliştirmek sanıyorumki 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);
}
}

Doğruyu söylemek gerekirse bu kodlar bize çok şey söylüyor. Buradaki kodları tamamen C#’taki bilgimi kullanarak yazdım. Örneğin sınıfı tanımlaması içinde, iki adet yapıcı (constructor) metod var. İlki Deger1 ve Deger2 isimli değişkenlerimize 0 değerlerini atıyan parametre almayan ve sınıflar için varsayılan olarak kabul edilen yapıcı metodumuz. Diğeri yapıcı metodumuz ise, bu değişkenlere aldığı parametre değerlerini atıyor. Birde Yaz isimli bir metodumuz var. Bu metod ise, sınıfımızın Deger1 ve Deger2 isimli integer değişkenlerini komut satırına yazdırıyor. Yapıcı metodların kullanımı, sınıflar içindeki yeri gibi kavramlara şimdilik göz ucu ile bakmış oldum. Bu kavramları ve daha fazlasını diğer kahve molalarımda incelemek istiyorum. Hazır kahve demişken, kahvemi tazelesem iyi olucak sanırım. Gelelim diğer sınıfımıza. Bu sınıfımız ise Sinifim sınıfı türünden nesneler üzerinde işlem yapmak için kullanılıyor.

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 durumunun tasviri 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. Bu konuyuda bir örnek üzerinde incelemek taraftarıyım. 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;

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);

}
}
Kodu derlediğimde hiçte beklemediğim bir hata ile karşılaştım.



Sanıyorumki hatanın sebebi Deger2 isimli integer veri tipindeki değişkene ilk değer atamasını yapmamış olmamdı. Bu durumda kodun bu satırını aşağıdaki gibi değiştirdim ve programın başarılı bir şekilde derlendiğini gördüm.
int Deger2=0;
Şimdi uygulamamı çalıştırdığımda aşağıdaki sonuçlar ile karşılaştım.




Şimdi kodu güzelce bir incelemem gerektiğini düşünüyorum. Kahvemden bir yudum aldım ve Javaca düşünmeye başladı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. Evet alet çantamızı doldurmaya devam edelim. Bizim için gerekli olan diğer önemli ve hatta çok önemli unsurlar koşullu ifadeler ve döngülerdir. Bu her programlama dili için böyledir. Öncelikle karşılaştırma ifadelerine bir göz atmak istiyorum. Karşılaştırma ifadelerimiz bana nedense çok tanıdık geliyor. If ve Switch. Bu ifadelerin kullanımını örnekler ile incelemek taraftarıyım. Öncelikle if koşul ifadesini incelemek istiyorum.

public class Kosullar
{
public static void main(String args[])
{
int Not;
Not=49;
if(Not>50)
{
System.out.println("Sınıfı geçtin...");
}
else if((Not>45)&&(Not<50))
{
System.out.println("Kanaat kullanmalımıyım bakayım?");
}
else
{
System.out.println("Sınıfta KALDIN?");
}
}
}

Aslında her şey çok açık ve ortada. If koşulları parantezler içinde yazılır ve karşılaştırma sonucu true ise hemen izleyen { } kod bloğu içindeki kodlar çalıştırılır. Eğer bu şart false ile sonuçlanır yani gerekli koşul sağlanmaz ise, varsa bir sonraki else koşuluna geçilir. Burada kullanmış olduğumuz bir takım karşılaştırma operatörleride mevcut. Java’da kullanılan karşılaştırma operatörlerü aşağıdaki tabloda yer almaktadır.

__________________

Conrad

E-Güven: (4/100)

Diğer yandan ifadelerimizin birisinde && kullandık. Bu mantıksal VE anlamına gelen bir operatördür. Bu tip mantıksal operatörleri, iki veya daha fazla koşulun sonuçlarını bir arada değerlendirmek istediğimizde kullanırız. Bu örneğimizde mantıksal operatörümüz, belirtilen iki şartında doğru olması şartıyla izleyen kod bloğundaki kodları çalıştırmaktadır. Java’da kullanılan mantıksal operatörler aşağıdaki gibidir.

Kaynaklardan mantıksal operatörlerden && ve || için farklı bir kullanım tarzı daha olduğunu öğrendim. Buda & ve | operatörleri. Bu iki kullanım tarzı arasındaki farkı incelediğimde oldukça işe yarar bir sonuçla karşılaştım. && ve || operatörleri, her iki koşulunda işleme sokulmasını sağlar. Ancak bazen ilk koşulun true olması yada false olması sonucu belirlemek için yeterlidir. Böyle bir durumda her iki koşuluda karşılaştırmaktansa, yani koşul ifadesindeki tüm kodu çalıştırmaktansa, & ve | operatörlerini kullanarak, sadece soldaki koşula bakılmasını ve buna göre karar verilmesini sağlayabiliriz. Gelelim switch koşullu ifadesinin kullanımına. Bunuda yine bir örnekle incelemek en güzeli.
public class Kosullar
{
public static void main(String args[])
{
int Deger1=3;

switch(Deger1)
{
case 1:
{
System.out.println("Birinci sınıf nesnesi oluştur.");
break;
}
case 2:
{
System.out.println("Ikinci sınıf nesnesi oluştur.");
break;
}
case 3:
{
System.out.println("Ucuncu sınıf nesnesi oluştur.");
break;
}
default:
{
System.out.println("Ana menuye don.");
break;
}
}
}
}
Aslında buraya kadar herşey çok hızlı gelişti. Nitekim kullanılan materyaller C dilinden gelmekte ve C# dili içindede aynen kullanılmakta. Bu nedenle bir C# programcısı için Java’yı öğrenmek veya bir Java programcısı için, C# dilini öğrenmek hızlı oluyor diyebilirim. Neyse kahvemizi yudumlamaya devam edelim.
Sırada döngüsel ifadeler var. Bazen bir işlemi birden fazla sayıda uygulamak isteyeceğimiz durumlar olabilir. Gauss eğer bir bilgisayara sahip olsaydı inanıyorum ki 1’den 100’e kadar olan sayıların değil 1’den 1000’e kadar olan sayıların 4ncü dereceden kuvvetlerinin toplamını bulan bir uygulama geliştirir ve bizi Gauss formüllerini ezberlemekten kurtarırdı. Sanıyorum programlama dillerini geliştirenler Gauss’un çektiklerinden çok, okul yıllarında matematik sınavlarındaki Gauss formüllerini hatırlayamamaktan çekmişler. Burada, for döngüsü kullanarak bu işlemin nasıl gerçekleştiğini incelemeye çalışacağım. Burada üs almak için, Java içinde yer alan Math sınıfına ait pow isimli metodu kullandım.
public class Dongu
{
public static void main(String args[])
{

double Toplam=0;

for(int i=1;i<=1000;i++)
{
Toplam=Toplam+(Math.pow(i,4));
}

System.out.println(Toplam);
}
}


For döngüsü dışında iki döngü çeşidi daha vardır. Bunlar while döngüleridir. İki çeşit while döngüsü vardır. Bunlardan birisi, ilk başta koşulu kontrol eder ve koşul sağlanıyorsa döngü içindeki kodları çalıştırır. Diğer çeşidinde ise, döngü içindeki kodlar en az bir kere çalışır ve koşul sonradan kontrol edilir. Her iki döngüde koşullar sağlandığı sürece devam eder. Örneğin yukarıdaki uygulamamızı while döngüsü kullanarak gerçekleştirelim.


Toplam=0;
int i=1;
while(i<=1000)
{
Toplam=Toplam+(Math.pow(i,4));
i++;
}
System.out.println(Toplam);
While döngümüzün diğer şekli ilede bu döngüyü yazabiliriz.
Toplam=0;
int j=1;
do
{
Toplam=Toplam+(Math.pow(j,4));
j++;
}
while(j<=1000);
System.out.println(Toplam);
Artık hakiki bir mola vermenin zamanı geldi sanırım. Bu kahve molasında, alet çantamızı iyice doldurduk. Ancak bu çantaya doldurmamız gereken daha çok parça olduğu kesin

__________________

Conrad

E-Güven: (4/100)

Şuanda sabahın saat 3 buçuğu ve yeni hazırladığım sıcak kahvemi yudumlarken, Java ile ilgilenmekten saatın ne kadar geç olduğunun farkına bile varamadım. Geçen hafta boyunca, Java programlama dilinin temellerini incelemeye devam ettim. Doğruyu söylemek gerekirse, sıkıcı olan bir kaç konu inceledim. Bunlardan birisi dizilerdi.
Hemen her programlama dilinde olduğu gibi dizilerinde java�da sıkıcı bir yeri var. Sıkıcı olmasını nedeni belkide, veri saklama ile ilgili olarak günümüz teknolojilerinin getirdiği veritabanı, xml, gelişmiş koleksiyonlar gibi kavramların çok daha fazla tercih ediliyor olması. Ancak ne olursa olsun, hangi programlama dili olursa olsun ve kavramları ne kadar sıkıcı olursa olsun, bunları bilmekte, incelemekte fayda var.Bu sabah saatlerindeki kahve molamda, dizilerin Java programlama dili içindeki yerini incelemeye çalışacağım. Bir diziyi belkide en güzel şu şekilde tanımlayabiliriz.
Dizi, belli bir sayıda ve aynı veri türünden değişkenlere, aynı isim altında erişilmesini sağlayan bir referanstır. Aslında bu tanım içerisinde çok geniş kavramlar var ve açıklanması gerekli. Herşeyden önce, dizilerin referans olduklarını söylüyor. Java dilindede, C#�ta olduğu gibi diziler referans tipli verilerdir. Dolayısıyla bir dizi, belleğin yığın (stack) kısmında tutulurken, dizi elemanlarının tamamı, öbek (heap)�te yer alır. Yani dizinin adı, öbekteki elemanların başlangıç adresine işaret eder. Bu dizilerin en önemli unsurlarından birisidir. Diğer yandan, diziler aynı veri türünden elemanlara sahip olmalıdır. Bununla birlikte dizilerin eleman sayısıda oluşturulurken belirlenir. Dolayısıyla, bir diziyi en baştan boyutlandırdığımızda, beliltilen sayıda elemanı aktarabiliriz ve buda dizinin boyutu ile dinamik olarak oynamamızı engeller. Doğruyu söylemek gerekirse bu kısıtlamalar belkide C# dilinde koleksiyonları geliştirilmesine ve daha çok önem kazanmasına neden olmuştur. Kimbili belki Java dilinde�de koleksiyonlar var. Şimdilik karşıma çıkmadılar.
O halde işe referans veri tipi olan dizilerin nasıl tanımlanacağından başlamak gerekiyor. Referans tipli olması, dizilerin oluşturulurken new yapılandırıcı kullanılarak oluşturulması gerektiği sonucunu ortaya çıkartıyor. Nitekim, diziler referans tipli nesnelerdir. Dolayısıyla bir sınıf örneği olmak zorundalar. Ancak diğer yandan, bir diziyi oluştururken new yapılandırıcısını kullanmak zorunda değiliz. Dizi elemanlarına, 0 tabanalı bir indis sistemi ile erişebilmekteyiz. Bu anlamda dizilerin, döngüler ile kardeş olmalarını gayet iyi anlayabiliyorum. Şimdi dizi kavramını incelemek için basit ama hızlı bir örnek geliştirmek düşüncesindeyim. Kahvemden bir yudum alıyorum ve aşağıdaki örneği yazıyorum. public class Dizi
{
public static void main(String[] args)
{
int dizi1[]=new int[10];
for(int i=0;i<dizi1.length;++i)
{
dizi1[i]=i*2;
System.out.println((i+1)+". eleman="+dizi1[i]);
}
}
}
Uygulamayı başarı ile derledikten sonra çalıştırdığımda aşağıdaki sonucu aldım.



Kodların çalışma sistematiği oldukça basit. Diziyi tanımlaka için new yapılandırıcısını kullandık ve dizinin integer veri tipinden 10 elemanlı olmasını sağladık. Bu noktadan sonra dizimize elemanlar atamak için bir döngü kullandık. Bu döngü dizimizin boyutuna kadar hareket eden ve her bir elemana indis değerinin iki katını aktaran bir yapıda. Kullandığımız length özelliği, dizilerin boyutunu elde etmekte kullanılmakta. Buradanda zaten, dizilerin bir Java sınıfına ait olduğu sonucuna varabiliriz. Kodumuzda, dizi elemanlarını okumak içinde aynı döngü içindeki dizi1[i] şeklindeki yazımı kullandık. Dizileri yukarıdaki örnekte olduğu gibi new yapılandırıcısı ile tanımlayabileceğimiz gibi, başka alternatif bir yoluda kullanabiliriz. Benzer bir örnek uygulam aşağıda yer alıyor.
public class Dizi2
{
public static void main(String[] args)
{
int[] dizi={1,3,5,7,9,11,13,15};
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
}




Burada diziyi tanımlarken elemanlarınıda baştan atamış olduk. Bu aynı zamanda verdiğimiz eleman sayısına göre dizinin otomatik olarak boyutlandırıldığınıda göstermektedir. Son örneğimizin bellekteki yerleşim planına göz atarsak aşadıdaki tasvire benzer bir yapının oluştuğunu görürüz.



Peki ya bir diziye taımlandığı veri tipinden başka bir tipte eleman eklemeye kalkarsak ne gibi sonuçlarla karşılaşabiliriz. Doğrusu bunu merak ediyorum. Bu nedenle yukarıdaki örnekte, integer tipteki dizimize, başka bir veri tipinden eleman eklemeye karar verdim. Bu amaçla, �a� karakterini sincizce dizi elemanları arasına yerleştirdim.
public class Dizi2
{
public static void main(String[] args)
{
int[] dizi={1,3,5,7,9,11,�a�,15};
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
}
} Uygulamayı derlediğimde her hangibi hata mesajı ile karşılaşmadım. Diğer yandan uygulamayı çalıştırdığımda aşağıdaki hata mesajı beni bekliyordu.





Vouv! Hiç beklemediğim bir durum. 7nci eleman yani �a� değerinin karakter karşılığı oluvermişti bir anda. Hımm. Aslında bu istemediğim bir sonuç. Ben daha çok bir hata mesajı bekliyordum. Yoksa dizi tanımında bir tanımlama hatasımı yaptım? Denemeye devam etmeye karar verdim. Sabahın kaçı olursa olsun ben bu hata mesajını bulacaktım. Kodları aşağıdaki şekilde değiştirdim. Aklıma ilk gelen integer değilse bir double değeri buraya koymak oldu. Hatta bir tane değil bir kaç farklı veri tipinden değerler koymak.
public class Dizi2
{
public static void main(String[] args)
{
int[] dizi={1,"Selam naber",5,true,9,11,15.154654,15};
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
}
} Sonunda başardım. İstediğim hata mesajlarını aldım ve dizi tanımına sadık kaldım.




Ancak dizileri kullanırken başıma gelebilecek diğer hatalarıda incelemek istiyorum. Öncelikle dizide olmayan bir indis elemanı oluşturmak istersem veya ona ulaşmak istersem ne olur? Fazla söze gerek yok hemen kodları yazmak lazım. Bu kez 5 elemanlı bir diziye 6ncı elemanı eklemeye çalışacağım.
public class Dizi2
{
public static void main(String[] args)
{
int[] dizi={1,2,3,4,5};
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
dizi[6]=7;
}
} Uygulama yine hatası olarak derlendi. Umarım bu sefer çalıştırdığımda istediğim hatayı alabilirim. Evet. Mükemmel. Hatayı elde etmeyi başardım.



Dizileri tanımlarken, aynı veri türünden elemanları grupladığımızdan bahsetmiştik. Farklı bir durum daha vardır. Bu da bir diziyi Java dilinin en üst sınıf olan (C# taki gibi) Object türünden tanımlamak ve elemanları birer nesne olarak belirlemektir. Bu teknikte, dizinin tüm elemanları birer nesnedir. Bu anlamda bellekteki dizilişte farklı olmaktadır. Öyleki, Object türünden bir dizi tanıladığımızda, dizinin elemanları öbekte tutulurken her bir eleman nesne olduğu için, yine öbekteki asıl alanlarına referans eden değerleri taşırlar. Ancak dizi elemanlarına eriştiğimizde, bu nesnelerin referans ettikleri öbek alanlarındaki verilere ulaşılır. Hemen bununla ilgili bir örnek yapmakta fayda var.
public class DiziObject
{
public static void main(String[] args)
{
Integer eleman1=new Integer(456);
String eleman2=new String("Ben bir stringim...");
Double eleman3=new Double(45.45687);
Boolean eleman4=new Boolean(true);

Object[] dizi={eleman1,eleman2,eleman3,eleman4};
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
}
} Burada yaptığım Object türünden dizim için, new yapılandırıcılarını kullanarak sırasıyla integer, string, double ve boolean veri türlerinden birer nesne yaratmak ve daha sonra bu nesneleri Object türünden diziye aktarmak. Uygulama başarılı bir şekilde derlenicektir ve çalışacaktır.



Bu tekniğin bellekteki görünümü ise aşağıdaki tasvire benzer şekilde olucaktır



Tabi burada aynı örneği aşağıdaki şekide geliştirmeyide düşündüm ama bu durumda hata mesajları ile karşılaştım. Çünkü aşağıdaki tekniği uygulayarak bir Object dizisi oluşturmaya çalıştığımda, elemanların her biri birer değişken olarak algılandı ve Object dizisine eklenmeye çalışılmak istendi. Ancak Object türünden bir dizi, kendisi gibi nesne elemanlarını kabul edeceğinden temel veri türlerinden tanımlanmış değişlenleri kabul etmedi ve derleyici bir sürü hata mesajı verdi.
public class DiziObject
{
public static void main(String[] args)
{
Object[] dizi={456,"Ben bir stringim",45.45687,true};
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}



Ancak burada dikkat etmemiz gereken bir nokta var. O da, String tipteki "Ben bir stringim" için bir hata mesajı almamış olmamız. Bunun nedeni aslında çok açık. Nitekim String veri türü, bir referans türüdür. Dolayısıyla new yapılandırıcısı ile bir String nesnesi yaratabiliriz. Bununla birlikte new yapılandırıcısın kullanmadan yukarıdaki gibi bir string tanımlamakta yine aynı işlevi gerçekleştirecektir. Sanırım burada bir dip not olarak şu iki ifadeninde eşit olduklarını söyliyebiliriz.
String s=new String("Merhabar"); String s="Merhaba"; Gelelim diziler ile ilgili ne tür işlevleri gerçekleştirebileceğimize. Dizilerin Java�nın bir sınıfı olduğu söylemiştik. Evet, diziler aslında, java.util.Arrays sınıfının örneklenmiş nesneleridir. Geçen kahve molamdada internetten indirdiğim jsdk dökümanları içinde bu sınıfı aradım ve sayısız pek çok metodunun olduğunu gördüm. Bunların hepsini incelemek için sanıyorumki bir kaç hektar kahve tarlamın olması, bunları öğütücek ve işlemden geçirerek sütlüsünü, 5 şekerlisini çıkartıp bana sunacak bir fabrikam olması gerekiyor. Ama sanıyorumki bu kahve molasında en çok işime yarayacakları incelesem iyi olur. İlk gözüme çarpan aynı isimli metodlardan hemen her veri türü için aşırı yüklenmiş varyasyonların oluşuydu. Örneğin sort metodunu ele alalım. Adındanda anlaşılacağı üzere bu metod dizi elemanlarını sıralıyor. Elbette dizinin tipine bağlı olarak gerçekleştirilen bir sıralama bu. Aşağıdaki örnekte, integer değerlerden oluşan bir diziyi şu metod prototipini kullanarak sıralattım.
public static void sort(int[] a) Şimdide kodlarımızı yazalım.
import java.util.*;

public class DiziSirala
{
public static void main(String[] args)
{
int[] dizi={8,6,3,56,12,3,1,0,23,-1,-5};
System.out.println("Siralanmamis Hali");
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
System.out.println("");
System.out.println("Siralanmis Hali");
Arrays.sort(dizi);
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
}




Burada öncelikle Arrays.sort metodunu kullanarak sıralam işlemini yapmak için, java.util paketini import anahtar kelimesi ile uygulamamıza ekledik. Bu C# taki namespace�lerin using ifadesi ile eklenmesi ile aynı şey. Integer veri türleri için tasarlanmış bu metodun diğer veri türleri için aşırı yüklenmiş versiyonlarıda mevcut. Burada metodumuz parametre olarak dizinin adını alıyor ve dizinin tipine bakarak uygun olan sort metodunu çalıştırıyor. Sort metodunun bir diğer versiyonuda aşağıda prototipi verilen versiyondur.
public static void sort(int[] a,int fromIndex,int toIndex) Bu aşırı yüklenmiş versiyona göre, dizinin sadece belirli indisler arasındaki elemanlarının sıralanmasını sağlamış oluyoruz.Bunu yukarıdaki örneğimize uygularsak;
import java.util.*;

public class DiziSirala
{
public static void main(String[] args)
{
int[] dizi={8,6,3,56,12,3,1,0,23,-1,-5};
System.out.println("Siralanmamis Hali");
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
System.out.println("");
System.out.println("Siralanmis Hali");
Arrays.sort(dizi,5,10);
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
}




Bir diğer ilginç metod ise BinarySearch metodu. Sort metodunda olduğu gibi bu metodda diğer tüm veri türleri için aşırı yüklemiş. Prototipi aşağıdaki gibi olan bu metod, dizi içindeki bir elemanın var olup olmadığına bakıyor ve buna göre bir sonuç döndürüyor.
public static int binarySearch(int[] a,int key) Şimdi bu metod ile ilgili bir deneme yapmanın tam sırası. import java.util.*;

public class DiziBul
{
public static void main(String[] args)
{
int[] dizi={8,6,3,56,12,3,1,0,23,-1,-5};
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
System.out.println("");
int sonuc=Arrays.binarySearch(dizi,56);
System.out.println("Arama sonucu "+sonuc);
}
} İlk sonuçlar hiçte iç açıcı olmadı benim için. Herşeyden önce aşağıdaki gibi anlamsız bir sonuç elde ettim.




Dökümantasyonu yeniden incelediğimde herşeyin sebebi anlaşılıyordu. BinarySearch metodunu kullanabilmem için, dizinin mutlaka sıralanmış olması gerekiyor. Bu nedenle koda, sort metodunuda ekledim. Bu durumda, dizimizin sıralanmış hali üzerinden arama işlemi başarılı bir şekilde gerçekleştirilmiş oldu. BinarySearch metodunun çalıştırılıması sonucu dönen değer, aradığımız elemanın dizi içindeki indis numarasıdır.
import java.util.*;

public class DiziBul
{
public static void main(String[] args)
{
int[] dizi={8,6,3,56,12,3,1,0,23,-1,-5};
for(int i=0;i<dizi.length;++i)
{
System.out.println((i+1)+". eleman="+dizi[i]);
}
System.out.println("");
Arrays.sort(dizi);
int sonuc=Arrays.binarySearch(dizi,56);
System.out.println("Arama sonucu "+sonuc+".eleman"+dizi[sonuc]);

__________________

Conrad

E-Güven: (4/100)

Pazar sabahları ne yaparsınız? Peki bir bilgisayar programcısı olsanız ne yaparsınız? Muhtemelen, cumartesi gecesinin sabaha kadar süren çalışmalarından başınızı kaldıramadığınız için, bütün gün uyumak isteyebilirsiniz. Ben çoğunlukla ve düzenli olarak, İstanbul Bostancı sahilinde çok erken saatlerde yürüyüş yaparım. Sabah 6 ile 7 arası inanılmaz bir huzur bulurum burada. Bir yandan denizden gelen tertemiz iyotlu hava, diğer yandan sessizlik, martı seslerinin ahengi ve göz kamaştırıcı güzelliği ile İstanbul boğazının Marmara denizi ile kucaklaşması. Matematikçi olmamın bana verdiği kazanımlardan birisi, etrafta olup bitenleri son derece felsefik inceleyebilme yeteneği. Sizde bilirsiniz ki tarihin en ünlü matematikçileri mantık, sosyoloji, felsefe, psikoloji gibi bilimlerle hep yakından ilgilenmişlerdir. Onlardan birisi olmayı çok isterdim gerçekten. Herşeyden önce bir programcı pek çok zorlukla, hayatta karşılaştığından çok, programlarını yazarken karşılaşır. O nedenle, sağlıklı ve ruhsal açıdan huzurlu bir beden, onun bu zorlukları aşmasında en büyük yardımcıdır. Ben bu yürüyüşleri çoğunlukla kafamı boşaltmak, kendi dünyamda huzur bulmak ve gözümden kaçan ayrıntıları daha sağlıklı inceleyebilmek amacıyla yaparım. İşte bu sabahta o amaçla yapılan bir yürüyüşteyim.
Adımlarımı attıkça, ciğerlerime dolan nefis iyotlu deniz havası daha sağlıklı düşünmemide sağlıyor. Etrafıma baktığımda, her türden nesneyi daha berrak sezinleyebiliyorum. Nesne! O o! Bu lafı bana kim söyletti? Nesne...Nesne...Gerçekten de şöyle bir durdum ve etrafıma bakındım. Her yerim , ben de dahil olmak üzere nesnelerden oluşmaktaydı. Evrenin sahip olduğu gizemi ve mükemmelliği kimse inkar etmez. Çağımız boyunca ve gelecektede pek çok teknolojik, endüstüriyel, matematik yaklaşıma ilham kaynağı olmuş sistematikler içerir. Bu düşünceler ile tekrar yürümeye başladığımda, nasıl olduysa bir anda kendimi bilgisayar dillerinin gelişimini düşünürken buluverdim. Basic, pascal, C, Fortran vesaire... Sonra tekrar durdum. Aklıma C++,Java,C# gelivermişti birden bire. Hepside nesneler ile uğraşan, nesneler üzerine kurulu yapılara sahipti. Hepside Nesneye Dayalı Programlama dillerindendi.
Nesne kavramını, günümüz modern programlama dillerine kim yerleştirmiş ise eminimki benim gibi bir yürüyüş sırasında bunu yapmıştır diye düşünüyordum. Bir anda kendimi Yazılım Mimarları gibi düşünürken, ayağımı yere sürtüp tepe taklak tabir yerinde ise iki seksen yere uzandım. Allahın tokatı yoktur derler. Neyseki kendime gelmiştim. O adamların tırnağı bile olmak büyük bir onur olurdu sanırım. Evet sonuç itibariyle sabahları bu kadar erken yürümemin nedeni buydu. Tökezleyip düştüğümde etrafta kimsenin olmayışı...Sonuç itibariyle geriye dönüp baktığımda, hem programlama dillerinin nesneye dayalı hale gelmesi ile, yaşamımızın ekosistemini örnek alarak ne kadar büyük üstünlükler sağladığını düşünüyor, bir yandanda ne kadar uzağa yürümüşüm şimdi nasıl geriye dönecem diye veryansın ediyordum. Aklıma her zaman olduğu gibi parlak bir fikir geldi. Dönüşte çevremdeki nesnelerin programlama dillerindeki etkilerini düşünecektim.
Çevremizde ne kadar çok nesne var. Çiçekler, böcekler, insanlar, arabalar, otobüsler, kuşlar, taşlar, kayalar...Bu liste o kadar kabarıkki saymaya kalkmak bile sonsuzlukla çarpışmak gibi bir şey olsa gerek. Her nesnenin belli bir takım özellikleri, işlevsellikleri ve hatta amaçları var. Bazı nesneler bir araya gelerek başka yeni nesnelerin doğmasına neden olurlarken onlara bir takım ortak özelliklerinide veriyorlar. Aynı insanların bir araya gelerek evlenmesi, çocuk sahibi olması ve çocuklarına kendi özelliklerinden bir takım kalıtımlar bırakması gibi. Bazı nesneler kendi içinde kapalı, sahip olduğu değerleri değiştirilemeyen ama gözlemlenebilen türden. Bazı nesneler ufak değişikliklere uğrayarak başka nesnelere ilham kaynağı olmuşlar. Bu çeşitlilik altındaki tüm neselerin ortak özelliklerini bir arada düşünmek ve bir kenara koymak onları bu ortak niteliklerine göre sınıflandırmaktan başka bir şey değil.
Otomobilleri bir sınıf altında düşünebiliriz. Her otomobil 4 tekerlekli, motoru olan, ileri geri hareket edebilen, direksiyona sahip ve benzinle çalışan, gaza basıldığında viteste ise hareket eden, frene basıldığında duran ve bunlar gibi pek çok ortak özelliğe ve işleve sahip olan birer nesne. Ama bu sınıfa ait tüm nesneler bir birlerinden farklı olabileceği gibi birbirlerinin aynısıda olabilir. Otomobil firmalarının arabalarını düşündüğümüzde, hepsinin farklı özelliklere sahip ama temel işlevsellikleri neredeyse aynı olan nesneler olduklarını söyleyebiliriz. Hatta üretim hattından yeni çıkmış tüm gri renkli opel vectra 1.6’lar motor seri numaraları hariç birbirlerinin aynısı olan nesnelerden oluşan bir nesne koleksiyonundan başka bir şey değildir.
İşte gerçek hayattaki nesnelerin bizler için anlamı ve önemi neyse, nesneye dayalı bir programlama dili içinde nesnelerin anlamı o derece önemlidir. Herşeyden önce, bu dillerde bütün kavramlar, nesnelere ve dolayısıyla bu nesneleri oluşturmak yada örneklemek için kullanılan sınıflara bağlıdır. Düşünün ki object sınıfı değilmidir C# dilinde ve hatta Java’da en üst sınıf. Java programlama dilide tam anlamıyla nesneye dayalı bir dil. Dolayısıyla nesneleri kullanan bir dil. Nesneleri, sahip oldukları özellikleri, değerleri ve işlevleri ile kullanan bir dil. Bu düşünceler eşliğinde geri dönüş yolunu tamamladım. Artık eve dönme vaktim gelmişti. Şu andan sonra yapılacak en güzel şey, eve gitmek sıcak bir duş almak ve Pazar sabahının gazetelerini okuyup güne merhaba demekti. Ama ne yazıkki böyle olmamıştı. İçimdeki korkunç öğrenme açlığı, gazete yerine Java ile ilgili kaynakları araştırmama neden oldu. Ama her zaman olduğu gibi yanımda sıcak bir kahvem vardı.
Uzun süre camdan dışarı bakarak sınıfların yerini düşündüm ve onları daha iyi anlamaya çalıştım. Gerçektende Javada’da diğer nesneye dayalı programlama dillerinde olduğu gibi herşey sınıflar üzerine kurulu idi. Dolayısıyla sınıfları çok iyi kavramak programlama dilini öğrenirken yaşadığım süreçte çok ama çok önemliydi. Önemli olan sadece sınıfların nasıl yazıldığını öğrenmek neleri ihtiva edeceğini bilmek değildi. Sınıfları en uygun şekilde, en etkin ve verimli şekilde kullanabilmekte çok önemliydi. Söz gelimi, bu gün .net dilinde, veritabanlarındaki veriler ile çalışmak için inanılmaz kabiliyetli ve yetenekli sınıflar vardı. Java içinde bunların benzerlerini yazmak istememiz bu tip sınıfları tasarlamamız anlamına geliyordu. Veya veritabanlarından okuduğumuz veri satırlarını düşünelim. Bunları birer sınıf nesnesi olarak uygulamamıza yerleştirmek , işlemlerimizi dahada kolaylaştırmazmıydı. Veritabanına bağlanır istediğimiz satıra ait verileri uygun bir sınıf nesnesine aktarır ve bunları tekrar veritabanına gönderinceye kadar bağlı olmak zorunda kalmazdık. Aynı DataSet kavramı gibi. Ama daha sade, daha kolay ve belkide daha etkili.
Elbette Java dilinde veritabanları ile ilgili ne tür işlemler yapabileceğimi ne tür kabiliyetlere sahip olduğumu şu an için bilmiyorum ama ileride bunları öğrenmek içinde can atıyorum. Ama şu an için yapacağım sınıfların nasıl oluşturulduğunu ve kullanıldığını anlamak olucak. Java dilini öğrenmeye devam ettikçe sanıyorumki sınıf kavramını çok daha iyi kavrayacağım. Gerçi, bu kavrama C# dilinden oldukça aşine ve hakimim. Ama Sun’ın belkide bilmediğim sürprizleri vardır bu konuda. Neyse deneyip göreceğiz. Normalde kendimce bu kadar çok konuşmam. Aslında daha az söz ve daha çok hareket taraftarıyımdır. Eeee atalırımız ne demiş; nerde hareket orda bereket. Tipik bir uygulamacı işte. O bakımdan makinemin başına geçip ilk sınıfımı yazsam iyi olucak sanırım.
Şimdi bir uygulama geliştirmek istiyorum. Bu uygulama hayali olarak bir tablodan bir kaç satır veri alsın istiyorum ve sonra bu verileri birer nesneye aktarmak istiyorum. Bu amaçla öncelikle kafamda hayali bir tablo tasarladım ve sonrada bu tablonun satırlarını birer sınıf nesnesi olarak nasıl tasarlayabileceğimi düşündüm. Aslında işin tasarım kısmında hep bir şeyler çizmek, düşünceleri kağıda dökmek en güzelidir sanırım. Bunun için aslında çok güzel bir yapı var. UML. Fakat ben buradaki şekilleri ezberlemekten ve unutmaktan bıktım. O nedenle başka birisine şeklimi göstermediğim sürece genelde kendi kafamda oluşturduğum çizelgeleri kullanırım. Sanırım buna ben BML diyeceğim. Diğer yandan çizdiklerimin başkaları tarafından kolayca anlaşılması içinde dikkat ediyorum.



Aslında yapmak istediğim şey çok basit. Tablodaki satırları alıp, Sınıf nesneleri haline getirmek. Bunu yaparken, tablodaki alanların değerlerini, sınıfım içinde oluşturacağım değişkenlerde saklıyacağım. Bu durumda, sınıfımdan nesneler türettikten sonra, içindeki değişkenlere değer atamamı sağlıyacak işlevlere ihtiyacım olucak. Ayrıca program içinde, bir nesneye ait bu alan değerlerini değiştirmek isteyebilirim. Bunun içinde bir veya bir kaç metoda ihtiyacım olabilir. Artık ne yapmak istediğimi bildiğime göre kodları yazmaya başlamanın zamanı geldi. Ne yazıkki yine sıkıcı Notepad editorümüze döneceğiz. Aslında buna bir çare bulmam lazım. Java programlarını yazabileceğim ücretsiz bir yazılıma ihtiyacım var. Aslında kaynaklarımdan en iyi java editörünün Borland firmasının JBuilder ürünü olduğunu öğrenmiş bulunmaktayım. Üstelik bu ürünün Personel sürmüde ücretsiz olarak dağıtılıyormuş. Sanıyorum bu öğleden sonra vaktimi ayırıp bu sürümü internetten indirmek için kullanabilirim. Ama şimdilik notepad ile devam edeceğim.
Evet öncelikle bana, oluşturacağım nesneleri örneklendireceğim bir sınıf lazım. Zaten Java’yı öğrenmeye başladığımdan beri, mutlaka sınıf tanımlamalarını yapıyoruz, nitekim Java dilide diğer nesne yönelimli diller gibi, nesnelere dolayısıyla sınıflara dayanıyor. O halde ne duruyoruz. İşe sınıfımız oluşturmakla başlayalım.
public class SinifKisi
{

} Elbette sınıfı böylesine tanımlamak son derece anlamsız ama birazdan sınıfın içine koyacağımız üyeler ile bayağı bir yol katedeceğiz. Biz oluşturduğumuz bu sınıfta türeteceğimiz nesneler ile, tablomuzdaki satırları temsil ediceksek eğer, tablodaki alanlarıda temsil etmemiz gerekir. İşte bunun için sınıfımız içerisinde, tablodaki alanlara denk gelicek alanlar tanımlayacağız. Bu alanların özel yanı private olarak tanımlanacak olmaları. Bunun sebebi, her zamanki gibi kapsülleme (Encapsulating). Kapsüllleme sayesinde, sınıfımız içinde kullandığımız alanların dışarıdan her hangibir etki ile doğrudan değiştirilemelerini engellemiş oluyoruz. Bu durum bizim isteğimiz dışında oluşabilecek atamaların önüne geçmemize ve illede bu alanların değerleri değişecekse bizim belirlediğimiz bir çizgide olmasına neden oluyor. Bu da programcılıkta ve özellikle nesne yönelimli programlamada çok büyük bir yere sahip olan Kontrol’ün elimizde olmasını sağlıyor.
Aslında kapsüllemeyi , içtiğimiz kapsül şeklindeki ilaçlardan yola çıkarak daha iyi anlayabiliriz. Çoğu zaman kapsül şeklinde ilaçlar içeriz. Bu ilaçların dışındaki koruyucu kapsül içinde, binlerce belkide onbinlerce zerrecik yer alır. Bu zerreciklerin böyle bir kapsül içine alınmasındaki en büyük neden bir arada tutulmak istenmeleri olarak düşünülebilir. Aynı sınıflarımızda kullanacağımız alanları bir arada tutmamız gibi. Diğer yandan, kapsüllenmelerinin en büyük nedeni, istenilen hedefe kadar gidilecek yol üzerinde (ağız, tükürük bezleri, yemek borusu, mide vesaire...) karşılaşılabilecek ve zerrelerin istenmeyen şekilde vücuda karışmasına neden olucak etkilerden korunmaktır. Amaç ilacın istenen yerde kapsülünün istenen etki ile eriyerek, zerreciklerin serbest kalmasıdır. Elbetteki kapsül ilaç örneği sınıflardaki kapsüllemeyi tam olarak açıklayamaz, ancak çok büyük benzerlikler taşır.
İşte sınıflarımızı yazarken de, bu sınıflar içierisinde tanımlanan ve sınıfa ait nesneler tarafından erişilebilen alanların, bizim programladığımız etkiler dışında değiştirilmesini istemeyiz. Bir alanın sadece okunabilir olmasını veya, bu alandaki değerlerin bizim kontrolümüz altındaki metodlar ile değiştirilmesini isteyebiliriz. İşte bu uyumu sağlamak için, nesneler tarafından kullanılan ve sınıf içinde tanımlanan alanları private olarak belirtiriz. Böylece bu alanlara sadece tanımlanmış oldukları sınıf içerisinden erişilebilecektir. Şimdi uygulamamızda, tablo alanlarını temsil edicek sınıf içi özel alanlarımızı oluşturalım.
public class SinifKisi
{
private int fID;
private String fAd;
private String fSoyad;
private String fTelefon;
} Şimdi C# ile bu sınıfı yazıyor olsaydım bu alanlar için birer özellik tanımlar ve get ile set bloklarını oluşturudum. Ancak kaynaklarıma baktığımda şaşırtıcı bir şekilde bu tarz ifadelerin, yani get ve set bloğu olan tarzda özelliklerin yer almadığını gördüm. Belki bu gözümden kaçmıştı ama tekrar baktığımda iyice emin oldum. Özellik tanımlamaları yerine, özelliklerinin rollerini üstlenecek olan metodları kendimiz yazıyorduk. Aslında bu tuhafıma gitti. Neyse yapacak bir şey yoktu, yeni bir fincan kahve almaktan başka. İşe koyulma vakti. Herşeyden önce bu alanların değerlerinin değiştirilebilmesini istiyorum aynı zamanda değerlerinin okunabilmesinide. O zaman her biri için birer metod yazmam gerekiyor.
public class SinifKisi
{
private int fID;
private String fAd;
private String fSoyad;
private String fTelefon;

public int getID()
{
return fID;
}

public String getAd()
{
return fAd;
}

public String getSoyad()
{
return fSoyad;
}

public String getTelefon()
{
return fTelefon;
}
} Önce alanların değerlerini sınıf örnekleri olan nesneler üzerinden okuyabilmek için, her bir alan için bir metod yazdım. Bu metodların tek yaptığı return anahtar kelimesi ile geriye, private sınıf alanlarının değerlerini göndermek. Tabi burada önemli olan nokta, bu metodların dönüş değerlerinin, private alanların veri tipleri ile aynı olmaları. Bununla birlikte bu metodları, sınıf dışından kullanabilmek için yada bu sınıfımızdan türeteceğimiz nesnelerde kullanabilmek için public belirteci ile tanımlıyoruz. Sıra geldi bu alanların değerlerini değiştirecek metodlara. Herşeyden önce, fID alanımız aslında, tablomuzdaki ID isimli birincil anahtar alanını işaret ediyor. Tablomuzun bu değerinin kullanıcı tarafından değiştirilmesi kesinlikle istenmeyecek bir durum. Ancak diğer yandan bu alana ait değerleri okumak isteyeceğimiz, örneğin where sorgularında kullanmak isteyeceğimiz durumlarda olucak. İşte kapsüllme için bir neden daha.
public class SinifKisi
{
private int fID;
private String fAd;
private String fSoyad;
private String fTelefon;

public int getID()
{
return fID;
}

public String getAd()
{
return fAd;
}

public void setAd(String ad)
{
fAd=ad;
}

public String getSoyad()
{
return fSoyad;
}

public void setSoyad(String soyad)
{
fSoyad=soyad;
}

public String getTelefon()
{
return fTelefon;
}

public void setTelefon(String telefon)
{
fTelefon=telefon;
}
} Artık bir yerler gelmeye başladık. Ancak sınıfımızda halen daha eksik üyeler var. Herşeyden önce, bir nesneyi yaratmanın en temel yolu new anahtar kelimesini kullanmak. Bu anahtar kelime, tanımlandığı sınıf için bir yapıcı metod çağırır. Yapıcı metodlar, çoğunlukla sınıf örneği olan nesneleri ilk kullanıma hazırlarken kullanılır. Örneğin, sınıf içinde kullanılan alanlara başlangıç değerlerinin verilmesi ve benzeri işlemler için. Bir sınıf için birden fazla yapılandırıcı tanımlayabiliriz. Bu, yapılandırıcı metodların aşırı yüklenmesi ile mümkün olur. Aşırı yükleme bildiğiniz gibi, bir metodun aynı isim altında farklı işlevler için kullanılmasıdır. Burada aynı isimli bu metodları birbirinden ayıran, kullanılan parametrelerin farklılıklarıdır. C# dilinde olduğu gibi aşırı yüklü metodların ayrı şekilde algılanmaları hem metod parametrelerine hemde metodun dönüş tipine bağlıdır. Oysa Java’da durum farklıdır. Java’da aşırı yüklü metodlar sadece parametreleri ile ayırt edilebilir, metodların dönüş tiplerinin, metodların ayırt edilmesinde bir etkisi yoktur. Sınıfımızı geliştirmeye devam etmeden önce aşırı yüklü yapılandırıcıların bir sınıf içinde nasıl kullanıldığına dair bir örnek verelim.
public class OverloadM
{
private int deger1;
private int deger2;

public OverloadM()
{
deger1=10;
deger2=15;
}
public OverloadM(int d1,int d2)
{
deger1=d1;
deger2=d2;
}
public OverloadM(int d1)
{
deger1=d1;
}
public void Yaz()
{
System.out.println("Deger1:"+deger1+" Deger2:"+deger2);
}
} Burada OverloadM isimli sınıfımızda, üç adet yapılandırıcı metod yer almaktadır. Bunları kullanacak olan sınıfımız ise Program sınıfımız olup kodları aşağıdaki gibi olucaktır.
public class Program
{
public static void main(String[] args)
{
OverloadM birinciNesne=new OverloadM();
birinciNesne.Yaz();
OverloadM ikinciNesne=new OverloadM(18,24);
ikinciNesne.Yaz();
OverloadM ucuncuNesne=new OverloadM(45);
ucuncuNesne.Yaz();
}
} Bu iki sınıfı başarı ile derledikten sonra, Program.java isimli uygulamayı çalıştırdım. Sonuç aşağıdaki gibi oldu.

__________________

Conrad