Design Patterns-Model-View-Controller-Observer Pattern

1.1 OBSERVER TASARIM DESENİ
1.1.1 DESEN KATEGORİSİ
Davranışsal (behavioural) tasarım deseni kategorisinde yer almaktadır.
1.1.2 AMAÇ
1 - N ilişkisi olan nesnelerden, birinde durum değişikliği meydana geldiğinde, o nesneye bağımlı olan diğer nesnelerin haberdar edilmesi amacıyla kullanılır.
1.1.3 UYGULANABİLİRLİK
“Observer” tasarım desenin aşağıdaki durumlarda kullanılması uygundur.
· Bir soyutlamada birinin diğerine bağımlı olan bir yönü varsa. (Bu iki tarafı – bir taraf ve ona bağımlı olan diğer tarafı- farklı nesnelerde enkapsüle etmek onların bağımsız olarak tekrar kullanım şansını arttıracaktır.)
· “Subject” nesnesinin kaç tane “observer” nesnesine sahip olduğunu bilmediği durumlarda.
· “Subject” nesnesinin “observer” nesnelerinin kim olduğunu bilmeden onları bilgilendirmesi gerektiği durumlarda.
1.1.4 GENEL DESEN YAPISI
“Observer” arayüzündeki “notify()” metodu “ConcereteObserverA” ve “ConcereteObserverB” sınıflarımda farklı şekillerde gerçekleştirilmektedir. “Subject” arayüzünde ise “registerObserver(observer)”, “unregisterObserver(observer)” ve “notifyObservers()” metodları tanımlanmıştır.

OBSERVER PATTERN

In our new, more sophisticated windowing world, we often would
like to display data in more than one form at the same time and have all of the
displays reflect any changes in that data. For example, you might represent
stock price changes both as a graph and as a table or list box. Each time the
price changes, we’d expect both representations to change at once without
any action on our part.
We expect this sort of behavior because there are any number of
Windows applications, like Excel, where we see that behavior. Now there is
nothing inherent in Windows to allow this activity and, as you may know,
programming directly in Windows in C or C++ is pretty complicated. In Java,
however, we can easily make use of the Observer Design Pattern to cause our
program to behave in this way.
The Observer pattern assumes that the object containing the data is
separate from the objects that display the data, and that these display objects
observe changes in that data. This is simple to illustrate as we see below.

When we implement the Observer pattern, we usually refer to the
data as the Subject and each of the displays as Observers. Each of these
observers registers its interest in the data by calling a public method in the
Subject. Then, each observer has a known interface that the subject calls
when the data change. We could define these interfaces as follows:

abstract interface Observer {
//notify the Observers that a change has taken place
public void sendNotify(String s);
}
//=============================================
abstract interface Subject {
//tell the Subject you are interested in changes
public void registerInterest(Observer obs);
}
The advantage of defining these abstract interfaces is that you can
write any sort of class objects you want as long as they implement these
interfaces, and that you can declare these objects to be of type Subject and
Observer no matter what else they do.