java观察者
A. 求 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 Vector<Invoker> observerList = new Vector<Invoker>();
public void addObserver(Observer o) {
observerList.add(new Invoker(o));
}
public void removeObserver(Observer o) {
Iterator<Invoker> 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类
B. Java的回调函数和观察者模式的区别
java的回调 叫listener 模式。
无论是listener模式，还是C++里面的callback模式，本质是一样的
他们都是观察者模式的具体实现。
观察者模式是设计模式中定义的一种思想，而具体到不同的语言环境，使用不同的语法表现出来就会有java的listener objc的 delegate，或者C++的 callback。
C. java绘图ImageObserver observer，观察者是什么意思
public interface ImageObserver
用于在构造 Image 时，接收有关 Image 信息通知的异步更新接口。
字段摘要
static int ABORT
imageUpdate 的 infoflags 参数中的此标志指示被异步跟踪的图像在生成完成前即已中止。
static int ALLBITS
imageUpdate 的 infoflags 参数中的此标志指示现在已完成了一幅以前绘制的静态图像，并且可以其最终形式再次绘制它。
static int ERROR
imageUpdate 的 infoflags 参数中的此标志指示被异步跟踪的图像遇到了错误。
static int FRAMEBITS
imageUpdate 的 infoflags 参数中的此标志指示多帧图像（以前绘制的）的另一个完整帧现在可以再次绘制。
static int HEIGHT
imageUpdate 的 infoflags 参数中的此标志指示基本图像的高度现在可用，并且可从 height 参数中获取此高度到 imageUpdate 回调方法。
static int PROPERTIES
imageUpdate 的 infoflags 参数中的此标志指示该图像的属性现在可用。
static int SOMEBITS
imageUpdate 的 infoflags 参数中的此标志指示已提供了绘制图像缩放变体所需的更多像素。
static int WIDTH
imageUpdate 的 infoflags 参数中的此标志指示基本图像的宽度现在可用，并且可从 width 参数中获取此宽度到 imageUpdate 回调方法。
D. JAVA观察者模式(observer pattern)
importjava.util.ArrayList;
importjava.util.HashMap;
importjava.util.Random;
importjavax.swing.event.ChangeEvent;
importjavax.swing.event.ChangeListener;
{
privateHashMap<String,Stock>hmStocks=newHashMap<String,Stock>();
privateHashMap<String,ArrayList<ChangeListener>>hmCL=newHashMap<String,ArrayList<ChangeListener>>();
publicStockLists()
{
init(100);
newThread(this).start();
}
publicvoidrun()
{
Randomrand=newRandom();
while(true)
{
try
{
Thread.sleep(100);
Stocks=randStock();
s.price=rand.nextFloat();
ArrayList<ChangeListener>alCL=hmCL.get(s.symbol);
if(alCL==null)
{
continue;
}
for(ChangeListenercl:alCL)
{
cl.stateChanged(newChangeEvent(s));
}
}
catch(InterruptedExceptione)
{
e.printStackTrace();
}
}
}
privateStockrandStock()
{
Randomrand=newRandom();
intidx=rand.nextInt(hmStocks.size());
Stringsym=(String)hmStocks.keySet().toArray()[idx];
Stocks=hmStocks.get(sym);
returns;
}
(ChangeListenercl,Stringsym)
{
ArrayList<ChangeListener>al=hmCL.get(sym);
if(al==null)
{
al=newArrayList<ChangeListener>();
hmCL.put(sym,al);
}
returnal.add(cl);
}
privatevoidinit(intcount)
{
Randomrand=newRandom();
for(inti=0;i<count;i++)
{
Stringsym=randSym(rand);
floatp=rand.nextFloat();
Stocks=newStock(sym,p);
hmStocks.put(sym,s);
}
}
privateStringrandSym(Randomrand)
{
char[]ca=newchar[3];
for(inti=0;i<ca.length;i++)
{
ca[i]=(char)('A'+rand.nextInt(26));
}
returnnewString(ca);
}
publicstaticvoidmain(String[]args)
{
StockListssl=newStockLists();
sl.addChangeListener(newInvestor("111"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("222"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("333"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("444"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("555"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("666"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("777"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("888"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("999"),sl.randStock().symbol);
sl.addChangeListener(newInvestor("000"),sl.randStock().symbol);
}
}
classStock
{
publicStringsymbol=null;
publicfloatprice=0.0f;
publicStock(Stringsym,floatp)
{
symbol=sym;
price=p;
}
publicStringtoString()
{
returnsymbol+":"+price;
}
}
{
publicStringname="";
publicInvestor(Stringname)
{
this.name=name;
}
@Override
publicvoidstateChanged(ChangeEvente)
{
Stocks=(Stock)e.getSource();
System.out.println("Hello,"+name+":STOCKCHANGED:"+s);
}
}
E. java23个设计模式有哪些
一共23种设计模式！
引用《软件秘笈-设计模式那点事》书籍：
按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。
创建型模式用来处理对象的创建过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。
创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：
工厂方法模式（Factory
Method
Pattern）
抽象工厂模式（Abstract
Factory
Pattern）
建造者模式（Builder
Pattern）
原型模式（Prototype
Pattern）
单例模式（Singleton
Pattern）
结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：
适配器模式（Adapter
Pattern）
桥接模式（Bridge
Pattern）
组合模式（Composite
Pattern）
装饰者模式（Decorator
Pattern）
外观模式（Facade
Pattern）
享元模式（Flyweight
Pattern）
代理模式（Proxy
Pattern）
行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：
责任链模式（Chain
of
Responsibility
Pattern）
命令模式（Command
Pattern）
解释器模式（Interpreter
Pattern）
迭代器模式（Iterator
Pattern）
中介者模式（Mediator
Pattern）
备忘录模式（Memento
Pattern）
观察者模式（Observer
Pattern）
状态模式（State
Pattern）
策略模式（Strategy
Pattern）
模板方法模式（Template
Method
Pattern）
访问者模式（Visitor
Pattern）
F. 为什么rxjava 被观察者方法叫subscribe
而RxJava作为一个工具库，使用的就是通用形式的观察者模式。RxJava的观察者模式RxJava有四个基本概念：Observable(可观察者，即被观察者)、Observer(观察者)、subscribe(订阅)、事件。Observable和Observer通过subscribe()方法实
G. java观察者模式监测多个线程
观察者设计模式定义了对象间的一种一对多的依赖关系，以便一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动刷新。
反之过来，监测多个线程是可以的，
不过需要自己动手设置一番。让观察者接受多个被观察者动态，根据不同线程动态再进行实现。
H. java中常用的设计模式有哪些
1.单例模式（有的书上说叫单态模式其实都一样）
该模式主要目的是使内存中保持1个对象
2.工厂模式
该模式主要功能是统一提供实例对象的引用。看下面的例子：
public class Factory{
public ClassesDao getClassesDao(){
ClassesDao cd = new ClassesDaoImpl();
return cd;
}
}
interface ClassesDao{
public String getClassesName();
}
class ClassesDaoImpl implements ClassesDao {
public String getClassesName(){
System.out.println("A班");
}
}
class test
{
public static void main(String[] args){
Factory f = new Factory();
f.getClassesDao().getClassesName();
}
}
这个是最简单的例子了，就是通过工厂方法通过接口获取对象的引用
3.建造模式
该模式其实就是说，一个对象的组成可能有很多其他的对象一起组成的，比如说，一个对象的实现非常复杂，有很多的属性，而这些属性又是其他对象的引用，可能这些对象的引用又包括很多的对象引用。封装这些复杂性，就可以使用建造模式。
4.门面模式
这个模式个人感觉像是Service层的一个翻版。比如Dao我们定义了很多持久化方法，我们通过Service层将Dao的原子方法组成业务逻辑，再通过方法向上层提供服务。门面模式道理其实是一样的。
5.策略模式
这个模式是将行为的抽象，即当有几个类有相似的方法，将其中通用的部分都提取出来，从而使扩展更容易。
I. java中的设计模式都有哪些
Java中的23种设计模式：
Factory（工厂模式）， Builder（建造模式）， Factory Method（工厂方法模式），
Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），
Adapter（适配器模式）， Bridge（桥梁模式）， Composite（合成模式），
Decorator（装饰模式）， Flyweight（享元模式）， Proxy（代理模式），
Command（命令模式）， Interpreter（解释器模式）， Visitor（访问者模式），
Iterator（迭代子模式）， Mediator（调停者模式）， Memento（备忘录模式），
Observer（观察者模式）， State（状态模式）， Strategy（策略模式），
Template Method（模板方法模式）， Chain Of Responsibleity（责任链模式）