设计模式

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<AbstractWatcher> list = new ArrayList<AbstractWatcher>();  
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