java笔记2(观察者模式、内部类、输入输出)

最新推荐文章于 2024-05-31 10:46:10 发布

weixin_34395205

最新推荐文章于 2024-05-31 10:46:10 发布

阅读量70

点赞数

文章标签： java

原文链接：http://www.cnblogs.com/luowei010101/archive/2012/09/05/2671737.html

版权

观察者模式

说明

观察者模式的组成

– 抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类或接口来实现。

抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。

– 具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

– 具体观察者角色：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。通常用一个子类实现

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);

}

转载于:https://www.cnblogs.com/luowei010101/archive/2012/09/05/2671737.html

weixin_34395205

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java笔记2(观察者模式、内部类、输入输出)

观察者模式说明观察者模式的组成 – 抽象主题角色：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类或接口来实现。抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。– 具体主题角色：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角...
复制链接

扫一扫