观察者模式
说明
观察者模式的组成
– 抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类或接口来实现。
- 抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。
– 具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。
– 具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。通常用一个子类实现
Watched.java
package com.vvvv.observer;
//抽象主题角色
public interface Watched{
//添加观察者
public void addWatcher(Watcher watcher);
//删除观察者
public void removeWatcher(Watcher watcher);
//传入指定的字符串,通知观察者
public void notifyWatchers(String str);
}
Watcher.java
package com.vvvv.observer;
//抽象观察者
public interface Watcher{
//根据接收到的字符串,更新自已
public void update(String str);
}
ConcreteWatched.java
package com.vvvv.observer;
import java.util.ArrayList;
import java.util.List;
//具体的主题角色
public class ConcreteWatched implements Watched{
//观察者集合
private List<Watcher> list = new ArrayList<Watcher>();
public void addWatcher(Watcher watcher){
list.add(watcher);
}
public void removeWatcher(Watcher watcher){
list.remove(watcher);
}
public void notifyWatchers(String str){
//遍历观察者集合，并调用观察者的更新方法
for(Watcher watcher : list){
watcher.update(str);
}
}
}
ConcreteWatcher.java
package com.vvvv.observer;
//具体的观察者
public class ConcreteWatcher implements Watcher{
//更新
public void update(String str){
System.out.println(str);
}
}
客户端测试类Test.java
package com.vvvv.observer;
//客户端
public class Test{
public static void main(String[] args){
//定义一个美女作为主题
Watched girl = new ConcreteWatched();
//定义三个追求者作为观察者
Watcher watcher1 = new ConcreteWatcher();
Watcher watcher2 = new ConcreteWatcher();
Watcher watcher3 = new ConcreteWatcher();
//将三个追求者添加到对美女的粉丝列表中
girl.addWatcher(watcher1);
girl.addWatcher(watcher2);
girl.addWatcher(watcher3);
//当美女发出消息说："开心，爽",将会触发粉丝也跟着说："开心，爽"
girl.notifyWatchers("开心，爽");
//美女从粉丝列表删除第二个粉丝
girl.removeWatcher(watcher2);
//美女再次发出消息说
girl.notifyWatchers("不爽");
}
}
Observable 与 Observer 的应用
/**
* An object may be observed by two or more
* observers.
*/
import java.util.*;
// This is the class being observed.
class BeingWatched extends Observable {
void counter(int period) {
for (; period >= 0; period--) {
setChanged();
notifyObservers(new Integer(period));
try {
Thread.sleep(100);
}catch (InterruptedException e) {
System.out.println("Sleep interrupted");
}
}
}
}
// This is the first observing class.
class Watcher1 implements Observer {
public void update(Observable obj, Object arg) {
System.out.println("watcher1's update() called, count is " +
( (Integer) arg).intValue());
}
}
// This is the second observing class.
class Watcher2 implements Observer {
public void update(Observable obj, Object arg) {
if ( ( (Integer) arg).intValue() <= 5) {
System.out.println("watcher2's update() called, count is " +
( (Integer) arg).intValue());
}
// Ring bell when done
if ( ( (Integer) arg).intValue() == 0) {
System.out.println("Done" + '\7');
}
}
}
/**
* client
*/
public class TwoObservers {
public static void main(String args[]) {
BeingWatched observed = new BeingWatched();
Watcher1 observing1 = new Watcher1();
Watcher2 observing2 = new Watcher2();
// add both observers
observed.addObserver(observing1);
observed.addObserver(observing2);
observed.counter(10);
}
}
内部类
静态内部类
package com.vvvv.innerclass;
class StaticInner{
private static int a = 4;
//静态内部类
public static class Inner{
public void test(){
System.out.println(a);
}
}
}
public class StaticInnerClassTest{
public static void main(String[] args){
StaticInner.Inner inner = new StaticInner.Inner();
inner.test();
}
}
成员内部类
package com.vvvv.innerclass;
class MemberInner{
private int a = 4;
//成员内部类
public class Inner2{
private int a = 5;
public void doSomething(){
//访问内部类的变量a
System.out.println(this.a);
System.out.println(a);
//访问外部类的变量a
System.out.println(MemberInner.this.a);
}
}
public void method(){
Inner2 inner = this.new Inner2();
}
}
public class MemberInnerClassTest{
public static void main(String[] args){
MemberInner.Inner2 inner = (new MemberInner()).new Inner2();
inner.doSomething();
}
}
局部内类部
package com.vvvv.innerclass;
class LocalInner{
public void doSomething(){
//外部类的变量要想被局部内部类访问到，必须定义成终态
final int a = 4;
//局部内部类
class Inner3{
public void test(){
System.out.println(a);
}
}
new Inner3().test();
}
}
public class LocalInnerClassTest{
public static void main(String[] args){
LocalInner localInner = new LocalInner();
localInner.doSomething();
}
}
匿名内部类
package com.vvvv.innerclass;
import java.util.Date;
public class AnonymousInnerClassTest{
@SuppressWarnings("deprecation")
public String get(Date date){
return date.toLocaleString();
}
public static void main(String[] args){
AnonymousInnerClassTest test = new AnonymousInnerClassTest();
//String str = test.get(new Date());;
//System.out.println(str);
//匿名内部类
String str = test.get(new Date(){
public String toLocaleString(){
return "hello world";
}
});
System.out.println(str);
}
}
输入输出 I/O
使用FilenameFilter
– 希望能够限制由list( )方法返回的文件数目，使它仅返回那些与一定的文件名方式或者过滤(filter)相匹配的文件。为达到这样的目的，必须使用list( )的第二种形式 (方法重载)
– String[ ] list(FilenameFilter FFObj)
– 该形式中，FFObj是一个实现FilenameFilter接口的类的对象
FilenameFilter仅定义了一个方法，accept( )。该方法被列表中的每个文件调用一次。它的通常形式如下：boolean accept(File directory, String filename)
当被directory 指定的目录中的文件（也就是说，那些与filename 参数匹配的文件）包含在列表中时，accept( )方法返回true ，当这些文件没有包括在列表中时，accept( )返回false.
package com.vvvv.io;
import java.io.File;
import java.io.FilenameFilter;
public class FileTest7{
public static void main(String[] args){
File file = new File("C:\\abc\\xyz\\hello");
//策略模式的应用
String[] names = file.list(new FilenameFilter(){
public boolean accept(File dir, String name){
if(name.endsWith(".txt")){
return true;
}
return false;
};
});
for(String name : names){
System.out.println(name);
}
}
}
用InpubStream读取文件
package com.vvvv.io2;
import java.io.FileInputStream;
import java.io.InputStream;
public class InputStreamTest1{
public static void main(String[] args) throws Exception{
InputStream is = new FileInputStream("c:/hello.txt");
byte[] buffer = new byte[200];
int length = 0;
//每次从流中读取200个字节放到buffer里，如果最后一次不足200,length即等于
//实际读到的字节数，如果读指针已经到达文件尾，则返回-1
while(-1 != (length = is.read(buffer, 0, 200))){
//将buffer中从指定位置0开始、长度为length的字节转换成字符串
String str = new String(buffer,0, length);
System.out.println(str);
}
is.close();
}
}
递归列出指定目录下的子目录与文件
package com.vvvv.io2;
import java.io.File;
import java.util.ArrayList;
//列出指定目录下的目录与文件的层次
public class ListAllTest{
//用于判断目录或文件所处的层次
private static int time;
// 递归的方法
public static void deepList(File file){
if (file.isFile() || 0 == file.listFiles().length){
return;
}else{
File[] files = file.listFiles();
files = sort(files);
for(File f : files){
StringBuffer output = new StringBuffer();
if(f.isFile()){
output.append(getTabs(time));
output.append(f.getName());
}else{
output.append(getTabs(time));
output.append(f.getName());
output.append("\\");
}
System.out.println(output);
if(f.isDirectory()){
time++;
deepList(f);
time--;
}
}
}
}
// 整理文件数组，使得目录排在文件之前
private static File[] sort(File[] files){
ArrayList<File> sorted = new ArrayList<File>();
// 寻找到所有的目录
for (File f : files){
if (f.isDirectory()){
sorted.add(f);
}
}
// 寻找到所有的文件
for (File f : files){
if (f.isFile()){
sorted.add(f);
}
}
return sorted.toArray(new File[files.length]);
}
//判断需要加多少 tab的方法
private static String getTabs(int time){
StringBuffer buffer = new StringBuffer();
for(int i = 0; i < time; i++){
buffer.append("\t");
}
return buffer.toString();
}
public static void main(String[] args){
File file = new File("C:\\Projects\\wsclient");
deepList(file);
}
}