design patterns

1

TASARIM ÖRÜNTÜLERİ(Design Patterns)

2

Christopher Alexander, mimari ürünlerin (yapıların) gerçekleştiriminde tasarımın kalitesini ölçeklendirme ve tasarım kalitesinin ürün üzerindeki etkisi üzerine çalışmış bir mimardır.

Tasarım kalitesi üzerinde yaptığı çalışmalarda tekrar tekrar karşılaşılan ve benzer çözümlere sahip olan durumlar ile karşılaşmış.

Ve tasarım örüntüsü olarak adlandırmış.

Tasarım Örüntüsü

3

Tasarım Örüntüsü Özetle tasarım örüntüsü aynı probleme ait aynıya yakın çözümdür.

Bir başka deyişle, çok rastlanan, birbirine benzer sorunları çözmek için geliştirilmiş ve işlerliği kanıtlanmış genel çözüm önerileridir.

4

GoF (Gang of Four-Dörtlü Çete) Erich Gamma, Richard Helm, Ralph Johnson ve

John Vlissides adlı 4 yazar tarafından 1995 tarihinde Tasarım Örüntüleri:Tekrar kullanılabilir Nesneye Yönelik Yazılımın Temelleri (Design Patterns: Elements of Reusable Object-Oriented Software) adıyla bir kitap yayınlanmış.

23 tane örüntü için problem, amaç ve çözüm bilgileri içeren ciddi bir katalogdur (kitaptır).

Nesneye yönelik tasarımı örüntü temellerine oturtarak yeniden gözden geçirmişlerdir.

5

Bir Örüntü için temel özellikler

Adı(Name) Niyeti(Intent) Problem Çözüm(Solution) Sonuçları(Consequencies) Gerçekleştirim (Implementation) Üreysel Yapısı(Generic Structure)

6

GoF’un temel stratejileri

23 adet örüntüde GoF’un temel önerisi şu olmuştur:“Design interfaces”

Sınıflara ait arayüzleri tasarla.“Favour aggregation over inheritance”

HAS ilişkisine kalıtımdan çok öncelik ver.“Find what varies and encapsulate it”

Değişeni bul ve onu sınıfın dışına alarak sarmala.

7

Örüntü ListesiOluşturucu(Creational)

Yapısal(Structural)

Davranışsal(Behavioral)

Abstract FactoryBuilderFactory MethodPrototypeSingleton

AdapterBridgeCompositeDecoratorFacadeProxyFlyweight

CommandInterpreterIteratorMementoObserverStateStrategyTemplate MethodChain of Responsibility MediatorVisitor

8

Design Patterns (Creational)• Oluşturucu örüntüler, yaratım (instantiation) işlemini soyutlarlar. Sistemin, nesnelerinin yaratımını(create), birleştirimlerinde (composed) ve kullanımlarından bağımsızlaşmasına yardımcı olurlar.

9

Design Patterns (Structural)• Yapısal örüntüler, sınıfların ve nesnelerin daha büyük ve karmaşık bir yapıyı oluşturmak için nasıl ele alınmaları gerektiğini gösteren yardımcılardır.

10

Design Patterns (Behavioral)• Davranışsal örüntüler, nesneler arası iletişimi gözeterek nesnelere sorumlulukların atanması ve nesnelerin birbirleri ile olan ilişkileri ile ilgilenir.

11

Oluşturucu Örüntüler

Factory Method

Abstract Factory

Singleton

12

Factory Method

Hangi sınıftan ve hangi nesnenin yaratılacağına yaratıcı alt sınıflar karar verdiği örüntüdür.

Nesnenin yaratılması işlemi, istemci sınıfı tarafından gözükmez.

İstemci, istediği nesnenin sadece temel türünü bilir.

13

Factory Method

14

Factory Method Product(Pizza): Factory Method’un yaratacağı

nesne tipi için arayüzü oluşturur. ConcreteProduct(CheesePizza,VeggiePizza,):

Somut ürünlerdir. Factory bu ürünlerden birisini oluşturur.

Creator(): ConcreteCreator için soyut arayüz tanımını sağlar.

ConcreteCreator(SimplePizzaFactory): Somut ürünleri oluşturup döndüren somut sınıftır.

15

Factory MethodProduct

ConcreteProducts

ConcreteCreator

16

Factory Method

17

Factory Method

18

Abstract Factory

Bir grup ilgili nesneden oluşan, duruma göre bir tanesinin/grubunun yaratımı için kullanılan örüntüdür.

Factory’lerin de soyutlanmış olduğu bir yapıdadır.

Ürünlerin(Product) birbirleri ile olan ilişkisini ve bunların oluşturulmasını alt sınıflara bırakır.

Uygun ürün veya ürün gruplarının üretilmesi soyutlanır.

19

Abstract Factory

20

Abstract Factory

21

Abstract Factorypublic abstract class GUIFactory { public static GUIFactory getFactory() { int sys = readFromConfigFile("OS_TYPE"); if (sys == 0) { return(new WinFactory()); } else { return(new OSXFactory()); } } public abstract Button createButton(); }

class WinFactory extends GUIFactory { public Button createButton() { return(new WinButton()); } }

class OSXFactory extends GUIFactory { public Button createButton() { return(new OSXButton()); } }

22

Abstract Factorypublic abstract class Button { private String caption; public abstract void paint(); public String getCaption(){ return caption; } public void setCaption(String caption){ this.caption = caption; } }

class WinButton extends Button { public void paint() { System.out.println("I'm a WinButton: " + getCaption()); } }

class OSXButton extends Button { public void paint() { System.out.println("I'm a OSXButton : " + getCaption()); } }

23

Abstract Factory

public class Application { public static void main(String[] args) { GUIFactory aFactory = GUIFactory.getFactory(); Button aButton = aFactory.createButton(); aButton.setCaption("Play"); aButton.paint(); } }

//output is //I'm a WinButton: Play //or //I'm a OSXButton: Play

24

Singleton

Tek nesnesi olan bir sınıf yaratmak için bu örüntü kullanılır.

Birden fazla nesneye gerek olmayabilir yada ilave nesneler bellek tüketimini attırabilir.

Bir sınıfa ait bir nesne tanımlanır ve istemcilere bu nesne kullandırılır.

Bu nesneye olan erişim kontrol altına alınır.

25

Singleton

26

Singleton

Sınıfa ait constructor, private yapılır. Nesnenin dışarıdan oluşturulması engellenir.

Nesneye static bir fonksiyon üzerinden ulaşılır.

27

Singleton

// Singleton sınıfı bir nesne gerçekleştirimine izin veren sınıf.public class Singleton {

// Private referansı ile tek bir nesneprivate static Singleton tekNesne = null;

public static Singleton getNesne() {if( tekNesne == null )

tekNesne = new Singleton();return tekNesne;

}//Singleton yapılandırıcısı-constructorprivate Singleton() {}

}

28

Yapısal Örüntüler

Adapter

Composite

Facade

Proxy

29

Adaptör

Amaç, varolan bir sınıf arayüzünü istemcinin beklediği arayüze çevirmektir.

Adaptör ile farklı arayüze sahip olduğu için birlikte çalışamayacak gibi görünen sınıfların birlikte çalışması sağlanırken, sınıfların var olan tanımları üzerinde bir değişiklik gerçekleşmez.

Varolan sınıf(Adaptee) bir Nesne veya Sınıf adaptörü ile Adaptör’ e bağlanır.

İstemci sınıf, Target üzerinden var olan sınıfı kullanır.

30

Adaptör

Adaptör ile, Adaptee sınıfına ait nesne üzerinden var olan fonksiyonlar kullanılır.

31

Adaptör

Target: İstemci tarafından görülen ve kullanılan arayüzü tanımlar.

Adaptee: Var olan sınıftır. Adapter: Target ile Adaptee arasında

ortak bir anlaşma sağlar. Adaptee sınıfına ait değişiklikler, istemciler

tarafından görülmez ve soyutlanır.

32

Composite Nesneler arası parça-bütün ilişkisini tutar. Genellikle resim/grafik düzenleyici

uygulamalarında kullanılır. Bir grup nesneyi ağaç yapısında bir arada

tutmayı sağlar.

33

Composite

34

Composite

35

Composite

Component (Graphic): Sınıflara ait ortak davranışı belirtir.

Leaf (Rectangle, Line, Text, etc.): Uç nesneleri gösterir. Çocukları yoktur.

Composite (Picture): İçerisinde çocuk nesneleri tutar.

Eğer nesne bir uç(Leaf) nesne ise istek kendisi tarafından gerçekleştirilir.

Eğer nesne composite ise, istekleri çocuk nesnelere iletir.

36

Compositepublic interface AbstractFile {

public void ls();}

public class Directory implements AbstractFile {private String name;private ArrayList<AbstractFile> files = new

ArrayList<AbstractFile>();public Directory (String name) {

this.name = name;}public void add(AbstractFile f) {

files.add(f);}public void ls() {

System.out.println(name);

for (AbstractFile file : files) {file.ls();

}}

}

class File implements AbstractFile {private String name;public File(String name) {

this.name = name;}public void ls() {

System.out.println(name);}

}

37

Composite

public class CompositeDemo {public static void main(String[] args) {Directory dirOne = new Directory("dir111");Directory dirTwo = new Directory("dir222);File a = new File("a");File b = new File("b");File c = new File("c");File d = new File("d");dirOne.add(a);dirOne.add(dirTwo);dirOne.add(b);dirTwo.add(c);dirTwo.add(d);dirOne.ls();}

}

38

Facade Altsistem 1,Altsistem 2‘nin

bazı bileşenlerini (sınıflarını), işlemlerini gerçekleştirmek için kullanmak zorunda olsun.

Direk kullanmak kötüdür? Altsistem1’den AltSistem2’nin

tüm karmaşıklığını ve yapısını bilmesi beklenemez.

AltSistem2’deki bir çok kullanılmayacak yetenek Altsistem1 için erişime açıktır.

Altsistem 2

AltSistem 1

39

Facade

AltSistem 2 üzerinden analitik çalışma ile sisteme nasıl erişileceği belirlenir ve AltSistem 2 için bir interface tanımlanır

Altsistem1 için kullanmayacağı hiç bir yetenek erişime açılmaz.

AltSistem1

AltSistem2

40

Facade

Altsisteme yapılacak tüm erişimler kontrol altındadır.

Altsistemde yapılacak bir değişiklik tamamen kullanıcı sistemden soyutlanmıştır.

Bunlara rağmen facade arayüzü sadece altsistemin yeteneklerinin bir kısmını içereceği için bazı yetenekler gözden kaçabilir.

Sınıflar bir başka sınıf tarafından sarmalanır ve sınıflara doğrudan erişim izni verilmez (direk müdahaleler hariç)

41

Facade

Örnek: Bir sistemde A, B ve C sınıfları içinde var olan sırası ile xx(), yy() ve zz() iletileri bir başka sistem tarafından yeniden kullanılmak isteniyor.

Alt sistemi, başka bir sistem tarafından bir arayüz ile kullandırmalıyız.

42

Facade

class A { public A() {…} public xx(); //diğer iletiler }

class B { public B() {…} public yy(); //diğer iletiler }

class C { public C() {…} public zz(); //diğer iletiler }

class Facade { A aref; B bref; C cref; public aXX() {a.xx();}; public bYY() {b.yy();}; public cZZ() {c.zz();};}

class Client { Facade f = new Facade(); f.aXX(); f. bYY(); f.cZZ();}

Alt Sistem

İstemci

43

Proxy

Bir nesneye olan erişimi kontrol etmek için bir vekil sağlamak bu örüntünün hedefidir

Arayüzü gerçekleştirimden ayırır. Performans, platform veya erişim kısıtlarından

dolayı gerçek hedef nesnenin ele alınamayacağı durumlarda kullanılır.

Word gibi düzenleyicilerde, resim gibi görsel nesnelerin yüklenmesinde kullanılır.

44

Proxy İstemci Nesne

EsasNesne Proxy

+İstem()

+İstem() +İstem()

esasNesne

esasNesne.İstem()

45

Proxy Proxy:

Esas nesneye bir proxy erişimi sağlayan bir referans içerir Esas nesne ile aynı arayüzü kullanır. Böylece esas nesne

erişimlerinde birebir kullanılır Esas nesneye erişimi kontrol eder. Yaratılması ve yok

edilmesinden de sorumlu olabilir. Nesne:

Esas nesne ve proxy nesnesi için ortak bir arayüzdür. EsasNesne:

Proxy nesnesinin temsil ettiği, istenilen işlemi gerçekleştiren nesnedir.

46

Proxy// “Nesne“abstract class Nesne {

// İletiler abstract public void İstem();

}

// “EsasNesne“class EsasNesne : Nesne {

// İletiler public void İstem() { Console.WriteLine(

“EsasNesne.İstem()” + “Çağrıldı");

}}

// "Proxy“class Proxy : Nesne {

// Alanlar EsasNesne esasNesne;

// İletiler public void İstem() {

if( esasNesne == null ) esasNesne = new EsasNesne();

// Burada denetim Proxy de...esasNesne.İstem();

}}

public class İstemci { public static void Main( string[] args ) { Proxy p = new Proxy(); p.İstem(); }

}

47

Davranışsal Örüntüler

Memento

Observer

State

StratejiVisitorTemplate

48

Memento

Bir nesnenin değişik durumlarının tutulması gerektiğinde bu örüntü kullanılır.

Nesnenin eski durumları veya kopyaları tutulur.

Gerektiğinde nesne eski durumlarından birine geri dönebilir.

Genellikle editor lerde geri/ileri (undo/redo) alma özelliği için kullanılır.

49

Memento

50

Memento

Memento: Originator nesnesinin herhangi bir durumu(kopyalarını)

tutar. Originator dışından bu nesneye erişim yapılamaz.

Originator: Kopyası tutulacak nesnedir. Değişik durumlarına geçmek için Memento’ yu kullanır.

CareTaker: Nesnenin durumları olan Memento nesnelerini tutar.

51

Mementopublic class Originator {

private String state;public void set(String state) {

System.out.println("Originator: Setting state to " + state);this.state = state;

}public Object createMemento() {

System.out.println("Originator: creating

Memento.");return new Memento(state);

}public void restoreFromMemento(Memento m) {

state = m.getSavedState();System.out.println("Originator:

State after restoring from Memento: " + state);}

}

public class Memento {private String state;public Memento(String stateToSave) {

state = stateToSave;}public String getSavedState() {

return state;}

}public class Caretaker {

private List<Object> savedStates = new ArrayList<Object>();

public void addMemento(Object m) {savedStates.add(m);

}public Object getMemento(int index) {

return savedStates.get(index);}

}

52

Memento

public class MementoExample {public static void main(String[] args) {

Caretaker caretaker = new Caretaker();Originator originator = new Originator();originator.set("State1");caretaker.addMemento(originator.createMemento());originator.set("State2");caretaker.addMemento(originator.createMemento());originator.set("State3");caretaker.addMemento(originator.createMemento());originator.set("State4");

originator.restoreFromMemento(caretaker.getMemento(1));}

}

53

Observer Bir nesnenin durumunun gözlemlenmesi ve bu nesnedeki

değişikliğin, nesne ile ilgilenen diğer nesnelere iletilmesini sağlayan tasarım örüntüsüdür.

Bu amaçla değişiklikleri takip etmek isteyen nesneler bir şekilde değişikliğe uğrayacak nesneye kendilerini kayıt ettirirler veya o nesne hakkındaki değişikliklerden haberdar olurlar.

NE ZAMAN KULLANILIR? Bir nesnedeki değişiklik başka nesnelerde otomatik olarak

değişiklik gerektiriyorsa,

Bir nesnenin başka nesneleri kim olduklarına bakmaksızın bir durumdan haberdar etmeleri gerektiğinde.

54

Observer

55

Observer Buradaki anahtar nesneler SUBJECT ve OBSERVER’dır.

Bir subject’e bağlı birçok observer olabilir.

Subject nesnesinin durumunda bir değişiklik olduğunda bütün observer nesneleri bundan haberdar olur.

Bunun sonucunda da bütün observer nesneleri durumlarını subject nesnesinin durumuyla senkronize etmek isterler. Bu tür bir etkileşim ayrıca PUBLISH-SUBSCRIBE olarak da bilinir.

Subject bildirilerin yayınlayıcısıdır. Bu bildirileri, kendisinin izleyicilerinin kimler olduğunu umursamaksızın yayınlar.

Herhangi bir sayıdaki izleyici bu bildirileri almayı kabul etmiş sayılır.

56

Observer Subject:

Değişikliği izlenen nesneye ait arayüzü tanımlar. Observer nesnelerini ekleyebilmek ve ayırabilmek için bir arayüz sağlamalıdır.

Observer: Subject’ teki değişikliklerden haberdar olabilmek için tanımlı bir arayüz kullanır.

Concrete Subject: ConcreteObserver nesnelerince durumu takip edilir. İzlenen nesnedir. Durum değişikliklerinde bu değişimi bildirmekle yükümlüdür.

Concrete Observer: Gözlemleyen nesnedir. Subject ile tutarlı kalması için gereken güncellemeleri bilir.

57

Observer

Kamil Koç otobüs firmasıdır. Firmamız için bilet kesen iki tane yazıhanemiz olsun. Balgat yazıhanesi ve Kızılay yazıhanesi. Bu iki yazıhane müşteriler için sefer bilgilerini tutsun. Yeni bir sefer eklendiği zaman bizim seyahat yazıhanelerimizin bu sefer bilgilerini de ekleyeceklerini garanti etmeliyiz.

Sistem, Kamil Koç tarafından bir sefer eklendiğinde bunu otomatik olarak yazıhanelere bildirmelidir.

58

Observer

59

Observerpublic abstract class Subject {

private ArrayList observers = new ArrayList();public void AddObservers(Observer observer) {

observers.Add(observer);}public void RemoveObserver(Observer observer) {

observers.Remove(observer);}public void Notify() {

foreach(Observer observer in observers) {observer.UpdateKamilKocsRout(this);

}}

}

public KamilKoc extends Subject { public void AddNewRout() {

// add new routNotify();

}}

60

ObserverConcreteObservers

public class KızılayYazıhanesi implements Observer

{public void UpdateKamilKocsRout(Object subject){

if(subject is KamilKoc){

AddRoutforKamilKoc((KamilKoc)subject);

}}private void AddRoutforKamilKoc(KamilKoc traveller){

Console.WriteLine("new rout No. " + traveller.TravelRout + " Veri

Tabanina Eklendi");}

}

ConcreteObservers

public class BalgatYazıhanesi implements Observer

{public void UpdateKamilKocsRout(Object subject){

if( subject is KamilKoc){

AddRoutforKamilKoc((KamilKoc)subject);

}}private void AddRoutforKamilKoc(KamilKoc traveller){

Console.WriteLine("new rout No. " + traveller.TravelRout + " Veri

Tabanina Eklendi");}

}

61

Observer

class Client{

static void Main(string[] args){

KamilKoc KK = new KamilKoc("EC 2012", 2230);KizilayYazanesi Kizilay = new KizilayYazıhanesi();BalgatYazanesi Balgat = new BalgatYazıhanesi();KK.AddObservers(Kizilay);KK.AddObservers(Balgat);KK.AddNewRout();

}}

62

State

Nesneye ait davranışların değişik durumlar için ayrı ayrı ele alınmasını sağlar.

Nesne için durumlar tanımlanır. Nesne aynı anda bir tane durumda bulunur. Nesneye gelen istek, o anki durumunun

fonksiyonuna gönderilir. Nesne bir durumdan başka bir duruma geçebilir. (State Machines) Durum makinalarını modeller.

63

State

64

State

Context: İstemcilere ait arayüzü tanımlar. State’ e ait bir referans tutar ve istekleri bu State üzerinden çağırır.

State: Durumlara ait ortak bir arayüz tanımlar. Somut Durumlar(ConcreteState) bu arayüzün fonksiyonlarını

gerçekleştirmek zorundadır.

ConcreteState: Durumun davranışını yansıtır. State’ deki fonksiyonları duruma göre ele alır. Gerektiğinde Context’ in (Durumunu) State ini değiştirebilir.

65

State

waterStateOfWater

WaterVapor LiquidWater Ice

increaseTemp()decreaseTemp()

state variable

ClientincreaseTemp()




setState(s:StateOfWater)


66

Strateji

İstemciler tarafından görünmeyen nesneye ait değişik algoritmaların ele alınmasını sağlar.

Değişikliklerin olabileceği noktalar tespit edilir ve sınıfın dışına taşınır.

Bu sınıf üzerinden gelen istek ilgili davranışa yönlendirilir.

67

Strateji

Client

ConcreteStrategyA

AlgorithmInterface()

ConcreteStrategyB


Context

ContextInteface

Strategy


Strategy

68

Stratejiclass StrategyInterface {

public: virtual void execute() = 0; };

class ConcreteStrategyA: public StrategyInterface { public: virtual void execute() {

cout << "Called ConcreteStrategyA execute method" << endl; }

};

class ConcreteStrategyB: public StrategyInterface { public: virtual void execute() {

cout << "Called ConcreteStrategyB execute method" << endl; }

};

69

Stratejiclass Context {

private: StrategyInterface *_strategy; public: Context(StrategyInterface strategy):_strategy(strategy) { } void set_strategy(StrategyInterface *strategy) {

_strategy = strategy; } void execute() {

_strategy->execute(); }

};

int main(int argc, char *argv[]) {ConcreteStrategyA concreteStrategyA;

ConcreteStrategyB concreteStrategyB;Context context(&concreteStrategyA);context.execute();

}

70

Visitor Üzerinde çalıştığı elemanların sınıflarını(class)

değiştirmeden yeni bir işlem tanımlamamıza izin verir.

Var olan yapıyı fazla bozmadan yeni özellikler kazandırır.

Sisteme yeni özelliklerin eklenmesinin ve çıkarılmasının sistemi fazla bozmasını engellemek istemiyorsak, yararlıdır.

Kodda if-else yapılarını daha iyi bir yöntemle ele alır.

71

Visitor

72

Visitor Bu hiyerarşiye modemlerin Unix ile çalışmasını sağlayan bir

özellik olan ConfigureForUnix() metodunu eklemek isteyelim.

Yeni bir işlemin ilave edilmesi bütün node sınıflarının değişmesini gerektirir.

Her bir sınıfta, sayısına bağlı olarak bu kadar çeşitli işlemlerin olması karışıklığa neden olur.

İyi bir çözüm, istenilen işlemi Visitor adı verilen ayrı bir sınıfta ele almaktır.

73

Visitor

Visitor Pattern var olan hiyerarşiyi değiştirmeden yeni metot ekleme olanağı tanıyarak sorunu çözecektir.

74

Template Method Template metodu programın genel algoritma

yapısını tanımlar. Alt sınıflarda farklı algoritmalar ile aynı işi

yapan metodlar template metodu altında genel sıra bozulmadan çağrılırlar.

Genel sıra, üst sınıfta (SuperClass) tanımlanır.

Genel sırada çağrılan metodlar ise ilgili alt sınıfa göre gerçekleştirilir.

75

Template Method

76

Template Method/** * An abstract class that is common to several games in which players play against the others, but only one is * playing at a given time. */abstract class Game {

private int playersCount;

abstract void initializeGame(); abstract void makePlay(int player); abstract boolean endOfGame(); abstract void printWinner();

/* A template method : Bu sınıfı overrride eden her sınıf bu sıraya uymak zorudadır. */ final void playOneGame( int playersCount ) { this.playersCount = playersCount; initializeGame(); int j = 0; while (!endOfGame()) { makePlay(j); j = (j + 1) % playersCount; } printWinner(); }

}

77

Template Methodclass Chess extends Game {

/* Implementation of necessary concrete methods */

public void initializeGame() { // ... }

public void makePlay(int player) { // ... }

public boolean endOfGame() { // ... }

public void printWinner() { // ... }

/* Specific declarations for the chess game. */

// ...}

COMPILED FROM

HACETTEPE UNIVERSITY COMPUTER ENGINEERING

DEPARTMENT’s Design Patterns Lecture (of Ebru SEZER)

Notes

78