------Observer patterns for Java 23 design Patterns

One Observer Mode (Observer)

The observer pattern is very well understood, similar to mail subscriptions and RSS feeds, when we look at some blogs or wikis, we often see the RSS icon, which means that when you subscribe to the article, if there are updates, you will be notified in time. In fact, a simple sentence: When an object changes, other objects dependent on the object will be notified, and with the change! Objects are a one-to-many relationship. Take a look at the diagram first:

I explain the effects of these classes: The Mysubject class is our main object, and Observer1 and Observer2 are objects that depend on Mysubject, and Mysubject and Observer1 are bound to change when Observer2 changes. The Abstractsubject class defines a list of objects that need to be monitored, which can be modified to add or remove monitored objects, and to notify objects that exist within the list when Mysubject changes. Let's look at the implementation code:

One observer interface:

 

1. Public interface Observer {
2. public void update ();
3. }

Two implementation classes:

 

1. public class Observer1 implements Observer {
3. @Override
4. public void Update () {
5. System.out.println ("Observer1 has received!");
6. }
7. }

 

1. public class Observer2 implements Observer {
3. @Override
4. public void Update () {
5. System.out.println ("Observer2 has received!");
6. }
8. }

Subject interface and implementation class:

 

1. Public interface Subject {
3. /* Increase the viewer */
4. public void Add (Observer Observer);
6. /* Delete the viewer */
7. public void del (Observer Observer);
9. /* Notify all observers */
10. public void notifyobservers ();
12. /* Self-operation */
13. public void operation ();
14. }

 

2. Public abstract class Abstractsubject implements Subject {
6. Private vector<observer> Vector = new vector<observer> ();
8. @Override
10. public void Add (Observer Observer) {
12. VECTOR.ADD (Observer);
14. }
18. @Override
20. public void del (Observer Observer) {
22. VECTOR.REMOVE (Observer);
24. }
28. @Override
30. public void Notifyobservers () {
32. enumeration<observer> Enumo = vector.elements ();
34. while (Enumo.hasmoreelements ()) {
36. Enumo.nextelement (). Update ();
38. }
40. }
42. }

 

1. public class Mysubject extends Abstractsubject {
3. @Override
4. public void operation () {
5. System.out.println ("Update self!");
6. Notifyobservers ();
7. }
9. }

Test class:

 

1. public class Observertest {
3. public static void Main (string[] args) {
4. Subject sub = new Mysubject ();
5. Sub.add (New Observer1 ());
6. Sub.add (New Observer2 ());
8. Sub.operation ();
9. }
11. }

Output:

Update self!
Observer1 has received!
Observer2 has received!

Reprint https://www.cnblogs.com/maowang1991/archive/2013/04/15/3023236.html

------Observer patterns for Java 23 design Patterns