java观察者代码 java观察者模式与消息队列

java中的观察者模式，中间的几行代码怎么理解呀？？？这种风格的代码很少见呀？？求大神分析下

第一个

专注于为中小企业提供成都网站制作、网站建设服务,电脑端+手机端+微信端的三站合一,更高效的管理,为中小企业海南州免费做网站提供优质的服务。我们立足成都，凝聚了一批互联网行业人才，有力地推动了超过千家企业的稳健成长，帮助中小企业通过网站建设实现规模扩充和转变。

public interface RandomNumberListener {//接口

public void numberChanged(double d);

}

第二个

public class Consol implements RandomNumberListener{

@Override

public void numberChanged(double d) {

System.out.println(d);

}

}

第三个

public class SwingWindow

extends JFrame

implements RandomNumberListener{//观察者

private JLabel label = new JLabel();

public SwingWindow(){

this.getContentPane().add( label);

this.setSize(300,200);

this.setVisible(true);

}

@Override

public void numberChanged(double d) {

label.setText(String.valueOf(d));

}

}

第四个

public class RandomNumber {//业务

private double r;

private ListRandomNumberListener listeners = new ArrayListRandomNumberListener();

//添加所有观察者

public void addRandomNumberListener(RandomNumberListener lis){

listeners.add(lis);

}

public void random(){

r = Math.random();

//数据发生改变，通知所有的观察者

for (RandomNumberListener lis : listeners) {

lis.numberChanged(r);

}

}

}

第五个

public class Test {

public static void main(String[] args) throws InterruptedException{

RandomNumber rn = new RandomNumber();

SwingWindow sw = new SwingWindow();

Consol c = new Consol();

rn.addRandomNumberListener(sw);

rn.addRandomNumberListener(c);

while(true){

rn.random();

Thread.sleep(new Random().nextInt(3000)+1000L);

}

}

}

JAVA观察者模式(observer pattern)

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Random;

import javax.swing.event.ChangeEvent;

import javax.swing.event.ChangeListener;

public class StockLists implements Runnable

{

private HashMapString, Stock                     hmStocks = new HashMapString, Stock();

private HashMapString, ArrayListChangeListener hmCL     = new HashMapString, ArrayListChangeListener();

public StockLists()

{

init(100);

new Thread(this).start();

}

public void run()

{

Random rand = new Random();

while (true)

{

try

{

Thread.sleep(100);

Stock s = randStock();

s.price = rand.nextFloat();

ArrayListChangeListener alCL = hmCL.get(s.symbol);

if (alCL == null)

{

continue;

}

for (ChangeListener cl : alCL)

{

cl.stateChanged(new ChangeEvent(s));

}

}

catch (InterruptedException e)

{

e.printStackTrace();

}

}

}

private Stock randStock()

{

Random rand = new Random();

int idx = rand.nextInt(hmStocks.size());

String sym = (String) hmStocks.keySet().toArray()[idx];

Stock s = hmStocks.get(sym);

return s;

}

public boolean addChangeListener(ChangeListener cl, String sym)

{

ArrayListChangeListener al = hmCL.get(sym);

if (al == null)

{

al = new ArrayListChangeListener();

hmCL.put(sym, al);

}

return al.add(cl);

}

private void init(int count)

{

Random rand = new Random();

for (int i = 0; i  count; i++)

{

String sym = randSym(rand);

float p = rand.nextFloat();

Stock s = new Stock(sym, p);

hmStocks.put(sym, s);

}

}

private String randSym(Random rand)

{

char[] ca = new char[3];

for (int i = 0; i  ca.length; i++)

{

ca[i] = (char) ('A' + rand.nextInt(26));

}

return new String(ca);

}

public static void main(String[] args)

{

StockLists sl = new StockLists();

sl.addChangeListener(new Investor("111"), sl.randStock().symbol);

sl.addChangeListener(new Investor("222"), sl.randStock().symbol);

sl.addChangeListener(new Investor("333"), sl.randStock().symbol);

sl.addChangeListener(new Investor("444"), sl.randStock().symbol);

sl.addChangeListener(new Investor("555"), sl.randStock().symbol);

sl.addChangeListener(new Investor("666"), sl.randStock().symbol);

sl.addChangeListener(new Investor("777"), sl.randStock().symbol);

sl.addChangeListener(new Investor("888"), sl.randStock().symbol);

sl.addChangeListener(new Investor("999"), sl.randStock().symbol);

sl.addChangeListener(new Investor("000"), sl.randStock().symbol);

}

}

class Stock

{

public String symbol = null;

public float  price  = 0.0f;

public Stock(String sym, float p)

{

symbol = sym;

price = p;

}

public String toString()

{

return symbol + ":" + price;

}

}

class Investor implements ChangeListener

{

public String name = "";

public Investor(String name)

{

this.name = name;

}

@Override

public void stateChanged(ChangeEvent e)

{

Stock s = (Stock) e.getSource();

System.out.println("Hello," + name + " : STOCK CHANGED: " + s);

}

}

求 JAVA 异步观察者模式 的源代码（完整的），不要同步的，好的给加分

package TestObserver;

import java.util.Iterator;

import java.util.Vector;

/**

*

* @author Seastar

*/

interface Observed {

public void addObserver(Observer o);

public void removeObserver(Observer o);

public void update();

}

interface Observer {

public void takeAction();

}

class Invoker {

private Observer o;

Handler handler;

public Invoker(Observer o) {

new Handler();

this.o = o;

}

private class Handler extends Thread {

public Handler() {

handler = this;

}

@Override

public void run() {

o.takeAction();

}

}

public boolean TestSameObserver(Observer o) {

return o == this.o;

}

public void invoke() {

handler.start();

}

}

class ObservedObject implements Observed {

private VectorInvoker observerList = new VectorInvoker();

public void addObserver(Observer o) {

observerList.add(new Invoker(o));

}

public void removeObserver(Observer o) {

IteratorInvoker it = observerList.iterator();

while (it.hasNext()) {

Invoker i = it.next();

if (i.TestSameObserver(o)) {

observerList.remove(i);

break;

}

}

}

public void update() {

for (Invoker i : observerList) {

i.invoke();

}

}

}

class ObserverA implements Observer {

public void takeAction() {

System.out.println("I am Observer A ,state changed ,so i have to do something");

}

}

class ObserverB implements Observer {

public void takeAction() {

System.out.println("I am Observer B ,i was told to do something");

}

}

class ObserverC implements Observer {

public void takeAction() {

System.out.println("I am Observer C ,I just look ,and do nothing");

}

}

public class Main {

/**

* @param args the command line arguments

*/

public static void main(String[] args) {

ObserverA a = new ObserverA();

ObserverB b = new ObserverB();

ObserverC c = new ObserverC();

ObservedObject oo = new ObservedObject();

oo.addObserver(a);

oo.addObserver(b);

oo.addObserver(c);

for (int i = 0; i 5; ++i) {

oo.addObserver(new Observer() {

public void takeAction() {

System.out.println("我是山寨观察者"+"，谁敢拦我");

}

});

}

//sometime oo changed ,so it calls update and informs all observer

oo.update();

}

}

观察者模式的精髓在于注册一个观察者观测可能随时变化的对象，对象变化时就会自动通知观察者，

这样在被观测对象影响范围广，可能引起多个类的行为改变时很好用，因为无需修改被观测对象的代码就可以增加被观测对象影响的类，这样的设计模式使得代码易于管理和维护，并且减少了出错几率

至于异步机制实际是个噱头，可以有观测对象来实现异步，也可以有观察者自身实现，这个程序实际是观测对象实现了异步机制，方法是在观察者类外包装了一层invoker类