Day19_IO第一天

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


什么时候用throw,什么时候用throws，什么时候用try
1、当系统不创建异常对象的时候，我就用throw手动创建异常对象
2、什么时候用throws : 当方法内部出现异常我不知道如何解决，或者是我解决了对方法的调用者会产生影响，这个时候用throws
3、在方法内部解决了异常，对方法的调用者没有任何影响，就用try


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、案例(掌握)

1、判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称

2、 * 键盘录入一个int类型的整数,对其求二进制表现形式
* 如果录入的整数过大,给予提示,录入的整数过大请重新录入一个整数BigInteger
* 如果录入的是小数,给予提示,录入的是小数,请重新录入一个整数
* 如果录入的是其他字符,给予提示,录入的是非法字符,请重新录入一个整数

3、A:面试题1final,finally和finalize的区别

3、案例代码(掌握)


1、判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称

  1. package com.heima.test;
  3. import java.io.File;
  4. import java.io.FilenameFilter;
  6. public class Test3 {
  8. 	/**
  9. 	 * @param args
  10. 	 * * A:案例演示
  11. 	 * 需求：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
  12. 	 */
  13. 	public static void main(String[] args) {
  14. 		File dir = new File("E:\\");
  15. 		
  16. //		String[] arr = dir.list();					//获取e盘下所有的文件或文件夹
  17. //		for (String string : arr) {
  18. //			if(string.endsWith(".jpg")) {
  19. //				System.out.println(string);
  20. //			}
  21. //		}
  22. 		
  23. 		/*File[] subFiles = dir.listFiles();			//获取e盘下所有的文件或文件夹对象
  24. 		
  25. 		for (File subFile : subFiles) {
  26. 			if(subFile.isFile() && subFile.getName().endsWith(".jpg")) {
  27. 				System.out.println(subFile);
  28. 			}
  29. 		}*/
  30. 		
  31. 		String[] arr = dir.list(new FilenameFilter() {
  32. 			
  33. 			@Override
  34. 			public boolean accept(File dir, String name) {
  35. 				//System.out.println(dir);
  36. 				//System.out.println(name);
  37. 				File file = new File(dir, name);
  38. 				return file.isFile() && file.getName().endsWith(".jpg");
  39. 			}
  40. 		});
  41. 		
  42. 		for (String string : arr) {
  43. 			System.out.println(string);
  44. 		}
  45. 	}
  47. }
2、 * 键盘录入一个int类型的整数,对其求二进制表现形式
* 如果录入的整数过大,给予提示,录入的整数过大请重新录入一个整数BigInteger
* 如果录入的是小数,给予提示,录入的是小数,请重新录入一个整数
* 如果录入的是其他字符,给予提示,录入的是非法字符,请重新录入一个整数

  1. package com.heima.test;
  3. import java.math.BigDecimal;
  4. import java.math.BigInteger;
  5. import java.util.Scanner;
  7. public class Test2 {
  9. 	/**
  10. 	 * 键盘录入一个int类型的整数,对其求二进制表现形式
  11. 	 * 如果录入的整数过大,给予提示,录入的整数过大请重新录入一个整数BigInteger
  12. 	 * 如果录入的是小数,给予提示,录入的是小数,请重新录入一个整数
  13. 	 * 如果录入的是其他字符,给予提示,录入的是非法字符,请重新录入一个整数
  14. 	 * 
  15. 	 * 分析:
  16. 	 * 1,创建键盘录入对象
  17. 	 * 2,将键盘录入的结果存储在String类型的字符串中,存储int类型中如果有不符合条件的直接报错,无法进行后续判断
  18. 	 * 3,键盘录入的结果转换成int类型的数据,是正确的还是错误的
  19. 	 * 4,正确的直接转换
  20. 	 * 5,错误的要进行对应判断
  21. 	 */
  22. 	public static void main(String[] args) {
  23. 		Scanner sc = new Scanner(System.in);
  24. 		System.out.println("请输入一个整数:");
  25. 		
  26. 		
  27. 		while(true) {
  28. 			String line = sc.nextLine();					//将键盘录入的结果存储在line中
  29. 			try {
  30. 				int num = Integer.parseInt(line);				//将字符串转换为整数
  31. 				System.out.println(Integer.toBinaryString(num));//将整数转换为二进制
  32. 				break;											//跳出循环
  33. 			}catch(Exception e) {
  34. 				try {
  35. 					new BigInteger(line);
  36. 					System.out.println("录入错误,您录入的是一个过大整数,请重新输入一个整数:");
  37. 				}catch (Exception e2) {							//alt + shif + z (try catch快捷键)
  38. 					try {
  39. 						new BigDecimal(line);
  40. 						System.out.println("录入错误,您录入的是一个小数,请重新输入一个整数:");
  41. 					} catch (Exception e1) {
  42. 						System.out.println("录入错误,您录入的是非法字符,请重新输入一个整数:");
  43. 					}
  44. 				}
  45. 				
  46. 			}
  47. 		}
  48. 		
  49. 		
  50. 	}
  52. }
3、A:面试题1final,finally和finalize的区别
  1. package com.heima.test;
  3. public class Test1 {
  5. 	/**
  6. 	 * * A:面试题1
  7. 			* final,finally和finalize的区别
  8. 			* final可以修饰类,不能被继承
  9. 			* 修饰方法,不能被重写
  10. 			* 修饰变量,只能赋值一次
  11. 			* 
  12. 			* finally是try语句中的一个语句体,不能单独使用,用来释放资源
  13. 			* 
  14. 			* finalize是一个方法,当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
  15. 		* B:面试题2
  16. 			* 如果catch里面有return语句，请问finally的代码还会执行吗?如果会，请问是在return前还是return后。
  17. 	 */
  18. 	public static void main(String[] args) {
  19. 		Demo d = new Demo();
  20. 		System.out.println(d.method());
  21. 	}
  23. }
  25. class Demo {
  26. 	public int method() {
  27. 		int x = 10;
  28. 		try {
  29. 			x = 20;
  30. 			System.out.println(1/0);
  31. 			return x;
  32. 		} catch (Exception e) {
  33. 			x = 30;
  34. 			return x;
  35. 		} finally {
  36. 			x = 40;
  37. 			//return x;					千万不要在finally里面写返回语句,因为finally的作用是为了释放资源,是肯定会执行的
  38. 										//如果在这里面写返回语句,那么try和catch的结果都会被改变,所以这么写就是犯罪
  39. 		}
  40. 	}
  41. }


6、今天必须掌握的内容，面试题，笔试题。

1、说说异常体系
2、如何创建一个自定义异常
3、throw和throws的区别
4、final,finally,finalize的区别
5、Exception和RuntimeException的区别
6、finally 里面的代码永远会执行吗
7、假如在catch里面有 ruturn,finally里面的代码还能被执行吗
8、File中判断文件，文件夹是否存在的方法是哪个
9、File类中创见目录和创建文件的方法是哪个
10、File类中获取当前目录下的所有文件的方法是哪个
11、File类中判断文件是否存在的方法是哪个
12、File类中哪个方法可以获取文件的大小，默认是什么单位
13、判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
14、使用文件过滤器打印 C:\Windows  目录下的所有.exe文件





posted on 2016-12-23 09:52  虫虫爬啊爬  阅读(145)  评论(0)  编辑  收藏  举报

导航