黑马程序员技术交流社区

标题: 基础班课堂笔记19-21天 [打印本页]

---

作者: 曹操001    时间: 2015-6-28 00:57
标题: 基础班课堂笔记19-21天
1、异常
1、概念
     程序出现不正常的情况

2、异常体系(掌握)
     Throwable
          |—Error                                    严重的错误，比如硬件坏了
          |—Exception                                   
                    |—RuntimeException     运行时异常，不需要处理,需要改代码
                    |—非RuntimeException  编译时异常，需要处理
     注意：
          每种体系的子类都是以父类的名称作为后缀
          XxxError
          XxxException

3、JAVA虚拟机的默认处理方式
     把异常的类名，原因，位置等信息显示在控制台
     一旦有异常发生，其后的代码不能继续执行

4、异常的解决方案(掌握)
     A：自己处理
          基本格式
               try{
                    可能发生异常的代码;
               }catch(异常类名 变量名){
                    异常的处理代码;
               }finally{
                    释放资源的代码;
               }
          变形格式
               try..catch
               try..catch..catch
               try..catch..catch..finally
               try..finally
          注意:
               不能写成 try{}单独存在
         
          JDK1.7针对多个catch做了优化
               try{
                    可能发生的异常代码;
               }catch(异常1 | 异常2 | 异常3){//注意，这些异常必须是平级关系

               }finally{

              }


     B、声明异常
           用throws关键字在方法上声明异常
           注意：throws应该叫声明，有些人叫抛出，这么叫是不准确的
                     throw是抛出

     C、自定义异常
          1、写一个普通类，继承RuntimeException(运行时)或者继承Exception(编译)
          2、写构造方法，一个有参的，一个无参的

     
5、到底应该选用谁？
          a、能自己处理的就自己处理
          b、不能自己处理的就抛出
2、异常常见面试题总结
1、finally的特点及面试题
     1、特点：finally里面的代码永远会执行，除非在执行前JVM退出
     2、区别：
               a:请说说final,finally,finalize 的区别?
                             final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
                              内部类要访问局部变量，局部变量必须定义成final类型，例如，一段代码……
                              finally是异常处理语句结构的一部分，表示总是执行。
                              finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资            源回收，例如关闭文件等。JVM不保证此方法总被调用
               b:finally 里面的代码永远会执行吗 ?
                    不一定，程序在执行fianlly前以外G掉
               c: 假如在catch里面有 ruturn,finally里面的代码还能被执行吗 ?
                   如果能,请问是在 return前, 还是在return后 ?
                    也许你的答案是在return之前，但往更细地说，我的答案是在return中间执行，请看下面程序代码的运行结果：
         
     static int test() {
          int x = 1;
          try
          {
              return x;
          }
          finally
          {
              ++x;
          }
     }


---------执行结果 ---------
运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。

2、Exception和RuntimeException 的区别?
           A:Exception 编译时期异常，必须处理的。
                     如果在方法上， throws了该类型的异常，将来调用者必须处理。
                     如果在方法内部， throw了该类型的异常，必须在方法上 throws该异常。
           B:RuntimeException 运行时期异常，是不需要处理的。要改代码的。
                     如果在方法上， throws了该类型的异常，不需要处理。
                     如果在方法内部， throw了该类型的异常，方法上可以 throws该异常，也可以不throws该异常。

3、throw和throws 的用法和区别 ?
           A:throw
                  用法：用在方法内部，后面跟的是异常对象名称。
                  区别：用 throw抛出了编译时期异常，方法上面必须用 throws抛出。
                       用throw抛出了运行时期异常，方法上面可以不用 throws抛出。
           B:throws
                  用法：用在方法声明上，后面跟的是异常类名。
                  区别：用 throws在方法上声明了异常，内部可以没有 throw

3、File类
1、概述
              因为数据在硬盘上最常见的方式，就是文件。而文件本身有很多的属性，比如说：文件大小，是否可读，是否隐藏。那么 java为了方便我们对文件进行操作，就提供了 File类供我们使用。
              File：既可以表示文件，也可以表示 (目录) 文件夹。  
     注意：什么是File？
               
4、File类-成员方法


构造方法
File(String pathName)
根据指定的路径创建File对象
File(String parent, String child)
根据指定的父文件夹和子文件或者文件夹创建File对象
File(File parent, String child)
根据指定的父文件夹对象和子文件或文件夹创建File对象
以上三个方法，创建当前文件或文件夹的时候都是先看是否存在，如果存在就不创建，否则就创建
创建功能
boolean createNewFile()
创建文件
boolean mkdir()
创建文件夹
boolean mkdirs()
创建多级文件夹
删除功能
public boolean delete()
删除文件或文件夹
A：如果删除的目录下还有内容，则必须先把该目录下的的内容清空
B：JAVA语言的删除不走回收站
判断功能
public boolean exists()
判断 file 对象是否存在
public boolean isFile()
判断 file对象是否是文件
public boolean isDirectory()
判断 file对象是否是文件夹
public boolean isAbsolute()
判断 file对象是否是绝对路径
public boolean canRead()
判断 file对象是否可读
public boolean canWrite()
判断 file对象是否可写
public boolean isHidden()
判断 file对象是否隐藏
获取功能
public File getAbsoluteFile()
获取文件的绝对路径
public String getName()
获取文件名称
public String getPath()
获取相对路径
public long length()
获取文件的大小，单位是字节
public long lastModified()
获取上次修改时间的毫秒值
public static File[] listRoots()
列出可用的系统文件根目录
public String[] list()
返回的是指定目录下所有文件或者文件夹的名称数组
public String[] list(FilenameFilter filter)
public File[] listFiles()
返回的是指定目录下所有文件或者文件夹对象数组
public File[] listFiles(FilenameFilter filter)


3、File类-案例
1、获取指定目录下所有 .mp4文件的名称


importjava.io.File;
importjava.io.FilenameFilter;

/*
* 获取指定目录下指定后缀的文件名称：
* A:先获取指定目录下所有文件或者文件夹的File数组,然后再遍历的时候进行判断。满足条件的就输出该File的名称。
* B:直接获取指定目录下满足条件的String(File)数组。然后遍历数组即可。
*
* 文件名称过滤器：FilenameFilter
*        public String[] list(FilenameFilter filter)
*/
public classFileDemo {
      public static voidmain(String[] args) {
           // 封装目录
           File file = new File("d:\\");

           // 获取满足条件的数组
           String[] strArray = file.list(new FilenameFilter() {
                 @Override
                 public booleanaccept(File dir, String name) {
                      // 判断是否是文件，是否是以.mp4结尾
                      // System.out.println(dir + "---" + name);
                      File file = new File(dir, name); // d:\我的文档
                      boolean flag = file.isFile();
                      boolean flag2 = name.endsWith(".mp4");
                      return flag && flag2;
                 }
           });

           // 遍历字符串数组
           for(String str : strArray) {
                 System.out.println(str);
           }
      }
}

---

作者: 曹操001    时间: 2015-6-28 00:59
1、递归
1、概述
     方法定义中调用方法本身的现象


2、注意事项
     A、递归次数不能过多，否则内存溢出
     B、一定要有出口，否则死递归。
     C、构造方法不能递归

3、递归案例
     A、求N的阶乘
               public static int jc(int n){
     if(n ==1){
          return 1；
     else
          return n* jc(n -1);
     }
               }
     B、递归遍历指定目录,列出文件和文件夹的绝对路径
     C、递归删除带内容目录

讲递归是为了给遍历目录和删除目录打基础，关于递归有兴趣的同学可以去看一些其他案例
2、IO流体系(每天记一点，最好今天全都记住，要不以后可能会乱)


记忆路线：输入输出流前面加File和Buffered，这就记住6个了，还剩两个转换流名字比较特殊，需要着重记一下(转换流：字节和字符的组合，所以起名字叫InputStreamReader,OutputStreamWriter)


3、FileWriter(掌握)
1、使用步骤
/**
* FileWriter类的使用
* 该类是写入字符文件的快捷类
*/
public classFileWriterDemo {
       public static voidmain(String[] args)throws Exception {
              //第一步:创建字符流输出对象
              FileWriter fw = new FileWriter("readme.txt");
            
              //第二步:调用写入数据方法
              fw.write("注意事项"+System.getProperty("line.separator"));
              fw.write("1、上课不能玩手机"+System.getProperty("line.separator"));
              fw.write("2、不能迟到早退"+System.getProperty("line.separator"));
            
              //第三步:调用刷新缓冲区功能,该功能会将缓冲区的数据写入到文件,并且清空缓冲区中的内容
              fw.flush();
            
              //第四步:关闭流，释放资源
              fw.close();
       }
}

2、flush 方法和close方法的区别
     flush只刷新缓冲区，不释放流资源，流对象还可以继续使用
     close刷新并且释放流资源，流对象不可以继续使用

3、如何实现数据换行
     window:\r\n
     linux:\n
     mac:\r
     通用解决方案：String line = System.getProperty("line.separator");//根据当前系统返回相应的换行符

4、怎么实现追加数据
     调用FileWriter(String fileName, true)构造方法创建对象
4、FileReader(掌握)
1、使用步骤
importjava.io.FileReader;
public classFileReaderDemo {
       public static voidmain(String[] args)throws Exception {
              //第一步：创建字符流输入对象
              FileReader fr = new FileReader("readme.txt");
            
              //第二步：调用读取数据方法，并显示
              /*
               *方式1:：一次读取一个字符，效率低 ,不推荐
               */
              int ch = 0;
              while((ch=fr.read()) != -1){
                     System.out.print((char)ch);
              }
            
            
              /*
               * 方式2：一次读取一个字符数组，效率高推荐
               */
              fr = newFileReader("readme.txt");//必须重新赋值，或者注释掉方式1中的代码,因为fr对象已经读取到末尾了，必须重新开始读取
              char[] chs = new char[1024];
              int len = 0;
              while((len = fr.read(chs)) != -1){
                     System.out.println(newString(chs,0,len));
              }
            

              //第三步：关闭流，释放资源，该对象无法继续使用
              fr.close();
       }
      
}



5、综合练习(掌握-必须练到闭着眼睛敲下来)
1、复制文本文件 , 从D 盘中复制一个 haha.txt文件( 里面字节写上 ”我爱学Java, 我爱学编程 ”)到E 盘下, 起名为 copy.txt

try异常的代码

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;


public class CopyFileDemo {

       public static void main(String[] args) throws Exception {
              boolean flag = copy(new FileReader("D://haha.txt"), new FileWriter("E://haha.txt"));
              if(flag){
                     System.out.println("拷贝成功");
              }else{
                     System.out.println("拷贝失败");
              }
       }
       /**
        * 拷贝文件
        * 思路：读取文件内容的同时，将读取到的内容写入到输出流
        */
       public static boolean copy(FileReader fileReader, FileWriter fileWriter) {
              //标识符，拷贝成功变为true并返回，拷贝失败返回false
              boolean flag = false;
            
              //创建字符数组，将读取到的内容存进去
              char[] chs = new char[1024];
              int len = -1;
            
            
              try {
                     //读取文件，将读取到的内容存到chs字符数组
                     while((len = fileReader.read(chs)) != -1){
                            //将字符数组中的内容写入到输出流
                            fileWriter.write(chs, 0, len);
                            fileWriter.flush();
                     }
                    
                     //拷贝成功，修改标识符的值为true
                     flag = true;
              } catch (IOException e) {
                     e.printStackTrace();
              }finally{
                     try {
                            fileWriter.close();
                     } catch (IOException e) {
                            e.printStackTrace();
                     }
                     try {
                            fileReader.close();
                     } catch (IOException e) {
                            e.printStackTrace();
                     }
              }
            
            
              return flag;
       }
}






抛异常的代码

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileUtil {
         /**
          * 拷贝文本文件
          * 从src 拷贝到 dest
          * @param src
          * 源文件
          * @param dest
          * 目标文件
          */
         public static void copy(File src, File dest) throws IOException {
                   FileReader fr =new FileReader(src);
                   FileWriter fw = new FileWriter(dest);

                  
                   char[] chs = new char[1024];
                   int len = -1;
                   while ((len = fr.read(chs)) != -1) {
                            fw.write(chs, 0, len);
                   }
                  
                   fr.close();
                   fw.close();

         }
}

6、练习
1、File类的list(FilenameFilter); 会用就可以了
2、递归求阶乘
3、扫描文件
4、删除某个目录下的所有文件
5、练习两个自定义方法：copy：一个高效的，一个不高效的
6、测试高效拷贝和不高效拷贝的效率

---

作者: 曹操001    时间: 2015-6-28 01:02
IO体系——字符流


记忆路线：输入输出流前面加File和Buffered，这就记住6个了，还剩两个转换流名字比较特殊，需要着重记一下(转换流：字节和字符的组合，所以起名字叫InputStreamReader,OutputStreamWriter)






3、IO体系——字节流


记忆路线：输入输出流前面加File和Buffered，这样就全记住了


2、字节流 与 字符流 比较
1、到底使用谁
     如果在写数据的时候需要另起一行或者读数据的时候一行一行读就用字符缓冲流：BufferedReader & BufferedWriter
     如果操作的是文本就用字符流，因为操作比较方便。否则就用字节流
     如果根本不知道用哪个，就用字节流，因为字节流很强大
     
2、复制文本文件
     (1)复制文本文件的几种方式
          字节流：
                      4 种
                             基本流一次读写一个字节
                             基本流一次读写一个字节数组
                             高效流一次读写一个字节
                             高效流一次读写一个字节数组
                  字符流：
                      5 种
                             基本流一次读写一个字符
                             基本流一次读写一个字符数组
                             高效流一次读写一个字符
                             高效流一次读写一个字符数组
                             高效流一次读写一个字符串

     (2)推荐
          既然是文本文件那么用字符串缓冲流读写是最好的方式

     (3)推荐代码：

public static void main(String[] args) throwsException{
              //字符缓冲输入流
              BufferedReader bufferedReader = new BufferedReader(newFileReader("d://readme.txt"));
              //字符缓冲输出流
              BufferedWriter bufferedWriter = new BufferedWriter(newFileWriter("d://readme.txt.bak"));
            
              String line = null;
              //每次读取一行，如果读到null就停止读取文件内容
              while((line=bufferedReader.readLine()) != null){
                     bufferedWriter.write(line);
                     bufferedWriter.flush();
              }
            
              //关闭流
              bufferedReader.close();
              bufferedWriter.close();
       }


3、复制二进制数据(非文本文件，音乐，视频，应用软件等..)

      (1)赋值二进制文件的几种方式
                  基本流一次读写一个字节
                  基本流一次读写一个字节数组
                  高效流一次读写一个字节
                  高效流一次读写一个字节数组


      (2)推荐
          使用缓冲流一次读写一个字节数组

      (3)推荐代码
       public static voidmain(String[] args) throws Exception {
              // 定义字节缓冲输入流
              BufferedInputStream bis = null;
              // 定义字节缓冲输出流
              BufferedOutputStream bos = null;

              try {
                     bis = new BufferedInputStream(newFileInputStream("d://readme.txt"));
                     bos = new BufferedOutputStream(newFileOutputStream("d://readme.txt.byte"));
                     byte[] bys = new byte[1024];
                     int len = -1;

                     while ((len = bis.read(bys)) != -1) {
                            bos.write(bys, 0, len);
                            bos.flush();
                     }
              } catch(Exception e) {
                     e.printStackTrace();
              } finally {

                     if (bis != null) {
                            try {
                                   bis.close();
                            } catch (Exception e) {
                                   e.printStackTrace();
                            }
                     }

                     if (bos != null) {
                            try {
                                   bos.close();
                            } catch (Exception e) {
                                   e.printStackTrace();
                            }
                     }
                     // 关闭流
              }
       }

---

作者: 1958078929    时间: 2015-6-28 09:18
谢谢分享

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2