Warning: Cannot modify header information - headers already sent by (output started at /home/yusuf/public_html/yusufaytas.com/wp-content/themes/beveled/includes/widgets/widget-woo-tabs.php:1) in /home/yusuf/public_html/yusufaytas.com/wp-includes/feed-atom.php on line 8
Yusuf Aytaş Yazılım Çözümleri 2012-01-30T11:56:07Z http://www.yusufaytas.com/feed/atom/ WordPress Yusuf Aytaş http://www.yusufaytas.com <![CDATA[Cepheye Yönelik Programlama]]> http://www.yusufaytas.com/?p=608 2012-01-30T11:56:07Z 2012-01-30T07:50:57Z Yazılım dünyasında başlıca endişelerinden biri, yazılımdaki parçaların biri birine çok bağlanmasıdır(high coupling, cross-cutting concerns). Bu durum yazılımın belirli bir noktadan sonra anlaşılmaz, ayrıştırılamaz, ilerletilebilemez hale gelmesine yol açar. Çare olarak yazılımcılar, en yaygın yöntem olan yazılım şablonlarını kullanırlar. Fakat, bazen işler o kadar karmaşık bir hal alır ki artık, yazılım şablonları da karmaşayı sonlandıramaz. Bu noktada cepheye yönelik programlama(aspect-oriented programming, AOSD) yazılımcıların imdadına yetişmektedir. Cepheye yönelik programlama, destekleyen yada yardımcı olarak görev yapan kısımların, asıl parçalardan arındırılmasıdır. AOSD, farklı işlevlere sahip kısımların, biri birinden ayrı(seperation of concerns) programlanmasına olanak tanıyarak karmaşayı giderebilir. Yazımın devamında, biri birine bağlanan parçalarından, AOSD’den ve son olarakta AOSD uygulamalarından bahsedeceğim.

Parçaların biri birine bağlı olması, gerçek hayatta karşımıza sıkça çıkan sorunlardan biridir. Çoğu zaman, yazlımın içindeki bağlılıkların(dependency) ortaya çıkmasında başlıca rol oynamaktadır. Bu duruma örnek verecek olursak, bir fonksiyonda güvenlik(security), kayıt düşme(logging) ve veri işleme(transaction processing) bağlılıkları olabilir. Bunları aynı yerde yazmak, yazılımın çok karmaşık bir yapıya bürünmesine neden olur. Bu durum, önemli bir dez avantaja, yazılım parçalarının yeniden kullanılmasını engel teşkil eder. Aşağıdaki örnekte bu duruma örnek verebileceğimiz bir fonksiyon görebilirsiniz.

public boolean saveStory(String story) throws Exception{
	if (user.isAuthenticatedUser()) {
		if (persister.save(user.id, story)) {
			logger.info("Story for the user has been added.");
			return true;
		} else{
			logger.error("Story is not saved.");
			throw new StoryNotSavedException();
		}
	} else{
		logger.error("User is not authorized.");
		throw new UnAuthorizedUserException();
	}
}

Yazılımdaki kısımların biri birine bağlı olması sorununu AOSD ile etkili bir şekilde çözebiliriz. AOSD bizim asıl fonksiyonu hayata geçirip, yardımcı fonksiyonlardan kurtulmamızı sağlayan bir yaklaşımdır. Yukarıdaki örnek üzerinden gidecek olursak, fonksiyondaki asıl amaç kullanıcı hikayesini başarılı bir şekilde kaydetmektir. Ama hikayeyi kaydederken, hikayenin kaydedildiğine dair kayıt düşme, kullanıcının bu işlem için yetkili olup olmadığına bakma ve veri işleme bizim yardımcı yada destekleyen işlevlerimizdir. AOSD, bizim asıl fonksiyona yoğunlarşıken, dışarıdan müdahale ile(by the help of pointcut) gerekli diğer işlevleri yerine getirmemizi sağlar.

Spring Framework AOSD’ye aspectj paketiyle destek oluyor. Dahası, Spring Framework kendiliğinden bazı cepheleri(aspect) sağlıyor çünkü Spring’in uyguladığı annotation’lar  cepheye yönelik programlamanın parçalarıdır denebilir. Mesela, @Autowired-Spring Bean olan bir nesnenin başka bir nesne içinden kısa yoldan çağrılmasına yarar yada @Component-Sınıfın Spring Bean olduğunu gösterir. Bu tip kullanımlar koddaki bağımlılığı azaltarak, fonksiyonların yada sınıfların daha basit olmasına yardımcı olarak, Spring’in daha basit olmasını sağlıyor.

Cepheye yönelik programlamanın uygulamasını Spring Framework’un AspectJ paketini kullanarak yapabiliriz.  Aşağıdaki kodda size yukarıda verilen fonksiyonun, cephe yardımıyla nasıl kayıt düşme bağlılığından kurtaracağımızı görebilirsiniz. Kısaca bir kaç kavramdan bahsetmek istiyorum. AOSD’de fonksiyonlara erişim noktası pointcut adıyla tanımlanmıştır. Belirli bir erişim noktasıyla, istediğiniz fonksiyona ulaşıp fonksiyonun işleyişine(@AfterReturning) göre işlem yapabiliriz. Bizim örneğimizde within ve execution erişim noktalarını kullanarak fonksiyona ulaşıp, işleyişine göre kayıt düşme işlemini gerçekleştirdik. Kullanım detayları için Spring AOSD referansına bakabilirsiniz.

package com.yusufaytas.ao;
 
import org.apache.log4j.Logger;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
 
import com.yusufaytas.example.StoryNotSavedException;
import com.yusufaytas.example.UnAuthorizedUserException;
 
@Aspect
public class LoggingAspect {
 
	Logger logger = Logger.getLogger(LoggingAspect.class.getName());
 
	@Pointcut("execution(public * saveStory(..))")
	public void saveStory(){}
 
	@Pointcut("within(com.yusufaytas.example.LoggingExample)")
	public void inLoggingExample(){}
 
	@Pointcut("saveStory()&&inLoggingExample()")
	public void saveStoryInLoggingExample(){}
 
	@AfterThrowing(pointcut="saveStoryInLoggingExample()",throwing="ex")
	public void logUnAuthorizedUserException(UnAuthorizedUserException ex){
		logger.error("User is not authorized.");
	}
 
	@AfterThrowing(pointcut = "saveStoryInLoggingExample()",throwing="ex")
	public void logStoryNotSavedException(StoryNotSavedException ex) {
		logger.error("Story is not saved.");
	}
 
	@AfterReturning(pointcut="saveStoryInLoggingExample()",returning="isSaved")
	public void logDatabaseAccess(boolean isSaved) {
		logger.info("Story for the user has been added.");
	}
 
}

Yazılımda öncelikli amacımız, yazdığımız kodun basit ve olabildiğince geliştirilebilir, sürdürülebilir yada rahat bir yapıya sahip olmasıdır. Bu durum göze alındığında, cepheye yönelik programlama, bu ihtiyaçları karşılamak için kullandığımız bir yöntemdir. Bunun haricinde daha öncede bahsettiğimiz, yazılım şablonları yada kullanılan kütüphaneler yine yukarıda saydığımız gereksinimleri karşılamaya yöneliktir. Yazıda sıkça bahsettiğim Spring Framework de sınıfların biri birine bağlanmasını önleyen bir şablonu(inversion of control) hayata geçirerek yazılımcıya basit bir ortam sunarak gereksinimlerimizi karşılamaktadır. Sonuç olarak, cepheye yönelik programlama bazı noktalarda iyi bir yöntem olsa da öncelikli tercihin yazılım şablonları yada kütüphane desteğini kullanmak olduğuna inanmaktayım. Her konuda olduğu gibi değişik yaklaşımlar arasından en iyisini seçmenin yada birden fazla yaklaşıma sahip olmanın fark yaratacağını düşünüyorum.

]]>
1
Yusuf Aytaş http://www.yusufaytas.com <![CDATA[FC Barselona Rüya Takım mı?]]> http://www.yusufaytas.com/?p=552 2011-12-01T08:45:40Z 2011-11-29T08:03:02Z Son zamanlarda medyada özelliklede goal.com’da lanse edilen bir olay var; şu anki barselona takımı bütün zamanların en iyi takımı mı. Yalnız Barselona’ya bütün zamanların en iyi takımı diyebilmek için, futbolun en eski zamanlarından şu ana kadar gelip geçen en iyi  takımlar ile karşılaştırmak gerekiyor. Barselona’yı değerlendirmeden önce biz bu takımları tanıyalım. Daha sonrasında da Barselona ile karşılaştırarak, Barselona’nın en iyi takım olup olmadığına karar verebiliriz.

Karşılaştırmamıza ilk olarak Bayern Munich ile başlıyoruz, en iyi oldukları dönem ise 1974-76. Bu dönemde Bayern, 3 defa o zamanın şampiyonlar ligi kupasını aldı. Bu dönem içinde göze çok güzel bir futbol oynamamalarına rağmen bir çok kupanın sahibi olmayı başarabilmişlerdi. Takımda öne çıkan oyuncu, Almanların gelmiş geçmiş en iyi futbolcusu diye adlandırabileceğimiz Franz Beckenbauer.

Bir sonraki takımımız ise Liverpool. 1975-84 seneleri arasında 4 kere o zamanın şampiyonlar ligi şampiyonu ve 7 defada kendi liglerinde şampiyon olmayı başarmıştı. Çok iyi pas trafiği yapmalarına ve oyun akışını iyi kontrol etmelerine rağmen, başarılarının sırrı çok iyi olan savunmalarında yatıyordu. Hatta defanslarına, istatiksel olarak baktığımızda Ingiltere futbol ligi tarihinin en iyi defansı denebilir. Liverpool bu senelerde takım halinde iyi savunma yapıyordu, öne çıkan futbolcuları yok demek yanlış olmaz.

Ezeli rakibi Real Madrid’te 1953 ile 1960 yılları arasında gerçekten de bir çok başarının altına imza atmıştı. O zamanın şampiyonlar ligi kupasını tam 5 kere kaldırmışlardı. Öyleki Real Madrid hakkındaki tek yorum, bu futbolcular insan olamazdı. Takımın şüphesiz en iyi oyuncusu olan Alfredo Di Stefano, bütün zamanların en iyi futbolcuları arasında gösterilmektedir.

Bir zamanların efsane takımı Ajax ise Barcelona’ya en büyük rakiplerden biri gibi görünüyor. Ajax 1965 ile 1973 yılları arasında her kupayı kazandı. Bu kupaların arasında 3 kere o zamanın şampiyonlar ligi kupası var. Ajax takımhalinde müthiş bir akıcılık içerisinde futbol oynuyordu. Ajax’ın bu dönemdeki futboluna total futbol denildi ve kelimenin tam anlamıyla bir ekol haline geldiler. Gerçekten de bu dönem Ajax’ın ve Hollanda futbolunun çağıydı. Ajax’ın bu dönemdeki en iyi futbolcusu Johan Cruyff’tu. Bu dönemde, Cruyff 3 defa en iyi futbolcu(FIFA Ballon d’Or) ödülünü kazanmıştır.

Şimdi sıra Barcelona’da. Barselona’yı aslında daha iyi inceleyebilmek için bir 5-10 seneye ihtiyacımız var. Rakiplerinin hepsi uzun yıllar istikrarını sürdürebilmiş. Biz de Barcelona’yı değerlendirmek için beklemeliyiz. Hali hazırda, rüya takım olma yolunda ise emin adımlarla yürüyor. Futbolcu bazında baktığımızda, kaleci ve sol bek hariç , her biri mevkilerinde en iyi futbolcular. Takdir edersiniz ki, futbolcu kalitesi takımı başarıya götürebilecek en önemli etkenlerden biri. Futbolcuların kalitesinin yanı sıra, takım olarak da iyi bir görünümdeler. Bütün bunları düşündüğümüzde, Barselonanın rüya takım olma ihtimali çok yüksek.

Şu anki barselona ile saydığımız diğer takımları karşılaştıracak olursak, Barselona’nın rakiplerinden hiçte alta kalır yanı olmadığını görebiliriz. Bence en önemli rakibi olan Ajax ile hemen hemen aynı seviyede diyebiliriz. Çünkü, Ajax’ın oynadığı total futbolu Barselona’da gözlemleyebiliyoruz. Rakip kim olursa olsun, topa sahip olum hücumu düşünen bu anlayış hem göze hitap ediyor, hem de iyi sonuçlar veriyor. Barselona istikrarı yakalarsa, rüya takım olucaktır.

]]>
0
Yusuf Aytaş http://www.yusufaytas.com <![CDATA[Jose Mourinho]]> http://www.yusufaytas.com/?p=529 2011-12-01T08:45:50Z 2011-04-22T11:50:11Z

Yazımın başında size Mourinho’yu kısaca tanıtmak istiyorum. Jose Mourinho, 26 Ocak 1963’te Portekiz’in Setubal şehrinde doğdu.  Baby Robson’ın yanında çevirmen olarak başladıktan sonra, kariyerine Barcelona’da devam etti. Burada da futbolcular ile teknik direktörler arasında çevirmenlik yaptı. Daha sonraları Louis Van Gaal’in isteği üzerine Barcelona B’nin teknik direktörlüğüne getirildi. Ayrıca bir kaç maçtada Mourinho’dan yardımcı teknik direktör olarak yararlandı. Mourinho ilk olarak Benfica’da teknik direktörlük görevine getirildi. Burada yaşadığı başarıdan sonra Porto’nun ilgilisini çekti ve Porto’nun teknik patronu oldu. 2003 yılına gelindiğinde, ligde şampiyon olup ueafa kupasınıda kaldırmıştı. Bir sonraki yıl ise şampiyonlar ligi şampiyonu olarak dikkatleri üzerine topladı. Roman Abramovich’in isteği üzerine Chealsea ile el sıkıştı. Ciddi bir transfer bütçesiyle, Didier Drogba, Michael Essien, Ricardo Carvallo gibi önde gelen isimleri kadrosuna kattı. İlk senede ligde şampiyon olup, şampiyonlar liginde de yarı finale kalma başarısını gösterdi. Chealsea’de kaldığı süre boyunca bir çok başarıyı kucakladı. 2008’de Inter’in teknik direktörü olmayı kabul etti. İlk senesinde çok büyük başarılar bekleyen taraftarlara, isteneni kısmende olsa veremedi. İkinci senesinde bir çok transfere imza attı. Ibrahimovic ve Wesley Snejder gibi dünyanın sayılı futbolcularını kadrosuna kattı. 2009-2010 sezonun neredeyse her kupayı müzesine götürme başarısını yaşadı. 2010 yılında Real Madrid  teknik direktörlüğüne getirildi.

Mourninho şimdilerde dünya tarihindeki en iyi teknik direktörleri arasında gösteriliyor. Takma adı olarakta “The Special One” özel biri adıyla anılıyor. Mourinho şimdiye kadar çıktığı maçların 68% yenme oranıyla gerçekten de çok başarılı bir teknik direktör olduğunu gözler önüne seriyor. Kariyerindeki başarılı olmasında en büyük nedenlerden birinin İspanyolca, İngilizce, İtalyanca gibi bir çok dile hakim olmasının önemli bir yer tuttuğunun altını çiziyor. Genel olarak agresif çıkışları ve yüksek egosuyla gündeme gelen Mou, oldukça hazır cevap olduğunu her fırsatta eleştirmenlere gösteriyor.

Mou’yu bu kadar tanıttıktan sonra, neden iyi olduğunu kendimce yorumlamak istiyorum. Bir takımı takım yapan oyuncularıdır. Mourinho yaptığı transferle ile kendisin futbolcuları analiz etmekteki becerisini kantılıyor. Bunlara bir çok örnek vermek mümkün, mesela Mesut Özil, Essien, Drogba, Deco ve daha niceleri. Bu oyuncular bulundukları takımlarda gerçekten iyiydiler ama onların birer yıldız olduğunun farkına varmak herkesin harcı değil. Zaten, yıldızları bir arada oynatabilmekte önemli bir yeti. Mou, ayrıca taktik ve teknik olarak gerçektende çok yetenekli. Bir çok farklı ligde bir çok takımda teknik direktörlük yapıp hepsinde de başarılı oldu. Bu takımlarda uyguladığı taktikler ise birbirinden farklıydı çünkü takım için ideali bulmayı biliyordu. Bu onun taktik bilgisini ve oyuncuları uygulanan taktiğe alıştırma becerisini gösterir. Ayrıca Mou, saha içinde de yaptığı yerinde değişikliklerle de oyun içinde maça hakim olabilmekte, müdahaleleri ile maç çevirip, maç kazanmayı en iyi şekilde başarabilmekte. Dahası Mourinho, büyük maçların adamı. Karşısındaki teknik adamı oynattığı oyun sitili ile ters köşe yapmakta üstüne yok. Bir bakarsınız savunma oyuncusu hücum hattında pres yaptığını görürsünüz yada bir hücum oyuncusu savunmaya olabildiğince yakın oynattığına şahit olursunuz. Mourinho, futbolcularını maça hazırlama ve onlara kazanma hırsını aşılamakta da mükemmel. Cristiano Ronaldo’ya bile pres yaptırabiliyorsa yada takım ruhuyla oynamayı az da olsa öğretebiliyorsa, gerçektende ikna kabiliyeti olarak ve oyuncu yönetme becerisi olarak Mou’yu yüceltmek yersiz olmasa gerek. Son olarak Mou çok istikrarlı bir teknik adam olduğunu yaptığı maçlara ve istatistiklere bakarak görebiliriz. Barcelona belkide gelmiş geçmiş en iyi futbolu oynarken, Real Madrid’te çok büyük işler yaptı;  yapmaya da devam edeceğine eminim.

Yazımın son kısmında olaylara başka bir açıdan bakalım. Ya Mourinho Barcelona’nın başında olsaydı. Eğlenceli bir takım olacağına ve  gücüne güç katacağına kesinlikle eminim. Aslında bildiğimiz gibi Barcelona’ya çok da yabancı değil Mou,  belkide bir gün Barçanın teknik direktörlüğünü yapar. Barcelona’ya katacaklarına gelirsek, bir kere çok iyi transferler yapacağı aşikar. Sonuçta Barcelona bütçesi Madrid’in kadar olmasada, çok da aşağı kalır yanı olduğunu düşünmüyorum. Barçada hali hazırda gayet işleyen bir taktik var bunu belki biraz daha geliştirilebilir ama maçların akışına çok iyi müdahalelerde bulunacaktır. Son olarak, futbolcular zaten hazır durumda ama onlara daha fazlasını verebilirsiniz, bu noktada Mou ciddi anlamda iş görecektir. Kimbilir, belki bir gün Barça’nın teknik adamı olur :D

Yazımı güncellemek istedim çünkü bir önceki paragrafta Mourinho’nun Barcelona’nın başında olması ile ilgili yazdıklarımı geri alıyorum. Bu kadar ahlaksız bir şekilde futbol oynatan bir adamı Barcelona camiasının hiçbiryerinde olmaması gerektiğini düşünüyorum. Kendi futbol ahlakıda ciddi derece sorgulanmalı. Hem verdiği demeçlerle, hem de yaptığı hareketlerle futbolu katlediyor. Evet Mourinho Barcelona’nın hiç bir yerinde olmamalı.

]]>
1
Yusuf Aytaş http://www.yusufaytas.com <![CDATA[Mediator]]> http://www.yusufaytas.com/?p=510 2011-11-29T09:23:29Z 2010-11-02T10:15:57Z Bu yazımda size Mediator adındaki nesneye dayalı yazılım şablonunu (Object-Oriented Design Pattern) anlatacağım.Mediator bize, bjeler arasında fazla bağ kurmadan (tight-coupled) işlemlerimizi yapabilmeyi sağlar. Buradaki amacımız, objelerin biribirini bilmesine gerek kalmadan, bizim yarattığımız mediator sınıfını kullanarak işlerini yapabilmesidir. Genellikle ara yüz yazılımında kullanılan bu şablona şöyle bir örnek verebiliriz.  3 tane ışığımız var ve biz bunların kontrolünü sağlayacağız. Bu ışıklardan her seferinde birini açmak istiyoruz. İşte burada bu isteğimizi mediator sınıfında uyguluyoruz. Her ışığa basıldığında diğer ışıklarla ilgili işlemleri mediator sınıfında yapıyoruz. Dolayısıyla ışıkların biribirlerini bilmesine gerek kalmıyor. Aşağıda verdiğim kod örneğinde daha iyi anlamanızı sağlayacaktır.

public interface Command{
	public void turnOn();
}
abstract public class Lamp implements Command{
	boolean isOn = false;
	Mediator mediator;
	public Lamp(Mediator mediator){
		this.mediator = mediator;
	}
	public void on(){
		this.isOn = true;
	}
	public void off(){
		this.isOn = false;
	}
	abstract public void turnOn();
}
public class GreenLamp extends Lamp{
	public GreenLamp(Mediator mediator){
		super(mediator);
	}
	public void turnOn(){
		mediator.turnOnGreenLamp();
	}
	public String toString(){
		if(this.isOn)
			return "GreenLamp is on";
		return "GreenLamp is off";
	}
}
public class RedLamp extends Lamp{
	public RedLamp(Mediator mediator){
		super(mediator);
	}
	public void turnOn(){
		mediator.turnOnRedLamp();
	}
	public String toString(){
		if(this.isOn)
			return "RedLamp is on";
		return "RedLamp is off";
	}
}
public class YellowLamp extends Lamp{
	public YellowLamp(Mediator mediator){
		super(mediator);
	}
	public void turnOn(){
		mediator.turnOnYellowLamp();
	}
	public String toString(){
		if(this.isOn)
			return "YellowLamp is on";
		return "YellowLamp is off";
	}
}
public class Mediator{
	Lamp yLamp,gLamp,rLamp;
	public void turnOnYellowLamp(){
		yLamp.on();
		gLamp.off();
		rLamp.off();
	}
	public void turnOnGreenLamp(){
		yLamp.off();
		gLamp.on();
		rLamp.off();
	}
	public void turnOnRedLamp(){
		yLamp.off();
		gLamp.off();
		rLamp.on();
	}
	public void selectYellowLamp(YellowLamp yLamp){
		this.yLamp = yLamp;
	}
	public void selectGreenLamp(GreenLamp gLamp){
		this.gLamp = gLamp;
	}
	public void selectRedLamp(RedLamp rLamp){
		this.rLamp = rLamp;
	}
}
public class MediatorDemo {
	public static void main(String []args){
		Mediator m = new Mediator();
		YellowLamp yLamp = new YellowLamp(m);
		GreenLamp gLamp = new GreenLamp(m);
		RedLamp rLamp = new RedLamp(m);
		m.selectGreenLamp(gLamp);
		m.selectRedLamp(rLamp);
		m.selectYellowLamp(yLamp);
		yLamp.turnOn();
		System.out.println(yLamp);
		System.out.println(gLamp);
		System.out.println(rLamp);
		System.out.println("***************");
		rLamp.turnOn();
		System.out.println(yLamp);
		System.out.println(gLamp);
		System.out.println(rLamp);
	}
}
]]>
1
Yusuf Aytaş http://www.yusufaytas.com <![CDATA[Strategy]]> http://www.yusufaytas.com/?p=504 2011-11-29T09:44:30Z 2010-11-01T08:21:23Z Bu yazımda size Strategy adındaki nesneye dayalı yazılım şablonunu (Object-Oriented Design Pattern) anlatacağım. Bu şablonun genel amacı yapılacak iş için alternatifler oluşturup, bu alternatifleride çalışma zamanında(runtime) seçebilme kabiliyetini sağlamaktır. Buna örnek verecek olursak, bir sıralama algoritması yazmak istiyoruz. Ama  bize verilen nesnelerin sayısı 30 dan küçük olduğunda insertion sort, büyük olduğunda da quick sort kullanacağız. İşte bu durumda bize, bu esnekliği sağlayan bir tasarım gerekli ki, stratejimizi çalışma zamanında değiştirerek sağlayabiliyoruz. Aşağıda verdiğimiz kodu anlatacak olursak. Şimdi bizim toplama, çıkarma, çarpma ve bölme işlemlerimiz var. Fakat biz hangisini kullanacağımıza çalışma zamanında karar vereceğiz, bu durumda aşağıda uyguladığımız gibi stratejimizi oluşturuyoruz. Eğer işlemi değiştirmek istiyorsak setInstruction methodunu çağırıyoruz.  Böylece sadece işlem yapan nesneyi değiştirerek, işlemimizi değiştirebiliyoruz.

public class Calculator{
	public static void main(String []args){
		Executer ex = new Executer();
		ex.setInstruction(new Addition());
		System.out.println(ex.execute(3,4));
		ex.setInstruction(new Substraction());
		System.out.println(ex.execute(3,4));
		ex.setInstruction(new Multiplication());
		System.out.println(ex.execute(3,4));
		ex.setInstruction(new Division());
		System.out.println(ex.execute(3,4));
	}
}
public class Executer {
	Instruction instruction;
	public void setInstruction(Instruction instruction){
		this.instruction = instruction;
	}
	public int execute(int x,int y){
		return instruction.execute(x,y);
	}
}
public interface Instruction{
	public int execute(int x,int y);
}
public class Addition implements Instruction{
	public int execute(int x,int y){
		return x+y;
	}
}
public class Substraction implements Instruction{
	public int execute(int x,int y){
		return x-y;
	}
}
public class Multiplication implements Instruction{
	public int execute(int x,int y){
		return x*y;
	}
}
public class Division implements Instruction{
	public int execute(int x,int y){
		return x/y;
	}
}
]]>
0
Yusuf Aytaş http://www.yusufaytas.com <![CDATA[Composite]]> http://www.yusufaytas.com/?p=494 2011-11-29T09:52:21Z 2010-10-25T21:19:12Z Bu yazımda size Composite adındaki nesneye dayalı yazılım şablonunu (Object-Oriented Design Pattern) anlatacağım. Bu şablonun genel amacı tekrarlanan(recursive) parçaları(component) genel parçalardan farksız olarak tanımlayabilmektir. Parçaları kullanan sınıfların, parçaların kendi karakterlerini bilmeden parçaları kullanabilmelerini  Composite şablonu ile sağlayabiliyoruz. Aşağıda gördüğümüz tasarımda bir DocumentElement sınıfımız var ve bu sınıftan türeyen 3 tane sınıf var. Section adlı sınıf diğer sınıflardan farklı olarak DocumentElement listesine sahip. Bu şekilde bir tasarımla her bir sınıf, DocumentElement sınıfı olarak tanımlanabilirken aynı zamanda Section sınıfının içerisinde SubSection yani alt kısımlar da oluşturulabilmektedir.

public abstract class DocumentElement{
	public void add(DocumentElement de){}
	public void remove(DocumentElement de){}
	public DocumentElement getChild(){return null;}
	public abstract void write();
}
public class Header extends DocumentElement{
	public void write(){}
}
public class Paragraph extends DocumentElement{
	public void write(){}
}
public class Section extends DocumentElement{
	public void add(DocumentElement de){}
	public void remove(DocumentElement de){}
	public DocumentElement getChild(){return null;}
	public void write(){}
}
]]>
1
Yusuf Aytaş http://www.yusufaytas.com <![CDATA[Observer]]> http://www.yusufaytas.com/?p=479 2010-11-02T10:19:06Z 2010-08-12T19:02:41Z Bu yazımda size Observer adındaki nesneye dayalı yazılım şablonunu (Object-Oriented Design Pattern) anlatacağım. Bu şablonun genel amacı bir objeyle başka objeler arasında bağ kurmaktır (One to many dependency). Yani eğer objenin birinde güncelleme olduysa diğerlerinde de bunun yansımasını sağlamaktır. Burada objeler arasında da çok fazla bağ(not tightly coupled) kurmadan işlemleri yapmaya yarar. Peki nerelerde kullanılır ? Eğer bir objede olan değişiklik diğer objelerin güncellenmesini gerektiriyorsa kullanılabilir. Yada bir obje diğer objelerin hakkında bilgi sahibi olmadan onları güncellemesi gerektiğinde yine bu şablon kullanılabilir. Size aşağıda verdiğim kod kısmında ise bu şablonun nasıl kullanıldığını göstermek istiyorum. Kodu kısaca anlatacak olursak Observer adlı bir interface kullanıyoruz. Bu interface den yararlanarak(implement) yazdığımız iki obje var. Bunlardan biri BoxChart diğeri ise PieChart. Başka bir sınıf(class) olarakta Observable ve bundan yararlanarak ürettiğimiz ConcreteObservable sınıfımızı görmekteyiz. Bunlarda sınıflar arası iletimi sağlayacak elemanlarımız. En sonunda ChartHandler adlı bir sınıfta da uyguladığımız şablonu çalıştırıyoruz. Bu şablon genel olarak kullanıcı arayüzü yapımında kullanılır. Örnek verecek olursak Java bir çok kütüphanesi bu şablonu kullanır.observer

public interface Observer{
    public void handleNotification();
}
public interface Observable{
	public void addObserver(Observer observer);
	public void removeObserver(Observer observer);
	public void notifyObservers();
}
public class BoxChart implements Observer{
	int [] data;
	public BoxChart(int [] data){
		this.data = data;
	}
	public void handleNotification(){
		System.out.println("Box Chart data is : "+data[0]);
	}
}
public class PieChart implements Observer{
	int [] data;
	public PieChart(int [] data){
		this.data = data;
	}
	public void handleNotification(){
		System.out.println("Pie Chart data is : "+data[0]);
	}
}
import java.util.ArrayList;
public class ConcreteObservable implements Observable{
	private ArrayList<Observer> list;
	public ConcreteObservable(){
		list = new ArrayList<Observer>();
	}
	public void addObserver(Observer observer){
		list.add(observer);
	}
	public void removeObserver(Observer observer){
		list.remove(observer);
	}
	public void notifyObservers(){
		for(int i=0;i<list.size();i++)
			list.get(i).handleNotification();
	}
}
public class ChartHandler{
	public static void main (String [] args){
		int [] data = {5};
		//We do not use int since we want to pass 
		//data by reference by using int array instead.
		BoxChart boxChart = new BoxChart(data);
		PieChart pieChart = new PieChart(data);
		ConcreteObservable observable = new ConcreteObservable();
		observable.addObserver(boxChart);
		observable.addObserver(pieChart);
		observable.notifyObservers();
		data[0] = 10;
		observable.notifyObservers();
	}
}
]]>
0
Yusuf Aytaş http://www.yusufaytas.com <![CDATA[Facade]]> http://www.yusufaytas.com/?p=469 2011-11-29T09:37:33Z 2010-01-11T00:05:43Z Bu yazımda size Facade adındaki nesneye dayalı yazılım şablonunu (Object-Oriented Design Pattern) anlatacağım. Bu şablon(pattern) genelde birden fazla pakete (package) aynı anda erişip bunlarla ilgili işlemleri yapabilmek adına tasarlanmış bir dizayndır. Demek istediğim birden fazla işlevi bir arada bulunduran işlemleri temelde daha kolaya indirgeyen bir yazılım unsurudur. Buna şöyle örnek verelim. Sizin computer adında bir sınıfınız(class) var. Computer çalışması için birden fazla parça kulanır. Biz sadece CPU, Ram ve harddisk kullandığını varsayalım. Şimdi bu saydığım parçaların her biri paket olarak tasarlayalım çünkü birden fazla işlevi yerine getiriyor. Mesela CPU’yu ele alalım. Bu paketin içinde birden fazla sınıf bulunur. İşte dışarıdaki sınıfları bu kargaşadan kurtarmak için bir facade sınıfı yazarız ve bu sınıf üzerinden erişimi sağlarız. Şimdi bunu bir uml şeması ile gösterelim.

facade

public class ALU{
	public void execute(){
		//execute instructions
	}
}
public class Latch{
	public void fetch(){
		//fetch intruction from memory
	}
}
public class Disk{
	public void data(){
		//gets data from disk
	}
}
public class Computer{
	ALU alu;Latch latch;Disk disk;
	public Computer(){
		alu = new ALU();
		latch = new Latch();
		disk = new Disk();
	}
	public void run(){
		alu.execute();
		latch.fetch();
		disk.data();
	}
}
public class User{
	public static void main(String [] args){
		Computer computer = new Computer();
		computer.run();
	}
}
]]>
2
Yusuf Aytaş http://www.yusufaytas.com <![CDATA[Adapter]]> http://www.yusufaytas.com/?p=461 2011-11-29T09:35:43Z 2010-01-10T11:19:29Z Bu yazımda size Adapter adında nesneye dayalı yazılım şablonunu (Object-Oriented Design Pattern) anlatacağım. Bu yazılım şablonu genellikle daha önce yazılan bir kodun başka bir programa entegre olmasını sağlamak amaçlı yapılır. Aslında adından da anlaşılacağı üzere adaptör özelliğine sahiptir. Bir program yazacağız ve bir arayüz sınıfına ihtiyacımız var.Bu kodun başka biri tarafından yazıldığını ve bu koddan yararlanabileceğimizi gördük.  Ama Şöyle bir sıkıntı oluştu, bizim yazdığınız ara yüze(interface) bulduğunuz kod uyumlu değil. Biz bu noktada hemen araya bir adaptör sınıfı yazıyoruz. Bu iki nesneyi biri birine uyumlu hale getiriyorsunuz. Aşağıda verdiğim şema, şablonu daha anlamlı hale getiricektir.adapter

public class User{
	public static void main(String [] args){
		Adapter a = new Adapter();
		a.doThis();
	}
}
public interface Target{
	public void doThis();
}
public class Adapter extends Adaptee implements Target{
	public void doThis(){
		super.doThat();
	}
}
public class Adaptee{
	public void doThat(){
		System.out.println("Hello world!");
	}
}
]]>
0
Yusuf Aytaş http://www.yusufaytas.com <![CDATA[Abstract Factory]]> http://www.yusufaytas.com/?p=454 2011-11-29T09:18:08Z 2010-01-10T01:41:33Z Bu yazımda size Abstract Factory adındaki nesneye dayalı yazılım şablonunu (Object-Oriented Design Pattern) anlatacağım. Abstract factory,  bir veya birden fazla nesnenin farklı türlerinin, ihtiyaca göre yaratılmasını amaçlayan tasarım şablonudur. Örnek vererek daha iyi açıklamak istiyorum. Bir çok farklı türde telefon mevcut ve buda hepsinin kendine has platformu olmasına neden oluyor. Dolayısıyla  telefon için bir uygulama geliştirdiğimizde, yaptığımız bir düğme(button) yada bir panel ortama göre değişmesi gerekecektir. Bu durumda düğmeleri Button, çeşitlerinide Button’dan türeyen düğmeler şeklinde tasarlarız. Aynı işlemleri paneller içinde yaparız. Oluşturacağımız AbstractFactory’den türeyen sınıfları ise platforma göre çeşitlendiririz. Eğer bizden Android buttonı isternirse, dolayısıyla Android düğmesini AndroidFactory’den yararlanarak yaratabiliriz. Aynı şekilde bunu Android Panel içinde yapabiliriz. Eğer yeni bir platform gerekirse tek yapmamız gereken onun factorisini oluşturup, ona ait button ve panelleri eklemek olacaktır. Yazdığımız diğer sınıflar aynen kalabilir.

abstract-factory

public abstract class ProductA{}
public class ProductA1 extends ProductA{}
public class ProductA2 extends ProductA{}
public abstract class ProductB{}
public class ProductB1 extends ProductB{}
public class ProductB2 extends ProductB{}
public abstract class AbstractFactory{
	public ProductA getA();
	public ProductB getB();
}
public class Factory1{
	public ProductA getA(){
		return new ProductA1();
	}
	public ProductB getB(){
		return new ProductB1();
	}
}
public class Factory2{
	public ProductA getA(){
		return new ProductA2();
	}
	public ProductB getB(){
		return new ProductB2();
	}
}
public class User{
	public static void main(String []args){
		AbstractFactory factory = new Factory1();
		factory.getA();
	}
}
]]>
0