IO装饰设计模式：（IO中使用了装饰设计模式）
节点流可以直接从源读取数据，处理流就是对节点流的包装，这就是装饰，装饰就是对原有的流的性能的提升。比如买的车，马力不够，就进行装饰，使其马力增大。
装饰模式：
扩音器对声音进行了扩大。

类与类之间的关系（6种）： 1、依赖:一个对象是形参或者局部变量，只有调用方法的时候才会依赖这个类。
2、关联:一个对象是属性。关联分为：
  聚合:是属性 整体与部分关系， 不一致的生命周期， 人与手
  组合:是属性 整体与部分关系， 一致的生命周期，  人与大脑
3、继承:父子类关系。
4、实现: 接口与实现类关系

public class Voice {
    private int voice =10;
    public Voice() {
        // TODO Auto-generated constructor stub
    }
    public int getVoice() {
        return voice;
    }
    public void setVoice(int voice) {
        this.voice = voice;
    }
    
    public void say(){
        System.out.println(voice);
    }
    
}



/**
 * 扩音器
 * 类与类之间的关系：
 * 1、依赖:一个对象是形参或者局部变量，只有调用方法的时候才会依赖这个类。
 * 2、关联:一个对象是属性。关联分为：
 *         聚合:是属性 整体与部分关系， 不一致的生命周期， 人与手
 *      组合:是属性 整体与部分关系， 一致的生命周期，  人与大脑
 * 3、继承:父子类关系。
 * 4、实现: 接口与实现类关系。
 */
public class Amplifier {
    private Voice voice;
    public Amplifier() {
    }
    public Amplifier(Voice voice) {
        super();
        this.voice = voice;
    }
    public void say(){
        System.out.println(voice.getVoice()*1000);
    }
}


public class App {
    public static void main(String[] args) {
        Voice v =new Voice();
        v.say();
        Amplifier am =new Amplifier(v);
        am.say();
    }
}




4.不能父目录拷贝到子目录中。
if(dest.getAbsolutePath().contains(src.getAbsolutePath())){
    System.out.println("父目录不能拷贝到子目录中");
    return;
}




/**
 * 文件的分割思路
 * 1、分割的块数 size   n块
 * 2、每一块的大小 blockSize
 *   最后:总的文件大小 -(n-1)*blockSize
 */
public class RndDemo01 {
    public static void main(String[] args) throws IOException {
        RandomAccessFile rnd =new RandomAccessFile(new File("E:/xp/test/a.txt"),"r");
        rnd.seek(30);//跳过30字节再开始。一个数字是4个字节
        //定义缓冲大小
        byte[] flush =new byte[10];
        //接收长度
        int len =0;         
        while(-1!=(len=rnd.read(flush))){
            if(len>=20){
                System.out.println(new String(flush,0,20));
                break;
            }else{
                System.out.println(new String(flush,0,len));
            }
        }
        FileUtil.close(rnd);
    }
}


文件的分割与合并：

public class SplitFile {
    //原始文件的路径
    private String filePath;
    //原始文件名
    private String fileName;
    //原始文件大小
    private long length;
    //根据每块的大小，确定分多少块
    private int size;
    //每块的大小
    private long blockSize;
    //分割后的存放目录
    private String destBlockPath;
    //每块的名称
    private List<String> blockPath;
    
    public SplitFile(){
        blockPath = new ArrayList<String>();
    }
    public SplitFile(String filePath,String destBlockPath){
        this(filePath,destBlockPath,1024);        
    }
    public SplitFile(String filePath,String destBlockPath,long blockSize){//方法里面一个个调用另一个方法，这是面向过程的思路。
        this();
        this.filePath= filePath;
        this.destBlockPath =destBlockPath;
        this.blockSize=blockSize;
        init();
    }
    
    /**
     * 初始化操作 计算 块数、确定文件名
     */
    public void init(){
        File src =null;
        //健壮性
        if(null==filePath ||!(((src=new File(filePath)).exists()))){
            return;
        }
        if(src.isDirectory()){
            return ;
        }
        //文件名
        this.fileName =src.getName();
        
        //计算块数 实际大小 与每块大小
        this.length = src.length();
        //修正 每块大小
        if(this.blockSize>length){
            this.blockSize =length;
        }
        //确定块数        
        size= (int)(Math.ceil(length*1.0/this.blockSize));
        //确定文件的路径
        initPathName();
    }
    
    private void initPathName(){
        for(int i=0;i<size;i++){
            this.blockPath.add(destBlockPath+"/"+this.fileName+".part"+i);
        }
    }
    
    /**
     * 文件的分割
     * 0)、第几块
     * 1、起始位置
     * 2、实际大小
     * @param destPath 分割文件存放目录
     */
    public void split(){    
        long beginPos =0;  //起始点
        long actualBlockSize =blockSize; //实际大小        
        //计算所有块的大小、位置、索引
        for(int i=0;i<size;i++){
            if(i==size-1){ //最后一块
                actualBlockSize =this.length-beginPos;
            }            
            spiltDetail(i,beginPos,actualBlockSize);
            beginPos+=actualBlockSize; //本次的终点，下一次的起点
        }
    }
    /**
     * 文件的分割 输入 输出
     * 文件拷贝
     * @param idx 第几块
     * @param beginPos 起始点
     * @param actualBlockSize 实际大小
     */
    private void spiltDetail(int idx,long beginPos,long actualBlockSize){
        //1、创建源
        File src = new File(this.filePath);  //源文件
        File dest = new File(this.blockPath.get(idx)); //目标文件
        //2、选择流
        RandomAccessFile raf = null;  //输入流，随机访问流。
        BufferedOutputStream bos=null; //输出流
        try {
            raf=new RandomAccessFile(src,"r");
            bos =new BufferedOutputStream(new FileOutputStream(dest));
            //读取文件，定位到起始位置。
            raf.seek(beginPos);
            //缓冲区
            byte[] flush = new byte[1024];
            //接收长度
            int len =0;
            while(-1!=(len=raf.read(flush))){                
                if(actualBlockSize-len>=0){ //查看是否足够
                    //写出
                    bos.write(flush, 0, len);
                    actualBlockSize-=len; //剩余量
                }else{ //写出最后一次的剩余量
                    bos.write(flush, 0, (int)actualBlockSize);
                    break;
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            FileUtil.close(bos,raf);
        }
    }
    /**
     * 文件的合并
     */
    public void merge(String destPath){
        //创建源
        File dest =new File(destPath);
        //选择流
        BufferedOutputStream bos=null; //输出流
        SequenceInputStream sis =null ;//输入流
        //创建一个容器
        Vector<InputStream> vi = new Vector<InputStream>();        
        try {
            for (int i = 0; i < this.blockPath.size(); i++) {
                vi.add(new BufferedInputStream(new FileInputStream(new File(this.blockPath.get(i)))));//把每块文件的流搞成一个集合。
            }    
            bos =new BufferedOutputStream(new FileOutputStream(dest,true)); //追加
            sis=new SequenceInputStream(vi.elements());    //java.io.SequenceInputStream.SequenceInputStream(Enumeration<? extends InputStream> e)
        //public Enumeration<E> elements() 
                
            //缓冲区
            byte[] flush = new byte[1024];
            //接收长度
            int len =0;
            while(-1!=(len=sis.read(flush))){//读到程序里面来，所以是输入流。
                bos.write(flush, 0, len);//输出到目的地文件，所以是输出流。
            }
            bos.flush();
            FileUtil.close(sis);
        } catch (Exception e) {
        }finally{
            FileUtil.close(bos);
        }        
        
    }
    /**
     * 文件的合并
     */
    public void merge1(String destPath){
        //创建源
        File dest =new File(destPath);
        //选择流
        BufferedOutputStream bos=null; //输出流
        try {
            bos =new BufferedOutputStream(new FileOutputStream(dest,true)); //追加
            BufferedInputStream bis = null;
            for (int i = 0; i < this.blockPath.size(); i++) {
                bis = new BufferedInputStream(new FileInputStream(new File(this.blockPath.get(i))));
                //缓冲区
                byte[] flush = new byte[1024];
                //接收长度
                int len =0;
                while(-1!=(len=bis.read(flush))){
                    bos.write(flush, 0, len);
                }
                bos.flush();
                FileUtil.close(bis);
            }
        } catch (Exception e) {
        }finally{
            FileUtil.close(bos);
        }        
    }

    public static void main(String[] args) {
        SplitFile split = new SplitFile("E:/xp/20130502/test/学员设置(20130502).xls","E:/xp/20130502",51);
        System.out.println(split.size);
        split.split();
        split.merge("E:/xp/20130502/test1.xls");
    }
}



IO总结：
IO操作步骤:4步。创建源，选择流，操作，
如图
操作：递归打印，文件拷贝，关闭流的方法，文件的分割与合并。