Bu yazının amacı, nesne yönelimli programlama ortamlarında kullanılan bir tasarım kalıbı (design pattern) olan gözlemci tasarım kalıbını (observer design pattern) açıklamak ve kullanımına dair bir örnek vermektir. Nesne yönelimli olmayan programlama dillerinde (örneğin C) aynı yapı, geri çağırım (callback) ismi verilen yaklaşım ile yapılabilir.

Konuya, klasik bir gözlemci tasarım kalıbını açıklayarak başlayalım. Geliştirme ortamı olarak sıklıkla kullandığım Netbeans içerisinde bir observer pattern eklenmesi halinde aşağıdakine benzer bir sınıf diyagramı (class diagram) görülmektedir:

Yukarıdaki kalıpta görüldüğü üzere 4 temel unsur bu kalıbı oluşturmaktadır:

• ConcreteObserver : Somut bir gözlemci
• ConcreteSubject: Somut bir fail (özne)
• Subject : Somut failden (özneden) türemiş olan diğer failler
• Observer: Somut gözlemciden türemiş olan diğer gözlemciler./

Gözlemci tasarım kalıbı, yukarıdaki şekilde görülebileceği üzere, aslında bir Fail / Meful ilişkisi (subject / object, özne /nesne ) üzerine kuruludur. Somut fail ile kastedilen, gözlemci yapısındaki herhangi bir fiile sebep olan (eylemi yapan) faildir (özne). Buna karşılık, nesne yönelimli programlama dillerinde, üzerine bir fiil uygulanan şey genelde nesne olarak ifade edilir. Yani zaten nesne yönelimli dillerde herhangi bir fiil, sadece nesneler üzerine uygulanmaktadır. Bu durumda fail ile kastedilen, yukarıdaki kalıpta concreteSubject ve bu yapıdan türeyen bütün subject sınıfı nesneler, meful ise bu nesnelerin metotlarına parametre olarak geçirilen ve üzerinde işlem yapılan nesnelerdir.

Bu yaklaşımı bir kod örneği üzerinden açıklamaya çalışalım. Öncelikle tasarımımızın sınıf diyagramını (class diagram) vererek konuya başlayalım:

Yukarıdaki şekilde, modelimizde bulunacak olan üç unsur içinde, yani gözlemci, fail ve meful için birer sınıf tanımı yaptık. Bu sınıfların kodu aşağıda verilmiştir:

İlk olarak gözlemci sınıfı (class) ile konuya başlayalım. Sınıfın tanımında, bir main fonksiyonu bulunuyor ve bu main fonksiyonu aslında fail , meful ve gözlemci kavramlarının bir araya geldiği nokta oluyor. Zaten sınıf diyagramında da görüleceği üzere gözlemci bu iki kavramı bir araya getirir. Buna göre fail ve meful sınıflarından üretilen failNesne ve mefulNesne nesneleri (objects) (kodun 20. ve 23. satırlarında), kodun 26. satırında, addObserver fonksiyonu ile birbirine bağlanmıştır. Bu basit işlem, meful üzerinde bir failin gözlemini tanımlar. Ayrıca kodun 29. satırında klasik thread üretmek için kullanılan ve Runnable arayüzü üzerinden Thread çağırımı ile failNesne’mizi bir thread şeklinde başlatıyoruz.

Gelelim Fail sınıfının tanımına:

Yukarıdaki kodda, basit bir şekilde, kulanıcıdan, ekranda yazı okumak için BufferedReader, InputStreamReader’a ve InputStreamReader da System.in’e bağlanmış. Bu sayede, System.in üzerinden girilen bir veri, BufferedReader tarafından okunabilecektir. response ismindeki String değişkeni (variable) bir sonsuz döngü içerisinde (21. satırdaki while) kullanıcıdan veri okumakta ve sırasıyla setChanged() ve notifyObservers() fonksiyonlarını çağırmaktadır. Buradaki notifyObservers fonksiyonu aslında bütün bu yazının kalbini oluşturuyoru. Dikkat edilirse bu fonkisyona klavyeden okuduğumuz response isimli değişkeni parametre olarak veriyoruz.

Kodda dikkat edilecek diğer iki husus ise, Observable sınıfını miras almamız (inheritance) ve bir thread olarak çalışmasını istediğimiz için Runnable arayüzünü (interface) implements etmemizdir.

Son olarak meful sınıfını açıklayıp, kodun çalışmasına bakalım:

Kodda görüldüğü üzere, Meful isimli sınıfımız, basitçe Observer arayüzünü kendi üzerine uygulamıştır (implements).

Meful sınıfının yegane fonksiyonu update fonksiyonudur ve parametre olarak bir Observable nesnesi bir de arg isimli Object tipinde (yani JAVA açısından tipsiz) bir parametre almaktadır.

Burada tipsiz tipler ile ilgili aşağıdaki yazıyı okumakta yarar olabilir

Son olarak update fonksiyonu içerisinde alınan mesaj, tip inkılabı (typecasting) ile Object tipinden String tipine inkılap ettirilmiş ve ardından ekrana basılmıştır.

Şimdi yukarıdaki senaryoyu toparlayacak olursak, gözlemci sınıfımızdaki main fonksiyonu çalıştırılarak bütün senaryo başlamaktadır. Bu main fonksiyonu içerisinde bir fail bir de meful nesnesi üretilmekte ve üretilen nesneler birbirine addObserver fonksiyonu ile bağlanmaktadır. Yani artık meful sınıfından türeyen nesneler, fail sınıfının birer observer’ı olmaktadır. Ardından fail sınıfından üretilen nesne bir thread olarak çalıştırılmakta ve kendi içerisinde bulundurduğu, ve threadlerin ilk çalışan fonksiyonu olan run() fonksiyonunda tanımlı olan kullanıcıdan bir dizgi (String) okuma işlemini gerçekletirmektedir. Hemen ardından okunan mesajı, aslında hiçbir fikri olmayan ismini, ne tür bir parametre aldığını dahi bilmediği notifyObservers () fonksiyonuna parametre geçirmektedir. Bu fonksiyon, bir sevki tabii olarak meful sınıfındaki update isimli fonksiyonu tetiklemektedir. Update fonksiyonu ise kendisine parametre olarak gelen nesneyi String sınıfına çevirmekte ve ekrana bamaktadır.

Yukarıdaki kodu çalışması sonucu ekran görüntüsü aşağıdaki şekildedir:

Görüldüğü üzere kodumuz bir fiil sorusu sormakta ve klavyeden benim yazdığım “merhaba” yazısını ekrana geri basmaktadır. Buradaki mesajı okuyan fail isimli sınıftan türeyen nesne iken, ekrana cevabı yazan meful isimli sınıftan türeyen nesnedir

Yukarıdaki bu tasarım kalıbını, daha gerçekçi bir örnek üzerinden açıklamaya çalışalım.

Örneğin bir müzayede (açık arttırma) ortamını, gözlemci tasarım kalıbı ile modellemek isteyelim. Buna göre müzayedeyi yöneten bir kişi ve bu müzayedeye katılan müzayedeciler bulunacaktır. Buna göre müzayedeyi yöneten kişi bir gözlemci olmakta, müzayedecilerin her biri birer fail (fiili yapan kişi) olmakta ve müzeyede sırasında verilen her teklif (fiyat) bir meful (fiilin etkisindeki değer) olmaktadır.

Bu yaklaşımı aşağıdaki şekilde göstermeye çalışalım:

Yukarıdaki yaklaşımda, muzayede sırasında verilen değerler, gözlemcinin update fonksiyonuna birer parametre olarak geçirilmekte ve nihayetinde gözlemciden bağımsız olarak ilgili fonksiyonlar çağrılmaktadır.

Gözlemci tipi tasarım kalıbının bir dezavantajı, bu noktada çıkmaktadır. Gözlemci tasarım kalıbında, meful yapısında olan ve fiilden etkilenen nesnelerin sistemde etkin rol oynaması beklenir. Diğer bir deyişle, açık arttırmaya katılan her bir katılımcı, fail olarak fiyatlarını belirtirken, gözlemci bu durumu sadece gözlemekte ve bir fiilde bulunmamakta ancak fiileri gözlemektedir. Bu anlamda, gözlemci tasarım kalıbı, çekme iletişim modeli (pull interaction model) olarak düşünülebilir. Alternatifi olan itme iletişim modelleri (push interaction model) failin doğrudan eylemde bulunması ile sonuca ulaşmakta ve dışarıdaki nesneleri çalışmaya zorlamaktadır. Yani gözlemci örüntü modelinde, dışarıda bulunan nesnelerin çalışmaları sonuçları toplanmaktayken, itme iletişim modeli olan diğer kalıplarda, bir nesne, diğer nesnelerin sonuç üretmesini zorlayabilir. Burada, tasarıma bağlı olarak bir seçim yapmak gerekir.

333 views

Netbeans ortamının en büyük avantajlarından birisi, kendi içerisinde ücretsiz bir UML tasarım ortamı bulundurmasıydı. Ne yazık ki 6.7 sürümünden sonra bu özelliği netbeans kurulum paketinden kaldırdılar ve netbeans.org sitesinde yapılan aramalardan visual paradigm isimli ücretli yazılıma yönlendirme yapılıyor.

Buna rağmen, netbeans üzerine UML paketi desteği kurulabiliyor. Aslında resmi olarak desteklenmese bile, paket bazlı olarak siteden desteğin indirilmesi mümkün. Bu yazı kapsamında UML desteğinin netbeans ortamına nasıl kurulacağı anlatılacaktır.

Öncelikle anlatımı yapacağım ortam MAC OS kullandığından ekran görüntüleri ve bazı detaylar bu ortama özgü olacak ancak windows ortamı için de açıklama yapmaya çalışacağım.

Bilgisayarıma, netbeans 7.0.1 sürümünü kurdum, ancak bütün sürümler için aşağıda anlatılanları yapabilirsiniz:

1. adım olarak netbeans kurulumunu tamamlıyor ve çalıştırıyoruz.

2. adım olarak aşağıdaki adresten içerisinde uml kelimesi geçen tek paketi indiriyoruz:

http://dlc.sun.com.edgesuite.net/netbeans/6.9/rc/zip.html

Paket ismi :netbeans-6.9rc2-201005312001-ml-uml.zip

Ben ne yazık ki 6.9 paketine ulaşabildim, ancak belki siz daha yeni bir pakete ulaşabilirsiniz. Sonuçta bu paket de iş görüyor.

3. adım olarak paketi açıyoruz ve kurulum dizinine taşıyoruz:

Yukarıdaki şekilde finder ekranında, applications dizini altına gidip netbeans üzerinden “Show package content” seçeneğini seçerek kurulum paketinin içini açıyoruz ve aşağıda gösterilen kurulum dizinine taşıyoruz:

Buna göre uml dizini tam olarak netbeans paketi içerisindeki netbeans xxx.app (buradaki xxx yerine kurulum versiyonu gelecek) Contents > Resources > Netbeans altına atılacak.

4. adım olarak netbeans’i çalıştırıyoruz.

Windows kullanıcıları 3. adımda anlattığım işlemi, doğrudan kurulum dizini altına yapabilirler (özel olarak farklı bir dizin belirtilmediyse, program files altında kurulan netbeans dizini altında, contents > resources > netbeans altına atmanız yeterli olmalı.

220 views

Bu yazının amacı, geri izleme algoritmasının (backtracking algorithm) bir uygulaması olarak, basit bir labirentte yol bulma kodunu JAVA dilinde kodlamaktır. Bu uygulamada herhangi bir yapay zeka yönetmi uygulanmayacaktır. Basitçe kör arama (blind search) yapan ve ihtimalleri sırayla deneyen bir robot uygulaması geliştirilecektir.

Örneğin labirent bilgisinin bir dosyada bulunduğunu ve bizim amacımızın bu dosyayı okuyarak labirentin başlangıcından çıkışına kadar olan yolu bulmak olduğunu düşünelim. Labirent tasarımımızda duvarları 1 ve yolları 0 ile gösterelim. Örneğin aşağıda bir labirent verilmiştir:

1111111
0010011
1000011
1101111
1100000
1111111

Yukarıdaki bu labirentte, sol üst köşeyi başlangıç konumu ve sağ alt köşeyi de bitiş konumu olarak kabul edeceğiz. Buna göre labirentin her zaman için ikinci satırının ilk kolonunda başlıyoruz ve labirentin boyutuna göre son satırın bir üstünde en sağ kolonda bitiriyoruz. Amacımız bu iki nokta arasındaki yollardan bir tanesini çözüm olarak bulmak. Ayrıca dosyadan labirent okuyacağımız için, veri yapısı kullanımını kolaylaştırmak amacıyla, labirentin boyutlarını da dosyanın ilk satırında tutalım. Buna göre bir labirent dosyasının içeriği aşağıdaki şekilde olacaktır:

6 7
1111111
0010011
1000011
1101111
1100000
1111111

Dosyanın ilk satırında, labirentin satır ve sütun boyutları verilmiştir.

Algoritmamız, basitçe labirentin başlangıç konumundan yola çıkacak ve yol alternatiflerini değerlendirecektir. Şayet yol tek yönlü ise hareket etmeye devam edecek ancak bir yol ayrımına geldiğinde bu noktayı bir yığında (stack) tutarak çıkmaz bir yola girdiğinde en son aklında tuttuğu bu yola geri dönecek ve farklı bir karar verecektir.

Örneğin yukarıdkai problem için çözümü elle yaparak tasarımımıza başlayalım. Başlangıç durumumuz (1,0) olacak (dizide satır sayısının 0′dan başladığını düşünürsek, ikinci satırın ilk sütunu (1,0) olarak gösterilecektir.

Bitiş durumumuz ise (4,6) olarak belirlenecektir (dizi boyutumuzda azami satır ve sütun değerleri 5,6 olacaktır (boyuttan bir eksik) ve en altın bir üstü satır 4 ve son sütun 6 olacaktır. Dolayısıyla bitiş durumu olarak (4,6) tanımlıyoruz.

(1,0) konumundan, (4,6) konumuna kadar olan çözüm yolunu bulmak için adım adım algoritma tasarımımızı inceleylim.

Algoritmamız kör arama (blind search) olduğu için, çözüme giden en mantıklı yolu bulmak yerine bütün ihtimalleri deniyeceğiz. Bu ihtimalleri belirli bir sıra ile aramamız gerekiyor. Bu srıalama için algoritmamızı aşağıdaki şekilde tasarlayalım:

Geldiğim yeri işaretle

if(sola gidilmemişse)

sola git;

else if(sağa gidilmemişse

sağa git;

else if(yukarı gidilmemişse)

yukarı git;

else if (aşağı gidilmemişse)

aşağı git;

Yukarıdaki bu tasarımda sol -> sağ -> yukarı -> aşağı sırası tamamen rast gele olarak üretilmiştir ve daha farklı sırada da olabilirdi.

(1,0) konumundan başlayarak yukarıdaki algoritmayı icra ettirelim. İşaretleme için 2 değerini kullanacağız. Öncelikle yığın (stack) değeri boş olarak başlıyoruz (bundan sonra S olarak gösterilecek ve sağdan eklenerek sağdan çıkarma yapılacaktır):

1111111
0010011
1000011
1101111
1100000
1111111

S -> boş

İlk değeri işaretliyoruz:

1111111
2010011
1000011
1101111
1100000
1111111

(1,0) konumunda tek gidilebilecek komşu, (1,1) konumudur (1,0) konumunun komşuları 0,0 2,0 ve 1,1 olduğuan göre bu değerlere bakıyoruz ve bunlardan 0 olan tek değere gidiyoruz:

1111111
2210011
1000011
1101111
1100000
1111111

Benzer şekilde (1,1) konumunun tek 0 olan komşusu (2,1) olan konuma gidiliyor. Benzer şekilde (2,1) konumunun tek komşusu olan (2,2) konumuna gidilerek aşağıdaki durum elde ediliyor:

1111111
2210011
1220011
1101111
1100000
1111111

Yukarıdaki son durumda geldiğimiz konum (2,2) ve birden fazla komşumuzda 0 değer var. Yani (2,2) konumunun komşuları olan (2,3) ve (3,2) değerleri 0 olduğu için bu alternatiflerden birisini takip edeceğiz. İşte bu yol ayrımında yığın (stack) kullanmanın sırası geliyor. Bunun sebebi şu anda vereceğimiz kararın doğru olup olmadığını bilmediğimiz ve basitçe hata yapıyorsak buraya geri dönmek istememiz.

S -> (2,2)

Yukarıdaki şekilde karar noktamızı yığına yerleştirdikten (push) sonra algoritmamızdaki öncelikli yol olan sol tarafı deniyoruz. Sol tarafımızda ((2,2)’nin solunda (2,1) vardır) 0 olmadığı için gidemiyoruz. Algoritmamızdaki ikinci ihtimal olan sağ tarafa bakıyoruz (sağın koordinatı (2,3)) ve bu değer 0 olduğu için bu yönde gidiyoruz.

1111111
2210011
1222011
1101111
1100000
1111111

Sağa gitme işlemine devam ediyoruz (aşağıya gidemediğimiz için) ayrıca burada bir yol ayrımı bulunduğu için (sağa veya yukarıya gidebiliriz) yığının (stack) içerisine yerleştiriyoruz:

S -> (2,2) , (2,3)

1111111
2210011
1222211
1101111
1100000
1111111

Tek alternatif olan yukarıya devam ediyoruz:

1111111
2210211
1222211
1101111
1100000
1111111

Tek alternatif olan sola devam ediyoruz:

1111111
2212211
1222211
1101111
1100000
1111111

Netice itibariyle alternatifi kalmayan (hiçbir yönde 0 olmayan) bir duvar ile karşılaştık ve bu noktadan sonra çıkma ihtimalimiz kalmadığı için yığındaki en üstte bulunan ve en son karar verdiğimiz noktaya dönüyoruz.

Bu nokta (2,3) koordinatlarındadır ve pop edildikten sonra stack aşağıdaki şekildedir:

S – > (2,2)

Pop ettiğimiz (2,3) noktasında da gidilecek hiçbir alternatif bulunmuyor. Mecburen yığındaki (stack) bir sonraki noktaya dönüyoruz:

S -> Boş

Döndüğümüz koordinat (2,3) noktası ve buradaki tek alternatif aşağı yönde bulunan 0 değeri:

1111111
2212211
1222211
1121111
1100000
1111111

Bu aşamadan sonra, hiçbir alternatif kalmadan 0 olan yollar izlenerek sonuca ulaşan yol bulunmuş oluyor.

Kodlama

Yukarıdaki yaklaşımın JAVA dilinde kodlanmış hali yazının sonunda verilmiştir. Bu kodun kısaca açıklamasını bu bölümde anlatacağım. Kodumuzda temel olarak iki sınıf bulunuyor:

• currentInfo
• Maze

currentInfo sınıfı, anlık olarak matrisin hangi konumunda bulunduğumuzu tutmaya yarıyor. Çok basit şekilde satır ve sütün koordinatlarımızı barındırıyor. Ayrıca bu değerlere erişmeyi sağlayan inşa sınıfları (constructors) ve kapsülleme fonksiyonları (encapsulation) bulunuyor.

Maze sınıfı ise geri kalan herşeyi yapan ana sınıfımız. Bu sınıfta getMaze() isimli fonksiyon, dosyadan labirent bilgilerini okumak için kullanılıyor. solveMaze fonksiyonu da labirentteki sonucu bulmaya yarayan yukarıdaki işlemleri çalıştırıyor.

Yukarıdaki anlatımda geçen ve S harfi ile ifade ettiğimiz yığın (stack) ise kodumuzda path ismi ile tanımlanmış java.util.Stack sınıfından tanımlanmış bir yığın. Buradaki yığın, karar verirken atılan her adımı tutmakta. Yani yukarıdaki labirent çözümünde geçen ve 2 olarak işaretlerken, birden fazla 0 ihtimali bulunan dönüm noktalarını tutuyor.

Yığının en temel 3 fonksiyonu ise aşağıdaki şekildedir:

• Pop() yığında bulunan en üstteki değeri alarak bir değişkene döndürür.
• Push() yığının en üstüne, parametre olarak aldığı veriyi yerleştirir.
• Peek() yığının en üstündeki veriyi alır ancak pop fonksiyonunun aksine bu veriyi silmez. Bu fonksiyon bazı kaynaklarda Top() olarak da geçmektedir ancak java.util.Stack sınıfında peek ismi ile tanımlanmıştır.

Kodumuzda kullandığımız iki temel dizi ise aşağıda verilmiştir:

• mazeData[][] iki boyutlu bu dizi, dosyadan okunan ve hafızada labirent bilgisini tutan dizidir.
• Mark[][] diğer iki boyutlu dizimiz ise sonuca giden yolu tutar.

İkinci diziye neden ihtiyaç duyduğumuz sorusunu şu şekilde cevaplayalım. Dizimizi dolaşırken, yanlış yollara sapabiliyoruz, geçtiğimiz her yeri basarsak bu sonuçta görmek istediğimiz çözüm yolu olmayacaktır. Ayrıca labirentte dolaşırken, çözüme giden yolu 2 ile işaretliyoruz ama hatalı yolları da 2 ile işaretliyoruz. Dolayısıyla labirenti dolaştıktan sonra 2 ile işaretli yolları basarsak bu yollarda da sonuca gitmeyen değerlerin basılması söz konusu. Çözüm olarak ayrı bir dizide, sonuca giden yoldaki koordinatları ayrıca tutuyoruz.

Koddaki bazı satırları anlatmamız gerekirse:

Yukarıdaki kod parçasında, bulunduğumuz konumdan (current) sonraki gidebileceğimiz yönleri sırasıyla deniyoruz. İlk if koşulunda mazeData isimli dizide (yani labirentin verilerinin tutulduğu dizi) bulunan ve mevcut konumun bir sağında yer alan (col + 1 işleminin anlamı bir sonraki kolon demektir) değere gidilmesi ve bu değerin daha önce mark dizisinde işaretlenmemiş olması (gidilmemiş olması ) durumu kontrol edilmektedir. Ardından sırasıyla, sol, aşağı ve yukarı yönler için aynı kontroller yapılmaktadır. Yazıda anlatılan sıradan bu anlamda farklıdır.

Yukarıdaki kod parçasında ise, bir önceki kod parçasının devamı niteliğinde, şayet 4 yöndede hareket edilemiyorsa, çıkmaz bir yola girilmiş neticesine varılabilir. Bu durumda mevcut durum dolaşıldı anlamında, 2 ile işaretlendikten sonra, yığından (stack) pop fonksiyonu ile dönülecek en son karar anına bakılıyor.

Şayet yığın bir şekilde boş olursa (ki bu durum try/catch blokları arasında istisna kabz edilerek (exception handling) çözülmüştür) bu durumda labirentin bir çözümü olmadığını söyleyebiliriz çünkü hem bir çıkmaz yol bulduk hem de geriye döneceğimiz hiçbir yol ayrımı bulunmuyor demektir.

Netice itibariyle, 61. Satıra kadar ulaştıysak, bu satırda flag değişkeni true değerinde olup, yukarıdaki 4 iften birisine girerek bir yöne hareket etmiş olabilir. Bu durumda gidilen bu yok, mark dizisinde işaretlerenerek yığına yerleştiriliyor. Ayrıca flag değişkenin false olduğu tek ihtimal olan çıkmaz yol durumunda da if bloğu çalışmıyor.

Yukarıda alıntılıanan kod parçası ise bütün işlemler bitip, labirent bir sonuca ulaşacak şekilde dolaşıldıktan sonra, mark dizisi üzerinden dolaşılan yolu ekrana basmaktadır. Döngü, labirent boyutları olan dim1 ve dim2 sınırlarında dönmekte, her adımdaki konum 71. Satırda ekrana basılmakta ve sonraki konum da 4 farklı koşul konrolü ile işaretlenmiş olan yöne doğru değiştirilmektedir.

Kodun çalışması sonucunda, örnek ekran çıktısı aşağıda verilmiştir:

Görüldüğü üzere labirentteki bütün yolları dolaşarak, sonuca ulaşan yolları ekrana basmıştır(lütfen basma işlemi sırasında, 71. Satırda olduğu üzere önce satır sonra sütun koordinatının basıldığına dikkat ediniz). Bu örnek çalışma, aşağıdaki labirent içindir:

Ayrıca farklı bir dosya içeriği, projenin bulunduğu dizindeki maze.dat dosyasının içerisine yerleştirilerek çalıştırılabilir.

Kodun tamamını netbeans projesi olarak indirmek için tıklayınız.

932 views

Soru 0) Ekrana adınızı, soy adınızı ve numaranızı bastıran tam bir JAVA kodu yazınız, kodunuzun konsoldan derlenip çalıştırılması komutlarını yazınız. (10 puan)

Soru 1) Aşağıdaki sorulara birer cümle ile cevap veriniz: (10 puan)

1. Serileme (Serialisation) nedir?

   Bir nesnenin dizgi (String) haline dönüşmesi ve dosya, ağ vb. gibi ortamlar üzerinde dizgi olarak saklanması / yollanmasıdır.

2. JAVA’da neden çok işlemli programlama (multi processed programming) bulunmaz?

   JAVA, platform bağımsız bir geliştirme ortamıdır, dolayısıyla JVM isimli sanal bir makine üzerinde çalışır ve bütün JAVA uygulamalarının bu sanal makine içerisinde kalması beklenir. Dolayısıyla yeni bir işlem (process) üretilmesi halinde JVM dışına çıkılacağı için, çoklu görevlerin (multi tasking), lifler (threads) vasıtasıyla çözülmesi mümkündür, ancak çoklu işlem (multiprocess) JAVA dilinde desteklenmez.

3. JAVA’da çoklu miras (multiple inheritance) nasıl yapılır?

   Arayüzler kullanılarak (interfaces) yapılabilir (örneğin bu sınavdaki 2. soruda hem extends Thread hem de implements Runnable örneğinde olduğu gibi)

4. Delegasyon (Delegation) ilişkisi nedir?

   Bir sınıfın, diğer bir sınıfa kılıf olması ve yapılan işlemlere aracılık etmesine verilen isimdir. Örneğin kişisel bir muayenehanede yapılan işlemler aslında doktorun yaptığı işlemlerdir.

5. Oluşum (composition), birliktelik (Association) ve münasebet (aggregation) ilişkileri arasında ne fark vardır?

   Oluşum, birliktelik ve münasebetin genel ismidir. Birliktelik, iki nesneden birinin diğeri içerisinde yaşamasına, münasebet ise bir nesnenin diğerine atıfta bulunarak içermesine verilen isimdir.

Soru 2) Programcı Ali, ekrana sırasıyla A ve B yazdırma için aşağıdaki kodu yazıyor. (örneğin ekranda “ABABABAB” görmek istiyor). Aşağıdaki kodda, lifler (thread) açısından oluşan problemleri/eksikleri tanımlayınız, ve kodu çalışır hale getiriniz. (25 puan)

Tam çözüm aşağıdaki şekildedir:

Dikkat edilecek hususlar:

extends eden sınıf doğrudan start() edilebilirken implements eden sınıf öncelikle Thread’in yapıcı fonksiyonuna (constructor) parametre verilmeli ardından Thread start() edilmelidir.

İki thread arasında ortak bir değişken kullanılarak senkranizasyon yapılabilmesi için paylaşılmış bir değişkene (shared variable) ihtiyaç duyulur. Oysaki yazılan hatalı kodda (yukarda) her sınıf için yeniden bir değişken tanımlanmıştır. Bu durumda iki farklı değişken bulunacak ve birbiri ile ilgisi kalmayacaktır.

Soruda istenilen senkranizasyon sonucunda ABABA şeklinde bir çalışma beklenmektedir. Oysaki soruda x değişkeni öncelikle 1 olarak atanmıştır. Bu değerin 0 olarak başlaması gerekir.

Senkranizasyon için sınıflardan birisi 0 diğeri 1 durumunda çalışmalıdır. Hatalı kodda ikisi de aynı durumda beklemektedir. Bu durum ölümcül kilitlenmedir (deadlock).

Senkranizasyon sonucunda liflerin (threads) tekrar tekrar çalışabilmesi için sırayı diğer life(thread) geçirmesi gerekir. Bu durumda 1 bekleyen lif, işi bittikten sonra 0, 0 bekleyen lif ise işi bittikten sonra 1 bekleyen lifi uyandırmalıdır.

class A extends Thread{
	test x;
	public A(test x){
		this.x = x;
	}
	public void run(){
		while(true){
			while(x.x==1){
			  try{
			      Thread.sleep(100);
			    }catch(Exception e){}
			}
			System.out.print("A");
			x.x=1;
		}
	}
}
class B implements Runnable{
	test x;
	public B(test x){
		this.x = x;
	}
	public void run(){
		while(true){
			while(x.x==0){
			    try{
				Thread.sleep(100);
			    }catch(Exception e){}
			}
			System.out.print("B");
			x.x=0;
		}
	}
}
public class test{
	public int x=0;
	public static void main(String args[]){

		test p = new test();
		A a = new A(p);
		B b = new B(p);
		Thread t = new Thread (b);
		a.start();
		t.start();
	}
}

Soru 3) (35 puan)

1. Bir metin dosyasını açıp içinden veri okuyunuz.

2. Okuduğunuz verinin içerisinde email adresi olup olmadığına bakınız (emailler için “@” işaretinden önce istenilen boyutta harf ve sayı karışımı “.” işaretiden önce yine istenilen boyutta harf ve sayı karışımı, “.” İşaretinden sonra ise com, edu, org veya net gelebileceğini kabul edebilirsiniz), şayet bir email’e rastlarsanız kendi yazdığınız bir istisna fırlatınız (throw exception).

3. Bir önceki şıkta istisna fırlatılması halinde bu email adresini, “Silindi” dizgisi(string) ile değiştiriniz.

Dikkat edilecek iki önemli husus, StringTokenizer ve RegularExpression kullanımıdır. Ayrıca istisna yakalama için farklı modeller kullanılabilir, yukarıdaki kodda en basit yol seçilmiştir.

Örnek bir dosya için çıktı aşağıdaki şekildedir:

Soru 4) Swing kütüphanesi kullanarak 500×500 boyutunda bir ekran oluşturup tam ortasına isminizi yazdırınız. İsminizin etrafına, isminizi çerçeveleyen bir dikdörtgen çizdiriniz. (20 puan)

Yukarıdaki kodun çıktısı aşağıdaki şekildedir:

1,393 views

Bu yazının amacı, JAVA dilinde bulunan ve grafiksel kullanıcı ara yüzü geliştirmekte kullanılan SWING kütüphanesine hızlı bir başlangıç yapmaktır.

Öncelikle Swing kütüphanesinin gelişiminden hızlıca bahsedelim. Swing kütüphanesi JAVA diline JDK 1.1 sürümünden sonra eklenmiştir. Daha önce AWT (Active Window Toolkit) ismi verilen bir kütüphane kullanmaktaydık ancak çok daha fazla ve gelişmiş özelliklerle gelen swing kütüphanesi neredeyse tamamen AWT yerine geçti denilebilir. AWT halen kullanılmakta, bunun en büyük sebebi JAVA’nın Visual Studio gibi geliştirme ortamlarından farklı olarak geçmişle uyumlu olmasıdır (back compatibility). Yani, örneğin 1997 yılında yazdığım bir kodu hala derleyip çalıştırabiliyorum.

AWT’nin bulunmasındaki diğer önemli bir faktör ise, Swing kütüphanesinin AWT üzerinde geliştirilmiş olmasıdır. AWT’den bu kadar bahsettikten sonra son olarak aynı projede hem AWT hem de Swing kullanmamanız gerektiğini, aksi halde ağır ve hafif bileşenlerin ekranda hatalı görüleceğini (heavy weighted, light weighted) söyleyerek Swing kütüphanesini anlatmaya başlayalım.

Swing kütüphanesi, javax altında bulunmaktadır ve bütün swing sınıfları (classes) javax.swing paketi ile başlar.

Örneğin, ekrana basit bir düğme koyarak uygulama geliştirmeye başlayalım.

Yukarıdaki kodun çıktısı, aşağıdaki şekilde bir pencereye yerleştirilmiş bir düğmeden (button) ibarettir:

Kodumuzda kullandığımız iki swing bileşeni olan JFrame ve JButton import edildikten sonra sınıfın bir JFrame olacağını, extedns JFrame yazıp JFrame sınıfını kalıtımla (inheritance) alarak belirtiyoruz.

Kodumuzda bulunan iki metottan ilki bir inşa fonksiyonu olup (constructor), this.add fonksiyon çağrılması ile JFrame içinde tanımlı olan add fonksiyonuna bir adet JButton parametre verilmiştir.

Klasik olarak swing kütüphanesinde, bir bileşenin diğer bileşenleri içinde barındırma özelliği bulunuyorsa (container) bu durumda add fonksiyonu, parametre olarak aldığı bileşeni, barındırıcı bileşene eklemektedir.

Kodun 5. satırında yapılan bu ekleme işleminde dikkat edilecek bir husus da, JButton bileşenini oluşturan ve new ile çağrılan yapıcı fonksiyonun (constructor) parametre olarak bir dizgi (string) almış olmasıdır. Bu dizgi, düğmenin üzerinde görülecek olan yazıdır.

Son olarak main fonksiyonunda, yeni tanımladığımız bu sınıftan bir nesne (object) oluşturarak bu objenin referansına sb ismini veriyoruz. Kodun 9. ve 10. satırlarında ise sırasıyla sb isimli bu nesneyi (ki artık JFrame özelliği taşıyan ve içerisinde bir buton olan nesnedir) paketliyoruz ve göstertiyoruz. Paketleme işlemini basitçe, bir pencerenin içerisindeki bileşenlerin sığacağı en ufak hali alması olarak düşünebilirsiniz. Gösterme işlemi ise bir bileşenin görünürlülüğünü (visibility) doğru yapmaktan ibarettir (true). Tersi şekilde görünürlülüğü yanlış (false) yapılarak bir bileşen gizlenebilir. Yine daha önceki sürümlerde bu işlem için sırasıyla show() ve hide() fonksiyonları da kullanılmaktaydı ancak JDK 1.3 sonrasında bu fonksiyonlar kaldırıldı.

Şimdi gelelim bu düğmenin tıklanması halinde eylemi algılamaya.

Yukarıdaki kodu yazıp denediyseniz tıklama eyleminin herhangi bir sonuç doğurmadığını görmüşsünüzdür. Bunun sebebi JAVA dilinde tanımlı olan herhangi bir eylemin sınıf içerisinde yer alamamasıdır.

JAVA dilinde eylemi üreten ve yakalayan nesneler farklı olabilir. Örneğin yukarıdaki örnekte düğmeyi tanımladığımız swingbuton isimli sınıf düğmeye tıklandığında devreye girebileceği gibi tamamen başka bir sınıf da devreye sokulabilir. Biz basit olsun diye ilk örneğimizde yine aynı sınıfta eylemi yakalayacağız. Bunun için öncelikle sınıfa bu özelliğin kazandırılması gerekir. JAVA dilinde bir sınıfın herhangi bir bileşen ile ilgili bir eylem yakalayabilmesi için ActionListener olması gerekir.

public class swingbuton extends JFrame implements ActionListener

şeklinde sınıfın tanımını değiştirerek bu sorunu çözebiliriz. Ancak, arayüzlerden (interface) hatırlanacağı üzere bir arayüzü (interface) sınıfa kazandırmanın (implements), bağlayıcı bir sonucu olmaktadır.

Kodumuzda yeni olan en büyük fark, sınıfta artık ActionListener arayüzünün implement edilmesidir. Bu arayüzün sınıfa uygulanması ile birlikte, sınıfta ” actionPerformed” isimli fonksiyonu bulundurma zorunluluğu ortaya çıkar. Nitekim yukarıdaki kodun 10-12. satırları arasında bu fonksiyon kodlanmış ve herhangi bir eylem olması halinde çalışacak olan bu fonksiyonun içerisinde ekrana “butona basıldı” mesajının yazılması sağlanmıştır.

Diğer bir ilave ise artık düğmenin bir eylem dinleyicisi olmasına olan ihtiyaçtır. Düğmemize basıldığında hangi sınıfın bu eylemi yakalacağını kodda belirtmemiz gerekir ki bu durum da 8. satırda kodlanmıştır.

Yukarıdaki kodun ekran çıktısı aşağıdaki şekildedir:

Birden fazla düğme bulunması halinde düğmeleri ayırt etmek için eylemin özel olarak koşullandırılması gerekir.

Kodun yeni halinde, düğmelerin tanımlandığı satırı sınıf geçerlilik alanına alarak actionPerformed fonksiyonu içerisinde hangi düğmeye tıklandığını kontrol edebiliyoruz. Bunun için parametre olarak gelen ActionEvent tipindeki e nesnesinin kaynağını okutan .getSource metodunu çağırıyor ve hangi nesneye eşit olduğunu sorguluyoruz.

Ayrıca kodda yapılan yeni bir ilave, birden fazla bileşeni aynı anda ekranda gösterebilmek için bir yayılım (Layout) eklenmesidir. Yukarıdaki kodda, 10. satırda bulunan komut, this ile ifade edilen JFrame nesnesinin yayılımının FlowLayout tipinde olacağını belirtmektedir. Bunun anlamı eklenen her bileşen, bir öncekinin sağına ilave edilecek, nihayet ekranda daha fazla sağa eklenecek yer kalmayınca aşağıya geçileceğidir.

Swing kütüphanesi kullanılarak mevcut bileşenler, yukarıda gösterildiği şekilde ekrana eklenip kullanılabileceği gibi, bileşenler üzerinde değişiklik yapılması da mümkündür. Örneğin bir swing bileşeni olan Jpanel üzerinde çizim yapmaya çalışalım:

Yukarıdaki kodda bulunan sınıf, Jpanel bileşenini miras almış ve bu bileşenin “paintComponent” isimli metodunun üzerine ezmiştir (override). Neticede Jpanel jf isimli Jframe’e eklenmiş ancak yeni çizim özellikleri ile görüntülenmiştir. Kodun ekran çıktısı aşağıdaki şekildedir:

paintComponet fonksiyonu yukarıda gösterildiği şekilde ezilerek (override) Graphics kütüphanesinden istenilen bir nesne, yukarıda gösterildiği şekilde ekrana eklenebilir.

Ayrıca JAVA’nın kuvvetli kütüphanelerinde birisi de Graphics2D kütüphanesidir. 2 boyutlu şekillerin bulunduğu kütüphane olarak tanımlayabileceğimiz bu kütüphane ile görsel pek çok işlem yapılabilir. Bu kütüphaneyi kullanmak için örnek kod aşağıda verilmiştir:

Yukarıdaki yeni kodda, paintComponent fonksiyonu altında, Graphics2D sınıfından türetilmiş bir nesne olan g2d nesnesine, şimdiye kadar kullandığımız ve klasik Graphics kütüphanesinin bir nesnesi olan g nesnesini tip inkılabı ile (type casting) atıyoruz. Bu sayede g2d nesnesinin fonksiyonlarını kullanabiliyoruz.

Kodda, dikdörtgen ve daire şeklinde iki nesne ekrana eklenerek gösterilmiştir. Kodun çıktısı aşağıda verilmiştir:

Aynı ekranda hem çizim hem de bileşen (component) kullanan kod (Ahmet beyin sorusu üzerine ekliyorum):

Sorunumuz, aynı ekranda hem çizim yapabilmek, yani Graphics kütüphanesini kullanmak, hem de java’nın bileşenlerinin (örneğin düğme (buton) veya yazı alanı (text areat) gibi ) kullanabilmek.

Bunu yapan örnek bir kodu aşağıdaki şekilde kodlayabiliriz:

Kodda, öncelikle bir JPanel sınıfı oluşturuyoruz. Basitçe JPanel miras alan bir sınıfımız var, ismi cizim ve bu sınıf içerisinde, yukarıda da anlatılan paintComponent metodunun üzerine ezere (method overriding) Graphics kütüphanesini kullanıyoruz (örnek olarak bir çizgi çizdirilmiştir).

Ardından main fonksiyonumuzu içeren bir sınıf kodlanmıştır. Bu sınıf içerisinde x nesne atıfı (object referrer) ile gösterilen bir JFrame oluşturulmuş ve bileşen yayılımı (layout) GridLayout olarak ayarlanmıştır. Kabaca ekran 2×2 boyutlarında dört parçaya bölünmüştür. Javada bu yayılıma ekleme yapıldığında sol üst köşeden başlanarak bileşenler eklenir ve ilk satır bitince aşağıya geçilir.

Buna göre sırasıyla eklediğimiz bileşenler, c ismindeki ve cizim sınıfından türetilmiş bir JPanel, satır içinde (inline) olarak türetilmiş bir cizim nesnesi, üzerinde “deneme” yazan bir düğme (buton) ve içinde “www.bilgisayarkavramlari.com” yazılı bir yazı alanı (JTextArea).

Ekranın çıktısı aşağıdaki şekildedir:

Görüldüğü üzere, ekranda çizim içerikli iki panel ve iki adet swing kütüphanesinden bileşen eklenmiştir.

570 views

1. Bir masa lambasının 4 farklı durumu bulunabilmektedir. Kapalı, az ışık, orta ışık ve çok ışık seviyelerinde yanabilen bu lambayı nesne yönelimli olarak programlayınız. Herhangi bir insanın bu lambanın durumunu değiştirebilmesi ve lambanın mevcut durumunu görebilmesini sağlayınız. (JAVA dilinde sadece gerekli sınıfları yazınız) (10 puan)

   Masa lambasında durumu tutan bir değişkene ve bu durumu değiştiren bir metoda ihtiyaç duyulmaktadır. 4 farklı durum olduğu için en uygun değişken int tipidir.
   

   

   Yukarıdaki kod doğru olmakla birlikte, insan sınıfında yapıcı fonksiyon içerisinde masa lambası tanımlanmaması kabul edilebilir (insanın masa lambası olabilir ama her insanın masa lambası olmak zorunda değildir). Veya durumu döndüren fonksiyon (durumuBildir) değer döndürmek yerine ekrana durumu basabilir, veya String tipinde kapalı, az, orta ışık, çok ışık şeklinde değerler döndürebilir. Benzer şekilde yeniDurum fonksiyonu paramatre olarak int yerine String tipinde değer alabilir. Bu açıklamada olduğu üzere makul kabul edilebilecek değişken tipinde ve fonksiyon yapısında değişiklik olabilir.
   

    

2. Bir bankanın ATM cihazına gelen müşteriler, giriş (şifre yazarak), para yatırma, para çekme ve bakiye sorgulama işlemlerini yapabilmektedir. Bu sistemi nesne yönelimli olarak modelleyiniz, ihtiyaç duyuluyorsa ilave sınıfları da tanımlayınız. Her sınıfın metotlarını ve özelliklerini belirtiniz ve modelinizi JAVA dilinde kodlayınız. (30 puan)

   

       

3. Aşağıda verilen sınıfların özellik ve metotlarının isimlerini yazınız. Bu sınıflardan hangilerinin arasında ilişki olduğunu ve bu ilişkinin çeşidini yazınız.

   {çember, daire, nokta, şekil, doğru, kare, yamuk, piramit, küp, silindir }

   Yukarıdaki tanımınız ışığında, bir şekil vektörünü parametre olarak alıp bu vektördeki elemanların alanlarını hesaplayan fonksiyonu JAVA dilinde kodlayınız. (Bu sorudaki vektör kelimesi, java.util.Vector sınıfını ifade etmektedir, sorudaki hesaplama fonksiyonu dışında kod yazmanız gerekmemektedir ancak isterseniz sınıfların metotlarını ve özelliklerini kod yazarak da gösterebilirsiniz. Sınıflar arasındaki ilişkilerin isimlerini her durumda yazınız.) (50 puan)

    

   

   

    

   1. Aşağıdaki kod parçasının ekran çıktısını yazınız (10 Puan):

      int x = 6; // 110

      int y = 3; // 011

               // 101 = ^

               // 010 = 2

      // 111 = |

      System.out.println(x^y|2);

      if(++y == 3&& x<6 )

      System.out.println(y);

      System.out.println(y);

      Not: Bu sorunun cevabı hem “Thinking in JAVA” kitabında hem de “JAVA Tutorial” içeriğinde bulunmaktadır.

      7
      

      3
      

      Yukarıdaki ilk işlem x^y işlemidir ve ikilik tabanda XOR işlemi olarak çalışır. Bu durumad 6 = (110)₂ ve 3 = (011)₂ olarak çevrildikten sonra aralarında özel veya (xor) operatörü çalıştırıldığında, 101 sonucu bulunur. Ardından gelen tek boru (pipe) işlemi ise ikilik tabanda veya (or) işlemidir ve (101)₂ | (010)₂ şeklinde düşünülmelidir. Bu işlemin sağ tarafı 2 sayısının ikilik tabandaki karşılığıdır. Bu işlemin sonucu da (111)₂ olarak bulunur ki bu değer onluk tabanda 7 yapar.
      

      Ardından gelen if satırında önce x değerinin 6′dan küçük olup olmadığı kontrol edilir. Bu kontrol doğru değildir (false) dolayısıyla if satırındaki ikinci kısım çalışmaz. Yani y++ == 3 satırı çalışmaz. Bunun sebebi JAVA dilindeki kısa devre (short circuit) uygulamasıdır. Ve işlemi ile birbirine bağlı olan if kontrollerinde sol tarafın false dönmesi halinde sonuç flase olacağı için sağ tarafa bakılmaz. Ayrıca bu if satırının altında olan if bloğu da sonuç false olduğu için çalışmaz ve ikinci println fonksiyonu ekrana basılmaz.
      

      Son satırdaki println fonksiyonu ise y’nin orijinal değeri olan 3′ü ekrana basar.
      

       

   “Bilgisayarların, bilgisayar bilimindeki yeri, teleskopların, astronomi bilimindeki yerinden fazla değildir.” — Dijkstra
   

974 views

Verilen bir dizilimdeki (sequence) tekrar oranını bulmaya yarayan yöntemdir. İsmi n ve gram kelimelerinin birleşiminden oluşmaktadır. Buradaki n, tekrarın kontrol edildiği değerdir. Gram ise bu tekrarın dizilim içerisindeki ağrılığını ifade etmek için kullanılmıştır.

Örneğin bir dizgi (string) içerisindeki n-gram değerini bulmak isteyelim ve buradaki n değeri 2 olsun (n = 2)

“wwwbilgisayarkavramlaricomsadievrenseker”

Yukarıdaki yazının 2-gram değerleri aşağıda verilmiştir:

Yukarıdaki değerler üzerinde çalıştığımız dizginin (string) 2şer komşuluktaki alt kümesidir.

Benzer şekilde aynı dizginin 3-gram değerleri aşağıda verilmiştir:

Benzer şekillerde sayı arttırılarak istenilen bir n-gram değeri listelenebilir. Bu değerlerin bazıları literatürde özel olarak isimlendirilmektedir.

Örneğin bu isimlendirme listesi aşağıda verilmiştir:

• 1-gram > unigram
• 2-gram > bigram
• 3-gram > trigram

3′ten büyük değerler için sadece n-gram terimi kullanılır.

n değerine bağlı olarak dizilimin alacağı ihtimal uzayı artmaktadır. Örneğin 29 harfli Türkçe için unigram bir işleme sonucunda 29 farklı alternatife göre dizilinim dağılımı ortaya çıkar. Yani listemizin sonucunda 29 farklı ihtimal ve bu ihtimallerin her birisinin kaçar kere tekrarlandığı bulunur.

n değerini arttırdıkça bu ihtimal uzayı büyür ve yine 29 harfli Türkçe için (Sadece alfabedeki harflerin olduğunu kabul ediyoruz) 29ⁿ olarak bulunabilir.

Yukarıda anlatıldığı üzere bir dizginin (String) üzerinde n-gram işlemesi yapan kod aşağıda verilmiştir:

Yukarıdaki kodda, iki adet sınıf kullanılmıştır. sayac isimli sınıf, bulunan n-gramları tutmak için kullanılan bir veri ünitesidir. Bu veri ünitesi, test sınıfında kullanılan vektör (vector) içerisinde tutulmakta ve bulunan her n-gram’ın kaç tane olduğunu saymaktadır.

Kodun 17 ile 34. satırları arasında verilen dizgi (String) önce verilen n boyutunda parçalara ayrılmakta (kodun 18. satırındaki String kütüphanesinden substring fonksiyonu marifeti ile) ardından bu n boyutundaki parça veri yapımız olan Vektör içerisinde var mı diye bakılmaktadır (kodun 20 ile 26. satırları arasında). Şayet yoksa vektör eklenmekte (kodun 27,28. satırları) varsa da kaç tane olduğu değeri arttırılmaktadır (kodun 24. satırı).

200 views

Bu yazının amacı, Java dilindeki vektör sınıfının kullanılmasını ve yapısını anlatmaktır.

Java dilindeki vektörlerin yapısından bahsederek başlayalım. Klasik veri yapısı olarak dizilerin (array) ve bağlı listelerin (linked list) özelliklerini birleştirmiştir.

Bir vektör boyutu belli olmadan tanımlanıp içerisine veri konuldukça hafızada kapladığı yeri arttırmaktadır. Bu anlamda bağlı listelere benzer özellik göstermektedir. Yani bir vektörün boyutunun önceden tanımlanması gerekmez. Aslında vektörün boyu yoktur ve herhangi bir anda vektör için bir limit belirtilmez.

Boyutunu belirsiz tutabilmemizin yanında, bir vektörün herhangi bir elemanına doğrudan erişmek (random acces) de mümkündür. Bu sayede vektör yapısı diziler ve bağlı listelerden daha avantajlı bir hal almış olur.

Vektörler hakkında bilmemiz gereken son özellik ise, vektörlerin tipsiz olduğudur. Yani vektörler içlerinde istenilen tipte veri tutabilir. Bunu, JAVA dilinde bulunan nesne mirası sayesinde yapmaktadırlar. JAVA dilinde, bütün nesneler, Object sınıfından türemiştir. Yani aslında bütün nesneler ile Object sınıfı arasında bir miras (inheritance) ilişkisi bulunmaktadır.

Dolayısıyla JAVA dilindeki bütün nesneler, Object sınıfına yukarı akış yapılarak (upcasting) bu tipte tutulabilir. Aşağıdaki örneklerde bu durumu gösteren kodlar sunulacaktır.

Gelelim vektörlerin, JAVA dilindeki kullanılışlarına

Basit bir uygulama ile bu sınıfı tanımaya başlayalım.

Öncelikle java dilindeki vektör sınıfı, java.util paketi altında bulunabilir. Dolayısıyla vektörler ile çalışırken kodun başına

import java.util.Vector;

yazmak gerekir. Yukarıdaki kodun 14. satırında da bu import işlemi ile koda başlanmıştır.

Kodun ana çalışan sınıfı (class) vektorDeneme isimli sınıftır ve bu sınıfın içerisinde bir adet main fonksiyonu bulunur. Bu fonksiyonun içinde victor isimli bir Vector tanımlanmıştır.

Ayrıca vektörün içerisinde tutulacak veri tipini belirlemek için bir oluşum sınıfı (composition class) tanımı yapılmış ve insan tipinin, boy ve yaş bilgilerinden oluştuğu kodlanmıştır. (kodun 14-23. satırları arası). Bu sınıf içerisinde bir inşa fonksiyonu (yapıcı fonksiyon, constructor) tanımlanmış ve iki tam sayı (int) alarak bir insanı tanımlamaya imkan sağlamıştır.

Kodun 28. satırında, insan tipinde bir ali nesnesi (object) üretilmiş ve bu nesne, 29. satırda, daha önceden tanımladığımız victor ismindeki vektöre yerleştirilmiştir.

Kodun 30. satırında, victor isimli vektörün boyutunun nasıl alındığı gösterilmiştir. Buna göre bir vektör nesnesinin .size() şeklinde metodu çağrılarak, boyutu alınabilir.

Ayrıca vektörün herhangi bir sıradaki elemanına erişmek için .elementAt() fonksiyonunu çağırmak ve bu fonksiyona parametre olarak kaçıncı elemana erişilmek istendiğini vermek yeterlidir.

Ne yazık ki 31. satırdaki çağırma işlemi sonucunda JAVA anlamlı bir şey basamaz. Bunun sebebi, vektörün 0. elemanı olarak konulan nesnenin tipinin belirsiz olması ve şu anda nesne sınıfına (object) çevrilmiş olmasıdır. Vektörün 0. sırasında bulunan bu elemanın üyelerine (members) erişmek için öncelikle insan tipine geri çevrilmesi gerekir. Bunun için tip inkılabı yapıp nesnenin başına parantezler içerisinde (insan) yazılmıştır. Ancak bu çevirim yapıldıktan sonra boy ve yas üyelerine erişilebilmiş ve ekrana basılmıştır.

Yukarıdaki kodun çıktısı aşağıda verilmiştir:

• vektör boyutu: 1
• vektörün 0. elemanı : javaapplication21.insan@190d11
• elemanın insan olarak boyu : 100 yasi : 10

Görüldüğü üzere, çıktının ikinci satırında, JAVA nesneyi ekrana basmıştır. (aslında ekrana basılan nesnenin dizgiye (string) çevrilmiş ve serilenmiş halidir, daha fazla bilgi için nesne serileme (serialization) başlıklı yazıya bakabilirsiniz).

Vektörlerin, JAVA dilinde bir tip kısıtlaması ile kullanılması da mümkündür.

Örneğin yukarıdaki kodda bulunan victor isimli vektöre, yeni elemanlar eklenirken herhangi bir kısıt bulunmaz. İkinci elemanı olarak öğrenci, üçüncü elemanı olarak ders tipinde nesneler eklenebilir. Bu nesnelerin hepsi Object tipine çevrilerek yerleştirilir. Ancak biz kısıtlamak istersek bir şablon tanımı (template) yapmamız mümkündür.

Vector<insan>kisitli = new Vector<insan>();

Şeklindeki tanım, sadece insan tipinden nesneler alabilir. Farklı tiplerdeki nesnelerin bu vektöre konulması mümkün değildir. Aynı zamanda tip dönüşümü yapmak da gerekmez. Yani bir önceki kodda bulunan ve vektörün herhangi bir elemanının boyu veya yaşını bastırmak için başına eklediğimiz (insan) ibaresinin bu kodda bulunması artık gerekmez. Çünkü JAVA bu sınıfların tiplerini bilmektedir ve bu tiplere göre erişime izin verir.

458 views

Bu yazının amacı, java dilinde bulunan final kelimesini açıklamaktır. Temel olarak final kelimesi, java dilinde 3 farklı yerde bulunabilir:

• Sınıf tanımında
• Metot (fonksiyon) tanımında
• Değişken tanımında

Sırasıyla bu durumları uygulamalar üzerinden görelim.

public final class sonsınıf{ }

yukarıdaki tanımın yapılması halinde, sınıf (class) nihai bir sınıf olur (final class) ve artık bu sınıftan kalıtım yapılamaz (miras, inheritance).

Örneğin yukarıdaki tanımdan sonra, aşağıdaki şekilde bir kod yazılması hatadır:

public class yenisınıf extends sonsınıf{ }

sebebi ise sonsınıf’ın nihai sınıf olarak tanımlanmış olmasıdır (final class).

Benzer şekilde bir metot tanımının başına final kelimesi yazılarak, metodun nihai olması durumunda, bu metodun üzerine bindirme yapılamaz (overriding).

Örneğin aşağıdaki kodu ele alalım:

public class deneme{

  public final int toplama(int a,int b){

     return a + b;

 }

}

Yukarıdaki kodda, toplama fonksiyonunun nihai hali kodlanmıştır. Bu sınıftan miras alan hiçbir sınıf toplama fonksiyonunu değiştiremez.

Örneğin aşağıdaki kod hatalıdır:

public class yenisınıf extends deneme{

  public int toplama(int a, int b){ }

}

Yukarıdaki bu kodun hatası, final olarak tanımlanan bir metodun üzerine bindirme yapıyor olmasıdır (overriding).

Son olarak bir değişkenin nihai olmasını inceleyelim. (final variables)

Bir değişken nihai tanımlandıysa, bu durumda içerisine atama sadece bir kere yapılabilir (assignment).

Örneğin aşağıdaki tanımı ele alalım:

final int x = 10;

yukarıdaki koddan sonra, kodun herhangi bir yerinde x değişkenine yeni değer atanamaz. Örneğin

x= 7;

yazılması durumunda hata alınır.

Nihayi değişkenler, sabit değişkenlerden farklıdır (constant variables, const)

En önemli farkı ise, derleme zamanında (compile time) değişkenin değerinin bilinmesi gerekmemesidir.

Örneğin aşağıdaki kodu ele alalım:

public class deneme{

  final int x;

  public deneme(int x){

   this.x = x;

  }

}

Yukarıdaki kod doğru ve çalışan bir koddur çünkü değişkene sadece bir kere, yapıcı fonksiyon marifetiyle (constructor, inşa fonksiyonu) atama yapılmıştır. Buna karşılık aşağıdaki kod hatalıdır:

public class deneme{

  const int x;

  public deneme(int x){

   this.x = x;

  }

}

Çünkü yukarıdaki kodda, değişkenin tanımı sırasında değer atanması yapılması gerekir. Örneğin

const int x = 10;

gibi ve bu atamadan sonra değer değiştirilemez. Örneğin yukarıdaki kodda bulunan final kelimesinin const kelimesi ile değişmesi halinde, yapıcı fonksiyonda (constructor) hala hata bulunmaktadır çünkü sabit bir değişkenin değeri değiştirilmeye çalışılmaktadır.

212 views

Bu yazının amacı, JAVA programlama dilinde bir sınıfın, birden fazla sınıftan nasıl miras aldığını anlatmaktır. Temel olarak JAVA dilinde doğrudan çoklu kalıtım (multiple inheritance) bulunmaz. Yani aşağıdaki gibi bir kod hatalıdır:

public class bilgisayar_mühendisliğ_öğrencisi extends sayısal_öğrenci, üniversite_öğrencisi{

}

Yukarıdaki tanıma göre bir bilgisayar mühendisliği öğrencisi hem üniversite öğrencisidir hem de sayısal bölüm öğrencisidir. Ancak JAVA, yukarıdaki bu tanıma izin vermez ve extends kelimesinden sonra sadece tek bir sınıf ismi yazılmasına izin verir.

Buna rağmen, JAVA programlama dilinde arayüz kullanarak (interface) bir sınıfın birden fazla sınıftan miras almasını sağlayabiliriz.

Çoklu mirasa geçmeden önce tek bir sınıfı, arayüz kullanarak nasıl miras aldığımızı görelim ardından birden fazla sınıf için bu yöntemi geliştirelim.

interface sayısal_öğrencisi_olma_şartı{

public void analitik_düşünmek();

}

Yukarıda bir sayısal öğrencisi olma şartı arayüzü tanımlanmıştır. Bu arayüz, herhangi bir sınıf tarafından uygulanırsa (implements) bu sınıfın analitik_düşünmek şeklinde bir fonksiyonu bulunması gerekir.

Şimdi bir bilgisayar mühendisliği öğrencisinin bu şartı sağladığını JAVA dilinde modelleyelim:

Public class bilgisayar_mühendisliği_öğrencisi implements sayısal_öğrencisi_olma_şartı{

public void analitik_düşünmek(){

// fonksiyon içeriği…

}

}

Yukarıda kodda görüldüğü üzere, uygulama şartı olarak (implements) arayüzde bulunan fonksiyonun içeriği yazılmıştır. Bu kodlamadan sonra artık bilgisayar mühendisliği öğrencisinin, sayısal öğrencisi olma şartını sağladığını söyleyebiliriz.

Şimdi bilgisayar mühendisliğindeki öğrencileri sayısal öğrencisi olarak tanıtabiliriz:

public class sayısal_öğrencisi {

double ortalaması;

public sayisal_öğrencisi( sayısal_öğrencisi_olma_şartı s){

s.analitik_düşünmek();

}

}

public class bilgisayar_mühendisliği_öğrencisi implements sayısal_öğrencisi_olma_şartı{

public void analitik_düşünmek(){

System.out.println(“düşünüyorum….”);

}

}

public class test{

public static void main(String args[]){

sayısal_öğrencisi ali = new sayısal_öğrencisi( new bilgisayar_mühendisliği_öğrencisi());

}

}

Yukarıdaki kod sonucunda ekranda, “düşünüyorum….” yazısı belirir. Bunun anlamı, ali isimli sayısal öğrencisinin, düşünmek isminde bir fonksiyonu olmasıdır.

Yazının başında da belirtildiği gibi JAVA doğrudan bir kalıtım ilişkisini desteklemez. Ancak yukarıdaki şekilde sınıflar arasında bir arayüz tanımlayarak bu iki sınıf arasında kalıtım ilişkisi kurulabilir.

Yukarıdaki kodda, yapılan eylem iki farklı yanlış anlaşılmaya açıktır. Genelde sık yapılan bu hataları aşağıda anlatmaya çalışalım.

1. Kalıtım değildir.

Yukarıdaki kod modeli, tam olarak kalıtım değildir. Sadece fonksiyonlar üzerinde tanımlıdır. Örneğin arayüzler (interface) üzerinde değişken tanımlanamaz.

2. HASA ve ISA arasındaki fark.

HASA ilişki modeli ile bir nesnenin diğer bir nesneyi içermesi, ISA ilişki modelinden farklıdır.

Bu durumu aşağıdaki şekil üzerinden açıklamaya çalışalım. Örneğin aralarında ISA ilişkisi bulunan iki sınıfı ele alalım:

Bu çizimi bir küme modeli ile modellemek istersek aşağıdaki şekilde bir sonuç çıkar:

Yukarıdaki model, nesne varlığı açısından kurulmuştur. Bu modele göre, insan, öğrenci’nin bir alt sınıfıdır. Yani öğrenci, insanda olan bütün özellikleri ve eylemleri kapsar ilave olarak kendisine özgü bazı özellikleri de bulunabilir. ( bu modelleme aslında çok sağlıklı değildir çünkü genelde kavram-varlığı açısından karmaşaya sebep olur. Modele kavram-varlığı açısından bakılırsa aslında öğrenci, insanın bir alt kümesidir ve insan kümesinde farklı varlıklar da vardır (örneğin öğrenci olmayan diğer insanlar) ancak yukarıdaki model tekrar ediyorum nesne-varlığı açısından çizilmiştir).

Yukarıdaki modeli elde etmenin birinci yolu miras ilişkisi kurmaktır (kalıtım inheritance) diğer yolu ise HASA ilişkisi tanımlamaktır.

public class öğrenci extends insan{

}

Şeklindeki bir tanım, insan sınıfındaki bütün tanımları otomatik olarak öğrenci sınıfına taşıyacak ve ardından yukarıda çizilen küme modelini gerçekleyecektir.

public class öğrenci{

insan a;

}

Ancak bu gerçekleme bir kalıtım ilişkisi olarak kabul edilemez. Bu gerçeklemede aslında iki farklı varlık vardır ve bu varlıklar arasında var oluştan kaynaklanan bir fark yoktur.

public class test{

public static void main(String args[]){

insan ali = new insan();

öğrenci veli = new öğrenci();

veli.a= ali;

}

Yukarıdaki bu model sonucunda, ali, velinin bir alt kümesi halini alır ancak buradaki ali’nin varlığı ile veli’nin varlığı arasında bağlayıcılık yoktur. Örneğin veli nesnesi (object) yok edilmesi sonucunda ali yaşamına devam edebilir. Bu tip ilişkilere münasebet (aggregation) ismi verilmektedir ve yukarıdaki yazıda anlatılan arayüz marifetiyle kalıtımdan tamamen farklı bir yapıdadır.

581 views