设计模式

  1. .抽象主题角色类 
  2. package com.observe;  
  3.   
  4. public interface AbstractWatched {  
  5.       
  6.     //增加一个观察者  
  7.     public void addAbstactWatcher(AbstractWatcher watcher);  
  8.       
  9.     //移除一个观察者  
  10.     public void removeAbstactWatcher(AbstractWatcher watcher);  
  11.       
  12.     //移除所有的观察着  
  13.     public void removeAll();  
  14.       
  15.     //通知所有的观察者  
  16.     public void notifyWatchers();  
  17.   
  18. }  

抽象观察者角色 
  1. package com.observe;  
  2.   
  3. public interface AbstractWatcher {  
  4.       
  5.     public void update();  
  6.   
  7. }  
.具体主题角色(Watched) 
  1. package com.observe;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. public class ConcreteWatched implements AbstractWatched {  
  7.   
  8.     //list:存放观察者的一个集合对象  
  9.     List list = new ArrayList();  
  10.       
  11.     //增加一个观察者  
  12.     public void addAbstactWatcher(AbstractWatcher watcher) {  
  13.         list.add(watcher);  
  14.   
  15.     }  
  16.   
  17.     //移除一个观察者  
  18.     public void removeAbstactWatcher(AbstractWatcher watcher) {  
  19.         list.remove(watcher);  
  20.   
  21.     }  
  22.   
  23.     //移除所有的观察着  
  24.     public void removeAll() {  
  25.         list.clear();  
  26.   
  27.     }  
  28.       
  29.     //通知所有的观察者  
  30.     public void notifyWatchers() {  
  31.         for(AbstractWatcher watcher : list){  
  32.             watcher.update();  
  33.         }  
  34.   
  35.     }  
  36.   
  37. }  
4.具体观察者角色(Watcher) 

  1. package com.observe;  
  2.   
  3.   
  4. public class ConcreteWatcher implements AbstractWatcher {  
  5.   
  6.     //观察到被观察者发生变化时,执行的方法  
  7.     public void update() {  
  8.         System.out.println("update.....");  
  9.           
  10.     }  
  11.       
  12.       
  13.   
  14. }  

  1. package com.observe;  
  2.   
  3. public class ClientTest {  
  4.   
  5.     public static void main(String[] args){  
  6.         //定义一个被观察者对象  
  7.         AbstractWatched watched = new ConcreteWatched();  
  8.           
  9.         //定义三个观察者对象  
  10.         AbstractWatcher watcher1 = new ConcreteWatcher();  
  11.         AbstractWatcher watcher2 = new ConcreteWatcher();  
  12.         AbstractWatcher watcher3 = new ConcreteWatcher();  
  13.           
  14.         //被观察者添加观察者. 被观察者和观察者之间关系是一对多关系  
  15.         watched.addAbstactWatcher(watcher1);  
  16.         watched.addAbstactWatcher(watcher2);  
  17.         watched.addAbstactWatcher(watcher3);  
  18.           
  19.         System.out.println("第1次...");  
  20.         //被观察者发生改变时,通知观察者执行相应方法  
  21.         watched.notifyWatchers();  
  22.           
  23.         //移除一个观察者  
  24.         watched.removeAbstactWatcher(watcher2);  
  25.           
  26.         System.out.println("第2次...");  
  27.         //被观察者发生改变时,通知观察者执行相应方法  
  28.         watched.notifyWatchers();  
  29.           
  30.         //移除一个所有观察者  
  31.         watched.removeAll();  
  32.           
  33.         System.out.println("第3次...");  
  34.         //被观察者发生改变时,通知观察者执行相应方法  
  35.         watched.notifyWatchers();  
  36.           
  37.     }  
  38. }  



【硬连接】
硬连接指通过索引节点来进行连接。在Linux的文件系统中,保存在磁盘分区中的文件不管是什么类型都给它分配一个编号,称为索引节点号(Inode Index)。在Linux中,多个文件名指向同一索引节点是存在的。一般这种连接就是硬连接。硬连接的作用是允许一个文件拥有多个有效路径名,这样用户就可以建立硬连接到重要文件,以防止“误删”的功能。其原因如上所述,因为对应该目录的索引节点有一个以上的连接。只删除一个连接并不影响索引节点本身和其它的连接,只有当最后一个连接被删除后,文件的数据块及目录的连接才会被释放。也就是说,文件真正删除的条件是与之相关的所有硬连接文件均被删除。

【软连接】
另外一种连接称之为符号连接(Symbolic Link),也叫软连接。软链接文件有类似于Windows的快捷方式。它实际上是一个特殊的文件。在符号连接中,文件实际上是一个文本文件,其中包含的有另一文件的位置信息。



查看文件内容 
cat file1 从第一个字节开始正向查看文件的内容 
tac file1 从最后一行开始反向查看一个文件的内容 
more file1 查看一个长文件的内容 
less file1 类似于 'more' 命令,但是它允许在文件中和正向操作一样的反向操作 
head -2 file1 查看一个文件的前两行 
tail -2 file1 查看一个文件的最后两行 
tail -f /var/log/messages 实时查看被添加到一个文件中的内容 

举例:(假设我们有一文件名为ab)
     删除某行
     [root@localhost ruby# sed '1d' ab              #删除第一行 
     [root@localhost ruby] # sed '$d' ab              #删除最后一行
     [root@localhost ruby] # sed '1,2d' ab           #删除第一行到第二行
     [root@localhost ruby] # sed '2,$d' ab           #删除第二行到最后一行

  显示某行
.    [root@localhost ruby# sed -n '1p' ab           #显示第一行 
     [root@localhost ruby] # sed -n '$p' ab           #显示最后一行
     [root@localhost ruby] # sed -n '1,2p' ab        #显示第一行到第二行
     [root@localhost ruby] # sed -n '2,$p' ab        #显示第二行到最后一行

  使用模式进行查询
     [root@localhost ruby] # sed -n '/ruby/p' ab    #查询包括关键字ruby所在所有行
     [root@localhost ruby] # sed -n '/\$/p' ab        #查询包括关键字$所在所有行,使用反斜线\屏蔽特殊含义

代替一行或多行
     [root@localhost ruby] # sed '1c Hi' ab                #第一行代替为Hi
     Hi
     ruby is me,welcome to my blog.
     end
     [root@localhost ruby] # sed '1,2c Hi' ab             #第一行到第二行代替为Hi
     Hi
     end

  替换一行中的某部分
  格式:sed 's/要替换的字符串/新的字符串/g'   (要替换的字符串可以用正则表达式)
     [root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby/bird/g'    #替换ruby为bird
   [root@localhost ruby] # sed -n '/ruby/p' ab | sed 's/ruby//g'        #删除ruby


你可能感兴趣的:(java)