Search Results for: hiyerarşi

Eclipse IDE Üzerine – II: Working Set, Ayarlar ve Proje Yönetimi

Java, Java Dersleri , , ,

Bir önceki yazımızda Eclipse’e giriş yapmış, kurulumu, workspace, workbench ve perspective yapılarını ele almış ve ilk kodumuzu yazıp çalıştırmıştık. Bu yazıda Eclipse’te working set oluşturma, ayarlar ve eklentileri ele alacağız.

Eclipse’te Working Set

Projelerinizi gruplamak isterseniz, “Working Set” kullanabilirsiniz. Varsayılan working set “Window Working Set”tir ve tüm projeler varsayılan durumda buradadırlar. Yeni working setler oluşturup, projeleri onlara ekleyebilirsiniz. Sonrasında working set seçerek, sadece onun projelerinin Package Explorer’da görünmelerini sağlayabilirsiniz.

Yeni bir working set oluşturup Java projelerini eklemek için File menüsünde ya da Package Explorer’da New => Java Working Set ile açılan pencerede oluşturacağınız working sete bir isim verip, var olan projelerden istediklerinizi seçip “Add” düğmesi ile kendisine ekleyebilirsiniz.  “Add All” düğmesi ile sol taraftaki tüm projeleri yeni oluşan working sete ekleyebilirsiniz.

Varsayılan working set “Window Working Set”tir. Farklı bir working sete geçmek istediğinizde Package Explorer sekmesinde, sağ üstteki aşağı doğru bakan küçük üçgeni tıklayıp, açılan menüden “Select Working Set”i seçmeniz gereklidir. Çıkan pencerede istediğiniz working seti seçebileceğiniz gibi yenisini oluşturabilir ya da var olanı değiştirebilir ve silebilirsiniz. Sonra istediğiniz working seti, benzer şekilde Package Explorer sekmesinde, sağ üstteki aşağı doğru bakan küçük üçgeni tıklayıp, açılan menüden “Select Working Set”i tıklayarak seçebilirsiniz.

Yeni bir proje oluştururken de working set seçebilir ya da yenisini oluşturabilirsiniz. Bu amaçla açılan “New Java Project” penceresinde “Add project working sets” seçimini yapmanız ve altından working set seçmeniz ya da “New” düğmesini tıklayarak yeni working set oluşturmanız gereklidir.

Eclipse Ayarları

Eclipse’te tüm ayarlar Preferences altındadır.

  • JRE,
  • Workspace,
  • Font ve renk,
  • Kısa yollar, şablonlar ve diğer ayarlar.

Preferences’a, Windows ve Linux’te sağ üst köşedeki Window Mac OS’ta sol üst köşedeki Eclipse menüsünden gidilir. Kısa yolu Windows/Linux’te “CTR+,”Mac OS’ta “⌘+,”dır.

JRE

Eclipse’in farklı projeler için farklı JRE’ler kullanmasını sağlayabilirsiniz. Bu amaçla JRE’leri Eclipse’e tanıtmanız gereklidir. Bunun için Preferences => Java => Installed JRE’s sayfasına gidip, buradan Eclipse’in kullanacağı JRE’leri yönetebilir, ekleme ve çıkarma yapabilirsiniz. Birden fazla JRE varsa, seçilen bir tanesi ise varsayılan JRE olacaktır. Preferences => General => Startup and Shutdown sayfasından workspacelerinizi düzenleyebilirsiniz.

Fontlar ve Renkler

Font ve renk ayarları, geliştirici için hem rahatlık hem de görsellik açısından önemlidir. Fontları, Preferences => General => Appearance => Colors and Fonts sayfasından değiştirebilirsiniz. Örneğin Java fontları için 11 puntoluk Monaco seçimi buradan yapılabilir.

Preferences => Editors => Text Editors => ile varsayılan arka plan (background color) ve ön plan (foreground color ) renkleri ile bunların alan seçimi (selection background color/selection foreground color) halindeki renklerini değiştirebilirsiniz. Java kodlarının daha detaylı renk ayarları için Preferences => Java => Editor => Syntax Coloring sayfasına giderek farklı Java kod parçalarının renk vb. özelliklerini değiştirebilirsiniz.

Eclipse Şablonları

Eclipse’te sık yazılan Java kodları için kısa yollar mevcuttur. Var olan kısa yollara Preferences => Java => Editor => Templates ile ulaşabilirsiniz. Kısa yollar, kısaltmasını yazıp sonrasında CTRL+Space yaparak çalışırlar. Sık kullanılan kısa yollar:

  • main: Main metotu yazar
  • sysout: System.out.println() yazar.
  • syserr: System.err.println() yazar, System.out.println()’ın kırmızı renkle yazanıdır.

Ben bunları da ma, sop ve ser olarak kısaltmayı tercih ediyorum 😀

Eclipse’e Proje Yüklemek

Eclipse’e, yeni bir Eclipse projesi yükleyebilirsiniz. Örneğin bu dersin projesini, “Introduction to Object-Oriented Programming with Java”, kullanmak için, onu Eclipse’e yüklemeniz gereklidir. Bu amaçla File menüsünde ya da Package Explorer’da sağ tık ile Import’u seçin. 

  • Çıkan Import penceresinden yükleyeceğiniz projenin tipini seçin.
  • Ant, Maven. vb. tipte proje yapıları için farklı seçenekler mevcuttur.
  • Bu dersin projesi en temel Eclispe projesi olduğundan General => Existing Project into Workspace seçin ve Next’i tıklayın.
  • Sonrasında çıkan Import penceresinde ya en yukarıdaki  Browse düğmesini tıklayarak bu dersin projesinin dizinini ya da altındaki Browse düğmesini tıklayarak projenin zip dosyasını seçin.
  • Projenin patikasının seçiminize göre “Select root directory” ya da “Select archive file”da görünmesini sağlayın.
  • Eclispe’e proje yüklerken en son adımda “Copy projects into workspace” seçeneğinin seçili olduğundan emin olun.
  • Ayrıca proje yüklerken “Add project into working sets”ı tıklayarak working set de seçebilirsiniz.

Eclipse’te Proje Görünümü

Eclipse, varsayılan durumda projedeki tüm paketleri alt alta sıralayarak, “flat” olarak gösterir. Bu ise yönetmesi daha zor bir görüntü oluşturur. Projedeki paketleri hiyerarşik olarak görmek için Package Explorer sekmesinde, sağ üstteki aşağı doğru bakan küçük üçgeni tıklayıp, açılan menüden “Package Presentation”i seçip, çıkan menüde “Hierarchical”ı tıklayın.

Eclipse’te Proje Kapatmak ve Silmek

Project Explorer’da pek çok proje görünmesine rağmen sadece ilgilendiklerinizin açık olmasını isterseniz, diğer projeleri kapatabilirsiniz. Kapatılan proje ile yanlışlıkla ona değişiklik yapmanın önüne geçersiniz. Eclipse workspacesi derlemek gibi, yaptığı bazı genel işlemleri kapalı projelere uygulamaz. Ayrıca Eclipse’in performansının artmasına yardımcı olur. 

Bunun için kapamak istediğiniz projede sağ tık yapıp, çıkan menüden “Close Project”i seçin. Bu durumda proje kapanacak ve ikonu değişecektir. Proje üzerinde çift tık yaparak ya da üzerinde sağ tık yapıp, çıkan menüden “Open Project”i seçerek tekrar açabilirsiniz. Proje üzerinde sağ tık yapıp, çıkan menüden “Close Unrelated Projects”i seçerseniz, o projeyle ilgisi olmayan diğer projelerin hepsini kapatır. Projelerin birbirleriyle ilgili olmalarının ne anlama geldiğini ileride göreceğiz.

Eclipse’in yönettiği bir projeyi Eclipse’ten silebilirsiniz. Eclipse, silinen bir projeden artık haberdar olmayacaktır. Silinen bir proje tekrar Eclipse’e yüklenebilir. Projeyi silmek için üzerinde sağ tık yapıp, çıkan menüden “Delete”i seçin. İsterseniz “Delete project contents on disk (cannot be undone)” de seçerek projenin diskten tamamen silinmesini sağlayabilirsiniz. Bu seçeneği tıklamadığınızda proje diskten silinmeyecek sadece Eclipse’ten silinecektir.

Eclipse’te Proje Özellikleri

Eclipse’de projelerin özelliklerine, proje ismi üzerinde sağ tık yapıp, çıkan menünün en altındaki Properties’i seçerek gidebilirsiniz. Resource’u seçerek projenin karakter kodlamasını (character encoding), Java Built Path => Libraries seçerek, projenin JRE’sini, Java Compiler’ı seçerek projenin derleme sürümünü, Java Code Style’ı seçerek projeye has kodlama stilini belirleyebilirsiniz. Varsa ilgili eklentilerin projeye özgü ayarlarına da buradan ulaşabilirsiniz.

Eclipse’i Kapatmak

Eclipse’i işletim sisteminize göre, penceresinin sol ya da sağ üst köşesindeki kapatma düğmesinden ya da Windows/Linux’te File => Exit, Mac OS’ta Eclipse => Quit ile kapatabilirsiniz. Kapatma kısa yolu Windows/Linux’te ALT+F4, Mac OS’ta “CMD+Q (⌘+Q)”dır.

Eclipse kapanırken size “Do you want to exit the Eclipse?” diye sorar. Bu soruyu her seferinde sormasını istemiyorsanız “Remember my decision”ı seçip “Exit”e basın.

Eclipse Kısa Yolları

Eclipse’te pek çok kısa yol vardır. Kısa yollarla ilgili yardıma Help => Help Contents ile açılan sayfada, Workbench User Guide => Reference => User Interface Information => Development Environment => List of key bindings’e giderek ulaşabilirsiniz. Internette de pek çok kısa yol listesi vardır.

Preferences => General => Keys ile, varsayılan kısa yollara ulaşabilir, yenilerini oluşturabilir ya da var olanları değiştirebilirsiniz. Help => Show Active Keybindings ile açılan pencerede kısa yolları liste olarak görebilirsiniz.

Kısa yolların pek çoğunda Windows ve Linux’teki CTRL yerine Mac OS’ta CMD (⌘) gelir. Örneğin Windows/Linux’te CTRL+D ya da Mac OS’ta CMD+D (⌘+D) üzerinde olunan satırı siler.

Eclipse Yardım (Help)

Eclipse’te Yardım (Help) için Help menüsünü kullanın. Help => Help Contents, tarayıcıda Eclipse’in tüm yardım içeriğini açar. Help => Search, Eclipse’te sağ tarafta Help içinde arama imkanı sağlar.

Ayrıca Windows/Linux’te CTRL+3, Mac OS’ta CMD+3 (⌘+3) ile hızlı erişimi (quick access) açıp, kısayol vb. bilgilere hızlıca ulaşabilirsiniz. Örneğin, hızlı erişim penceresinde “Run” yazıp, çıkan listeden Menus’ün altından “Run As”i seçip açık olan sınıfı çalıştırabilirsiniz.

https://help.eclipse.org/ adresinden de detaylı bilgi alabilirsiniz.

 

Toplam görüntülenme sayısı: 7784

Tasarım Kalıpları – II: Neden Öğrenelim?

Java, Tasarım Kalıpları, Yazılım Mühendisliği ,

Bu yazıda tasarım kalıplarını neden öğrenmemiz gerektiğini ele alalım.

“Tasarım Kalıpları” tamlaması, kullanıldığında bir “üst perde” havası oluşturan bir kavrama karşılık geliyor. Sanki bu tamlamayı kullanan kişi birden “erenler”den oluveriyor. Kullanıldığında konuya ve özellikle de kullanana “ileri derecede karmaşıklık” ya da “sofistikasyon” atfediyor. Halbuki durum öyle değil, ama belli ki bu algı bizim cehaletimizden kaynaklanıyor.

Bir de bu konuda öğrenilmiş çaresizlik yaşıyor gibiyiz. Ben üç-beş defa bu konuyu öğrenmeye niyetlenmiş ve girişmiş ama her seferinde belli bir yerde bırakmak zorunda kalmış insanlarla tanıştım. Ülkemizdeki “İngilizce”nin durumu gibi 🙁 Sanki bilmek zorundaymışız, ciddi bir miktar zaman harcamışlığımız da var ama malesef henüz tam olarak bilmiyoruz gibi bir durumdayız. Her eğitimde ya da danışmanlıkta müşteri tarafında olan yazılımcı arkadaşlar bazen bir miktar uğraştıklarını göstermek, bazen kötü durumda olan kodlarının bu durumunu açıklamak ya da doğrudan benimle sohbet etmek vs. gibi sebep ve niyetlerle tasarım kalıpları tamlamasını ya da bazı tasarım kalıplarını telaffuz ederler.

Tasarım kalıpları etrafındaki oluşan bu buğulu havayı dağıtmak, başarılı bir öğrenim süreci için elzem görünüyor.

Tasarım kalıplarını kullanmadan program yazmaya başladığınızda ilk yapacağınız hata, program olarak ifade etmeye çalıştığınız iş süreci ya da problemindeki sorumlulukları roller olarak ayırt edememenizdir. Yani “bu problemin çözümünde hangi sorumluluklar var?” ve “bu sorumluluklar farklı nesnelere nasıl dağıtılmalı?” sorularının sorulması ve cevaplanması aslen bir tasarım faaliyetidir. Hatta tasarım daha doğrusu fonksiyonel tasarım faaliyeti temelde bu soruları açıklığa kavuşturmak, alternatif cevaplar verip bunları kıyaslayarak sonuca ulaşmadan ibarettir bile denebilir. Tasarım yapma niyetiniz yoksa ki bunu biz “zamanımız yok” diye ifade ederiz, zaten bu yazının geri kalanı anlamsız olur 🙂 Yok, doğru düzgün bir yapı ortaya çıkarmak için tasarıma niyetimiz varsa tasarıma vakit ayırırız ki yukarıdaki soruları sorarız ve tasarım kalıplarının yardımıyla vereceğimiz cevaplarla nesne modellerini oluştururuz.

Tasarım yapılmazsa dolayısıyla da tasarım kalıpları kullanılmazsa, istenildiği kadar en yeni teknolojiler kullanılsın ya da nesne-merkezli bir dille program yazılsın, sağlıklı bir nesne yapısı kurgulama ihtimali sıfıra yakındır. Çünkü, yukarıda bahsettiğim, sorumlulukları bulma ve nesnelere dağıtma işinin sağlıklı yapılmaması söz konusudur. Bu durumda da gidilecek yön, nesne-merkezli programlama değil, olsa olsa prosedürel programlama hatta daha da kötüsü, karman-çorman kod yığınıdır.

Örneğin, normalde tasarım yaparak ve tasarım şablonlarını kullanarak nesnelere ve üzerinde muhtemelen override edilmiş metotlara bölünecek bir davranışın, tek bir metot altında pek çok “if” kullanarak kodlandığı sıklıkla görülür. Bu durum ise olsa olsa “functional decomposition”dır ve başınızı gittikçe belaya sokan bir yaklaşımdır. Dolayısıyla tasarım kalıpları çoğu defa bize, normalde nesne-merkezli programlama dili kullanmamıza rağmen prosedürel anlayışla yazılım geliştirmeye düşmekten kaçınmamızı sağlar. Tam da bu yüzden pek çok refactoring yani kod iyileştirmesi tekniği, var olan karmaşık ve devasa hale gelmiş nesne ve metotları, farklı kalıpları kullanarak, ufak-tefek nesne ve metotlara dönüştürür. Tasarım kalıplarının bunu yaparken elinde tuttuğu temel teknik, yukarıda bahsettiğim iki sorudur: “bu problemin çözümünde hangi sorumluluklar var?” ve “bu sorumluluklar farklı nesnelere nasıl dağıtılmalı?” Zaten bu sorular sorulmadığından devasa sınıflara ve metotlara ulaşılmıştır.

Ben danışmanlıklarımda, özellikle kod kalitesini arttırıcı işlerimde bu durumlarla çok sık karşılaşıyorum. Tek yapacağım şey konuyu anladıktan sonra bu iki soruyu sormak. Tasarım kalıpları, bu iki sorunun cevabını ciddi oranda veriyorlar. Çünkü tasarım kalıpları hem bir yöntemdir hem de bir sorumluluk kataloğudur. Tasarım kalıpları yöntemdir çünkü bu iki soruyu sormanızı ve nasıl cevap vereceğinizi size öğretir. Tasarım kalıpları aynı zamanda bir sorumluluk kataloğudur, çünkü en basitinden en karmaşığına kadar, farklı sektördeki yazılımlarda bulunan en yaygın sorumlulukları ortaya koyar. Dahası tasarım kalıpları, bu sorumlulukları nasıl bulacağınızı ve bunları iç tutarlılığı yüksek (highly-cohesive) ve dış bağımlılığı düşük (lowly-coupled) nesne modellerine nasıl çevireceğimizi de bize gösterir.

Eğer tasarım faaliyeti, yazılım geliştirme sürecinizin bir parçası ise zaten yolunuz bir şekilde kalıplarla kesişiyor demektir. Yani sadece Gof’un 23 kalıbını kullanmakla kalmıyor, kendi iş alanınızda sıklıkla karşılaştığınız sorumluluk problemlerine özel kalıplar da geliştiriyorsunuz demektir.

Dolayısıyla tasarım kalıplarını şu amaçlarla öğrenmeliyiz:

  • Tekerleği yeniden keşfetmemek, var olan ispatlanmış çözümleri kullanmak: Tasarım kalıpları sıklıkla karşılaştığımız, yaygın sorumluluk bulma ve dağıtma problemlerini çözerek, tekrar kullanılabilen, faydası ispatlanmış modeller ortaya koyar.
  • Formal ve yaygın bir dil oluşturmak: Tasarım kalıpları, formal bir kalıp dili (pattern language) oluşturmaktadır. Bu kalıp dilinin en temel kavramı sorumluluktur. Dolayısıyla tasarım kalıpları zihnimize, “şu şey yapar, şunu alır şuna verir” gibisinden sokak ağzı bir konuşma yerine “kontrol nesnesi (controller), request ve response nesnelerini, ilgili üreticilerden (factory) alıp sunum (view) nesnesine geçer” şeklinde konuşmayı öğretir. Bu dilin yazılım geliştiriciler arasında yayılması, anlaşmayı kolaylaştıracak, ifade gücümüzü arttıracaktır.
  • Tasarıma uygun, yüksek soyutlama gücü kazandımak, detaylardan sıyrılıp, daha yüksek hedefler cinsinden düşünmek: Bu anlamda tasarım kalıpları daha iyi bir yazılım geliştirici hatta mühendisi olmanın en temel gerekliliklerindendir.

Zaman zaman karşılaşıyorum, “biz aslında bir miktar tasarım yapmıştık” şeklinde cümlelerle. Bırakın kalıbı sistemde hiç arayüz yok, hiç bir nesne hiyerarşisi yok, devasa sınıflar ve metotlar var, nesneler arası ilişkiler karmakarışık, kim neyi biliyor belli değil, peki tasarım nerede? Yukarıda anlattığım gibi tasarım yapılacaksa o iki sorudur üzerinde düşünülmesi ve çözülmesi gereken şey. Ve yolunuz bir şekilde tasarım kalıplarıyla kesişir.

Tasarım kalıplarını bilmiyorsanız, tasarım da yapamazsınız.

Bol tasarımlı günler dilerim 🙂

Toplam görüntülenme sayısı: 1732

Arayüzlerde Varsayılan Metotlar (Default Methods) – II

Java

Bir önceki yazıda arayüzlerdeki bir gerçekleştirmeye sahip olan metotlara giriş yapmıştık.

Java SE 8 ile birlikte gelen, arayüzlerde varsayılan metot kullanımı, default method, işin içine girdikçe kafamızı karıştırmaya devam edecek gibi görünüyor. Bende hep öyle olur. Bir konuyu öğrenirken başta çok karmaşık gibi gelmez ama sıklıkla, ilerlemeyle birlikte durum çetrefilleşir ve olmadık yerlere çıkar. Bu durum tabi olarak büyük keyif verir, zekanızı zorlar, sizi düşünmeye iter ama geldiğiniz noktanın acaipliği hep aklınızda kalır.

Bakın arayüzlerde default metot kullanımının bizi getirdiği yere. Hangisinden başlayalım? Çoklu mirası (multiple inheritance) ele alalım önce.

C++’tan bilirim, eğer bir alt sınıf, aynı virtual olmayan metoda sahip iki sınıftan miras devralıp da o metodu override etmezlerse, probleminiz var demektir. Eski zamanlardan hatırladığım şey bu duruma “diamond problem” ya da “deadly diamond of death” dendiği. Java’da bir sınıftan devralma anlamında çoklu mirasa izin verilmeyişi, sadece arayüzlerden devralma anlamında çoklu mirasın söz konusu oluşu, bu problemi şu ana kadar ertelemişti. Ama arayüzlere default metot koyunca durum değişti. Bakın, Artist bir arayüzümüz ile onun alt arayüzleri olan Actor ve Musician arayüzlerimiz olsun:

package org.javaturk.oofp.ch04.multipleInheritance;

public interface Artist {
	
	void play();
}
package org.javaturk.oofp.ch04.multipleInheritance;

public interface Actor extends Artist{
	
	default void play(){
		System.out.println("Actor plays!");
	}
}
package org.javaturk.oofp.ch04.multipleInheritance;

public interface Musician extends Artist{
	
	default void play(){
		System.out.println("Musician plays!");
	}
}

Yukarıdaki henüz tamamlanmamış elması, Actor ve Musician arayüzlerininden devralan ama “play()” metoduna bir gerçekleştirme vermeyen MusicianActor sınıfı ile tamamlayalım:

package org.javaturk.oofp.ch04.multipleInheritance;

public class MusicianActor implements Actor, Musician{

}

Diamond Problem

 

 

MusicianActor‘ün araryüzünde “play()” metodu var ama hangi gerçekleştirmeye sahip? Gelinen noktada, “diamond problem” ile karşılaştık. Bu durumda MusicianActor sınıfı derlenmeyecektir. Bunu çözmenin yöntemi ise ancak MusicianActor‘ün “play()” metoduna bir gerçekleştirme vermesidir.

package org.javaturk.oofp.ch04.multipleInheritance;

public class MusicianActor implements Actor, Musician{
	
	public void play(){
		System.out.println("MusicianActor plays!");
	}
}

Dolayısıyla default metotlara sahip olmanın ilk maliyeti, diamond problemine duçar olmaktır.

Default metotlarla alakalı bir başka durum ise, üst bir arayüzün default metot tanımlamasına karşın, onun alt arayüzünün aynı metodu abstract olarak tekrar tanımlamasında oluşur. Yukarıda verdiğimiz örneği biraz değiştirerek devam edebiliriz. Bu defa Actor, play() metodunu default olarak tanımlar:

package org.javaturk.oofp.ch04.multipleInheritance.v2;

public interface Artist {
	
	default void play(){
		System.out.println("Artist plays!");
	}
}

Ve tek alt arayüzleri olarak Musician ise “play()” metodunu abstract olarak tekrar tanımlarlar:

package org.javaturk.oofp.ch04.multipleInheritance.v2;

public interface Musician extends Artist{
	
	void play();
}

Tabi olarak bu durumda, hiyerarşinin en altındaki Pianist sınıfı “play” metoduna bir gerçekleştirme sağlamak zorundadır, aksi taktirde abstract bir sınıf olur. Pianist‘i abstract yapalım:

package org.javaturk.oofp.ch04.multipleInheritance.v2;

public abstract class Pianist implements Musician{	
}

 

Garip bir hiyerarşi!

Geçmiş olsun 🙂 Herkese iyi günler dileriiim, iyi hafta sonlarııııı 🙂

Üst arayüz Artist ile Musician ve Pianist arasındaki ilişkiye bir bakın. Farkedebildiniz mi?

Gariplik şurada: “interface” anahtar kelimesiyle oluşturduğumuz arayüzler, bir önceki yazıda da vurguladığım gibi sadece davranışların tanıtımının (declaration) yapıldığı yerlerdir. Davranışların tam olarak tanımlandığı (definition) yer değildir, davranışlar arayüzlerde tanıtılır, sınıflarda tanımlanır. Bu yüzden bu yapılara, sadece arayüz sağladığı için “arayüz” ya da “interface” denir. Ama yukarıdaki durumda tanımlamayı yapan arayüzdür, tanıtımı yapan ise sınıf! “play()” metodu Artist arayüzünde tam olarak tanımlanıyor ama hiyerarşinin en altındaki Pianist sınıfı ise aynı davranışı tanıtıyor, yani üst tipi olan Mucisian arayüzünden abstract olarak devralıyor ama bir gerçekleştirme vermiyor.

Ne demiş atalarımız böyle durumlarda: “Ne oldum demeyeceksin, ne olacağım diyeceksin.” ya da “büyük lokma ye büyük laf konuşma.”

Bol düşünmeli bir haftasonu dilerim 🙂

Toplam görüntülenme sayısı: 692

Tasarım Kalıpları: Prototype (Prototip ya da Örnek Nesne)

Kategorisiz

GoF’un nesne yaratmayla ilgili 5 kalıbından bir diğeri de Prototype’dır. Dilimize “prototip” ya da “örnek nesne” olarak çevrilebilecek olan bu kalıbın amacıyla ilgili GoF’da şu bilgiler bulunmaktadır:

Intent: Specify the kinds of objects to create using a prototypical instance, and create new objects by copying prototype.

Amaç: Prototip bir nesneyi kullanarak yaratılacak nesneleri belirlemek ve yeni nesneleri prototipi kopyalayarak oluşturmak.

Anlaşılması son derece kolay ve tabi olan bu kalıbı özellikle karmaşık ve durumları arasında az farklar olan nesneleri yaratmada başarıyla kullanabiliriz.

Uygulamalarda sıklıkla iş sınıflarından nesneler oluştururuz. Bu nesneler zaman zaman ciddi karmaşıklıkta olurlar. Aynı tipten olan nesneleri sıklıkla farklı durumlarla yaratmak isteriz: UnAuthenticatedUser ve AuthenticatedUser gibi.

Bazen karmaşık bir nesneyi yaratıp, o nesneyi kopyalayarak yeni nesneler yaratabiliriz. Kopyalanan nesne prototip nesnedir. Bazen de karmaşık bir nesneyi, farklı durumlarla yaratmak isteriz. Yani nesnenin ilk yaratıldığında alacağı farklı durumlar ise birbirlerinden türetilebilir.

Çözüm olarak diğer nesnelerin yaratılabilmesi için oluşturulan örnek nesne ya da prototipten başlayabiliriz. Yani prototip olarak oluşturulan bir nesne, aynı türden diğer nesnelerin yaratılması için bir başlangıç noktasıdır. Dolayısıyla, yeni nesneler oluşturmak, için var olan prototipi kopyalarız (cloning). Muhtemelen prototype ile diğer nesneler arasında durum farklılıkları vardır. İstenirse bu farklı durumlar tek bir prototipten üretilen nesne üzerinde, gerekli setter metotları çağrılarak oluşturulur. İstenirse de farklı durumlar için farklı prototipler üretilir.

Örneğin aşağıdaki gibi örnek amacıyla yapılmış olduğundan basit yapıyı ele alalım.

ClassDiagram1

Örnek kodlar da aşağıdaki gibi olacaktır.

package org.javaturk.dp.pattern.gof.creational.prototype.simple;

public abstract class Customer implements Cloneable {
	protected int id;
	protected String address;
	protected String phone;
	boolean authenticated;

	public Customer(int id, String address, String phone) {
		this.id = id;
		this.address = address;
		this.phone = phone;
		authenticated = false;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getPhone() {
		return phone;
	}

	public void setPhone(String phone) {
		this.phone = phone;
	}

	public boolean isAuthenticated() {
		return authenticated;
	}

	public void setAuthenticated(boolean authenticated) {
		this.authenticated = authenticated;
	}
	
	@Override
	public String toString() {
		return "Customer [id=" + id + ", address=" + address + ", phone="
				+ phone + ", authenticated=" + authenticated + "]";
	}

	@Override
	public Customer clone() {
		Customer customer = null;
		try {
			customer = (Customer) super.clone();
		} catch (CloneNotSupportedException e) {
			System.out.println("Problem when cloning the object: " + e.getMessage());
			e.printStackTrace();
		}
		return customer;
	}
}

Görüldüğü gibi nesnenin “clone()” metodu override edilmiştir.

Benzer şekilde yapıdaki diğer iki nesne de şöyledir:

package org.javaturk.dp.pattern.gof.creational.prototype.simple;

import java.util.Date;

public class IndividualCustomer extends Customer{
	private String firstName;
	private String lastName;
	private Date dob;
	
	public IndividualCustomer(int id, String address, String phone,
			String firstName, String lastName, Date dob) {
		super(id, address, phone);
		this.firstName = firstName;
		this.lastName = lastName;
		this.dob = dob;
	}

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public Date getDob() {
		return dob;
	}

	public void setDob(Date dob) {
		this.dob = dob;
	}

	@Override
	public String toString() {
		return "IndividualCustomer [firstName=" + firstName + ", lastName="
				+ lastName + ", dob=" + dob + ", id=" + id + ", address="
				+ address + ", phone=" + phone + ", authenticated="
				+ authenticated + "]";
	}
}
package org.javaturk.dp.pattern.gof.creational.prototype.simple;


public class CorporateCustomer extends Customer {

	private String corporateName;
	private double discount;

	public CorporateCustomer(int id, String address, String phone,
			String corporateName, double discount) {
		super(id, address, phone);
		this.corporateName = corporateName;
		this.discount = discount;
	}

	public String getCorporateName() {
		return corporateName;
	}

	public void setCorporateName(String corporateName) {
		this.corporateName = corporateName;
	}

	public double getDiscount() {
		return discount;
	}

	public void setDiscount(double discount) {
		this.discount = discount;
	}

	@Override
	public String toString() {
		return "CorporateCustomer [corporateName=" + corporateName
				+ ", discount=" + discount + ", id=" + id + ", address="
				+ address + ", phone=" + phone + ", authenticated="
				+ authenticated + "]";
	}
}


Bu durumda client kodumuz da basitçe şöyle olacaktır:


package org.javaturk.dp.pattern.gof.creational.prototype.simple;

import java.util.Date;

public class Test {

	public static void main(String[] args) {
		IndividualCustomer unAuthenticatedCoskunCustomerPrototype = new IndividualCustomer(1,
				"Cumhuriyet Cad. No 28 Beşiktaş Istanbul", "2128399041",
				"Selim", "Coskun", new Date());
		System.out.println(unAuthenticatedCoskunCustomerPrototype);
		
		
		IndividualCustomer authenticatedAhmetCoskun = (IndividualCustomer) unAuthenticatedCoskunCustomerPrototype.clone();
		authenticatedAhmetCoskun.setId(2);
		authenticatedAhmetCoskun.setFirstName("Ahmet");
		authenticatedAhmetCoskun.setAuthenticated(true);
		System.out.println(authenticatedAhmetCoskun);
		
		
		CorporateCustomer unAuthenticatedGECustomerPrototype = new CorporateCustomer(100, "Manolya Cad. No 5 Sariyer Istanbul", "2124199047", "GE", 0.25);
		System.out.println(unAuthenticatedGECustomerPrototype);

	}
}
Bu basit uygulamadan da görüldüğü gibi, karmaşık nesneler, bir örnek nesneden clonelanarak oluşturulup,  gerekirse olması gereken duruma getirilebilir.

Okuyuculara ödev olarak aşağıdaki durumu verebiliriz:


	public JTUser execute(RegistrationForm form, 
          HttpServletRequest request, Locale locale) throws JTException {

		String uid = utils.generateUUID();
		String salt = utils.generateSalt(32);
		String accountId = utils.generateUUID();

		JTUser user = new JTUser(
				form.getEmail().trim(), null, true, true, true, true,
				AuthorityUtils.NO_AUTHORITIES, // spring security fields
				uid, formorm.getEmail().trim(), salt, form.getName().trim(),
				form.getSurname().trim(), null, accountId, true,
				true, form.getWelcomeMessage().trim(), true,
				new Date(), null);

		user.setStatus(JTConstants.PENDING);

		String servletPath = request.getServletPath();
		if (executeInner(form, locale, user)) {
		     auditLogDao.insert(new AuditLog(user.getUid(), user.getUsername(),
					utils.getRemoteIp(), utils.getSid(),
					AuditType.REGISTRATION, AuditSubtype.PENDING,
					ResponseCode.SUCCESS, new Date(), null));

		     authenticateFastRegisterUser(form, request);
		}

		return user;


Yukarıdaki kodu prototype kalıbıyla nasıl iyileştirebiliriz? Kodda JTUser oluşturulurken pek çok boolean parametre geçildiği görülüyor. Muhtemelen sistemde farklı JTUser nesneleri farklı boolean değerlerle oluşturuluyor. Bu durumda prototype kalıbı kullanışlı görünüyor.


Benzer durum AuditLog nesnesi için de geçerli midir?


Prototype kalıbının artısı, Factory ya da Abstract Factory kalıplarında var olan miras mekanizmasını kullanmamasıdır. Çünkü yeni nesneler sadece var olan prototipten üretilirler, ama factorylerde her nesne için ayrı bir üretici sınıf vardır. Bu yüzden derin factory hiyerarşisinden kaçmak için Prototype kalıbını kullanabilirsiniz.


Factory Method ve Abstract Factory nesne oluştururken Prototype kalıbını kullanabilir. Prototype, Composite ve Decorator kalıplarında sıklıkla kullanılır.


Toplam görüntülenme sayısı: 2696



					
				

						
					

					
				


	


		
		


		
	

	
	



							
											
			

			

			
 1  2  3  4  5