popo

java-doc-设计模式

Posted on Edited on

Observable

Observable类用于创建可以被程序其他部分观察的子类。当这种子类的对象发生变化时，观察类就会注意到。观察类必须实现Observer接口，该接口定义了update()方法。当观察者注意到观察者的某个变化时，会调用update()方法。

将被观察的对象必须遵循两条简单的规则：首先，如果被观察对象发生变化，就必须调用setChanged()方法；其次，当准备通知观察者这一变化时，就必须调用notifyObservers()方法，这回导致被观察的对象的update()方法被调用。如果在调用notifyObservers()之前没有调用setChanged()那么不会发生任何动作，在调用update()之前，被观察对象必须调用setChanged()和notifyObservers()方法。

  • Observable类定义的方法
方法 描述
void addObserver(Observer obj) 将obj添加到观察者调用对象的对象列表中
protected void clearChanged() 调用该方法将调用对象的状态返回到“未改变”
int countObservers() 返回观察调用对象的对象数量
void deleteObserver(Observer obj) 将obj从观察调用对象的对象列表中删除
void deleteObservers() 删除调用对象的所有观察对象
boolean hasChanged() 如果调用对象已经被修改，就返回true；否则返回false
void notifyObservers() 通过调用update()方法，通知调用对象的所有观察者————对象已经发生了变化。传递null作为update()方法的第2个参数
void notifyObservers(Object obj) 通过调用update()方法，通知调用对象的所有观察者————对象已经发生了变化。将obj作为参数传递到update()方法中
protected void setChanged() 该方法调用对象发生变化时被调用
void update(Observable observOb, Object arg) observOb是被观察的对象，arg是由notifyObervers()方法传递的值 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
import java.util.*;

class Watcher1 implements Observer
{
    public void update(Observable obj, Object arg) 
    {
        System.out.println("update() called, count is" + ((Integer)arg).intValue());
    }
}

class Watcher2 implements Observer
{
    public void update(Observable obj, Object arg) 
    {
        if(((Integer)arg).intValue() == 0) {
            System.out.println("Done");
        }
    }
}

class BeingWatched extends Observable
{
    void counter(int period) {
        for(; period >= 0; period--) {
            this.setChanged();
            this.notifyObservers(new Integer(period));
            
            try {
                Thread.sleep(100);
            } catch(InterruptedException e) {
                System.out.println("Sleep interrupted");
            }
        }
    }
}

public class LearnObserver1 
{
    public static void main(String args[])
    {
        BeingWatched observed = new BeingWatched();
        Watcher1 observing1 = new Watcher1();
        Watcher2 observing2 = new Watcher2();
        
        observed.addObserver(observing1);
        observed.addObserver(observing2);
        
        observed.counter(10);
    }
}

反射

反射是软件分析自身的能力，这个功能是由java.lang.reflect包和Class中的元素提供的。反射是重要的功能，特别是当使用调用了Java Bean的组件时。通过反射可以在运行时而不是在编译时，动态地分析软件组件描述组件的功能。

Modifier

  • Modifier定义的方法
方法 描述
static boolean isAbstract(int val) 如果val中设置了abstract标志，就返回true；否则返回false
static boolean isFinal(int val) 如果val中设置了final标志，就返回true；否则返回false
static boolean isInterface(int val) 如果val中设置了interface标志，就返回true；否则返回false
static boolean isNative(int val) 如果val中设置了native标志，就返回true；否则返回false
static boolean isPrivate(int val) 如果val中设置了private标志，就返回true；否则返回false
static boolean isProtected(int val) 如果val中设置了protected标志，就返回true；否则返回false
static boolean isPublic(int val) 如果val中设置了public标志，就返回true；否则返回false
static boolean isStatic(int val) 如果val中设置了static标志，就返回true；否则返回false
static boolean isStrict(int val) 如果val中设置了strict标志，就返回true；否则返回false
static boolean isSynchronized(int val) 如果val中设置了Synchronized标志，就返回true；否则返回false
static boolean isTransient(int val) 如果val中设置了transient标志，就返回true；否则返回false
static boolean isVolatile(int val) 如果val中设置了volatile标志，就返回true；否则返回false 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

class A
{
    public void a1() {}
    public void a2() {}
    protected void a3() {}
    private void a4() {}
}

public class LearnReflect1 
{
    public static void main(String args[])
    {
        try {
            A a = new A();
            Class<?> c = a.getClass();
            System.out.println("Public Methods:");
            Method methods[] = c.getDeclaredMethods();
            
            for(int i = 0; i < methods.length; i++) {
                int modifiers = methods[i].getModifiers();
                if(Modifier.isPublic(modifiers)){
                    System.out.println(" " + methods[i].getName());
                }
            }
        } catch (Exception e) {
            System.out.println("Exception: " + e);
        }
    }
}