观察者模式的学习和理解

模拟一个孩子在睡觉，父亲子在孩子醒来后给孩子喂奶

没学观察者模式之前的实现一：

//利用线程隔一段时间去看下孩子醒来了没：耗内存资源

public class BanBen1 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Child c=new Child();
  Dad d=new Dad(c);
        new Thread(c).start();
        new Thread(d).start();
  
 }

}

class Child implements Runnable{
 
 private static boolean isweak=false;

 public  static boolean isIsweak() {
  return isweak;
 }

 public  static void weakUp() {
  isweak = true;
 }

 @Override
 public void run() {
  // TODO Auto-generated method stub
  try {
   Thread.sleep(3000);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  this.weakUp();
 }
 
}

class Dad implements Runnable{

 Child c;
 
 public Dad(Child c){
  
  this.c=c;
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  while(!c.isIsweak()){
   try {
    Thread.sleep(2000);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
  
  System.out.println("喂孩子吃奶");
 }
 
}

 

没学观察者模式之前的实现二：

//孩子醒来后主动调用了父亲的喂孩子方法,功能实现了，但是不合理，而且不利于扩展

public class BanBen2 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub

  Dad2 d=new Dad2();
  new Thread(new Child2(d)).start();
 }
 
}
class Child2 implements Runnable{
 Dad2 d;
 public Child2(Dad2 d) {
  // TODO Auto-generated constructor stub
  this.d=d;
  d.setC(this);
 }
 
 private void weakUp(){
        
  d.weihaizi();
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  try {
   Thread.sleep(3000);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  weakUp();
 }
}
class Dad2{

 Child2 c;
 public Child2 getC() {
  return c;
 }
 public void setC(Child2 c) {
  this.c = c;
 }
 public void weihaizi() {
  // TODO Auto-generated method stub
  System.out.println("喂孩子孩子吃奶");
 }
 
} 

 

学习了观察者模式后的实现

//效率高，便于扩展,一个被监听者可以被不同类型的监听器监听，也可以被同一类型的多个监听器监听，

同一类型的监听器可以监听同一事件的不同的被监听者

mport java.util.ArrayList;
import java.util.List;

public class BanBen3 {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub

  WeakupListener listen1=new WeakupListener() {
   
   @Override
   public void WeakupAction(WeakupEvent cwe) {
    // TODO Auto-generated method stub
    System.out.println("listener1 excute weakupAction");
   }
  };
  
        WeakupListener listen2=new WeakupListener() {
   
   @Override
   public void WeakupAction(WeakupEvent cwe) {
    // TODO Auto-generated method stub
    System.out.println("listener2 excute weakupAction");
   }
  };
  Sleeper sleeper=new Sleeper();
  sleeper.addWeakupListener(listen1);
  sleeper.addWeakupListener(listen2);
  new Thread(sleeper).start();
 }

}
interface WeakupListener{
 void WeakupAction(WeakupEvent cwe);
}

class WeakupEvent{
 long weakTime;
}

class Sleeper implements Runnable{

 WeakupEvent event;
 List<WeakupListener> listners=new ArrayList<WeakupListener>();
 void addWeakupListener(WeakupListener wl){
  listners.add(wl);
 }
 
 void getWeakupEvent(WeakupEvent we){
  event=we;
  wekup();
 }
 
 void wekup(){
  for (WeakupListener wl : listners) {
   wl.WeakupAction(event);
  }
 }
 @Override
 public void run() {
  // TODO Auto-generated method stub
  try {
   Thread.sleep(2000);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  getWeakupEvent(event);
 }
 
 
}