IO概述：
操作数据的工具
IO流，即数据流，数据像水流一样通过IO工具进行传输。
程序 <IO> 硬盘
绝对路径与相对路径
1:异常(理解)
(1)就是程序的非正常情况。
异常相关操作：
创建异常对象（JDK已定义的异常会自动创建对象，自定义异常需要手动创建）
抛出异常（JDK已有定义的异常会自动抛出异常，自定义异常需要手动抛出）
处理异常:
程序员在有异常抛出时，异常的处理方法有两种:(1)将异常捕获并处理(2)声明抛出异常
(2)异常的继承体系结构：
Throwable:
|--Error 严重的问题,不需要处理的。
|--Exception 非RuntimeException必须进行处理。两种方案，点击鼠标即可。
|--RuntimeException 运行时期异常,需要修正代码。
(3)jvm的默认处理方式：
默认情况下，jvm会采用默认处理方案：
把异常的全路径名称，原因，及位置等信息显示出来。
注意：
如果是jvm的默认处理方式，那么，它会在出问题的地方结束。
(4)我们自己的处理方案：
A:处理方式之一：使用捕获
try...catch...finally
基本格式：
try {
可能有问题的代码;
}catch(异常对象) {
对问题的处理;
}finally { //一定会执行的代码
释放资源;
}
变形格式：
try...catch
try...catch...catch
try...catch...catch...finally
try...finally
多异常处理方式：
分别捕获分别处理，每个try对应一个catch ( cn.itcast2.demo4)
package cn.itcast2; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /* * 多个异常的捕获处理： * 1:分别捕获分别处理，每个try对应一个catch */ public class Demo4 { public static void main(String[] args) { DateFormat df = new SimpleDateFormat("yyyy-MM-dd"); try { Date parse = df.parse("2008-08-08"); System.out.println(parse); } catch (ParseException e) { System.out.println("您的日期格式有误，请换成2008-08-08的格式！"); } int a = 10; int b = 0; try { System.out.println(a/b); } catch (Exception e) { System.out.println("您的计算中，有数学错误，请更换数字"); } System.out.println("================"); } }
分别捕获分别处理，一个try对应所有catch (cn.itcast2.demo5) ，注意：大的异常不能在前边捕获
package cn.itcast2; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /* * 多个异常的捕获处理： * 2:分别捕获分别处理，一个try对应所有catch,注意：前边的异常一定要小于后边的异常 * 3:一次捕获共同处理,不能同时捕获大的异常与小的异常 */ public class Demo5 { public static void main(String[] args) { DateFormat df = new SimpleDateFormat("yyyy-MM-dd"); int a = 10; int b = 0; //2：格式2 //报错，前边的异常不小于后边的异常 // try { // Date parse = df.parse("2008,08-08"); // System.out.println(parse); // System.out.println(a/b); // } catch (ParseException e) { // System.out.println("您的日期格式有误，请换成2008-08-08的格式！"); // } catch (ArithmeticException e) { // System.out.println("您的计算中，有数学错误，请更换数字"); // } try { Date parse = df.parse("2008,08-08"); System.out.println(parse); System.out.println(a/b); //前边的异常一定要小于后边的异常 } catch (ParseException e) { System.out.println("您的日期格式有误，请换成2008-08-08的格式！"); } catch (Exception e) { System.out.println("您的计算中，有数学错误，请更换数字"); } System.out.println("try后的代码继续执行..."); //格式3： try{ Date parse = df.parse("2008-08-08"); System.out.println(parse); System.out.println(a/b); }catch(ParseException|ArithmeticException e) { //一次捕获共同处理,不能同时捕获大的异常与小的异常 System.out.println(e); } System.out.println(true||false); System.out.println(true|false); } }
一次捕获共同处理
注意：不能同时捕获大的异常与小的异常
注意：
如果多个异常，有子父关系，父异常一定要放在最后。
如果多个异常，是平级关系，它们存在的位置没有顺序关系。
执行顺序：
在try里面的代码会按照从上往下执行，一旦发生问题，
就会产生一个异常对象，去和catch里面进行匹配。
有对应的匹配，就走对应的处理方案。
没有，就找父匹配，有就走对应的处理方案。
如果找不到，那么就由jvm采用默认处理方案。
JDK7的新特性：在处理多个平级的异常的时候
catch(ExceptionA | ExceptionB | ExceptionC ... e) {
}
B:异常处理方式之二:使用声明抛出
throws
* throws：用于声明函数抛出异常。用于函数声明。
* 多个异常可以同时声明抛出，用逗号分隔。 （cn.itcast2.demo7）
package cn.itcast2; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; /* * 异常处理方式：声明异常抛出 * throws：用于声明函数抛出异常。用于函数声明。 * 是异常对象的处理方式之一。 * 多个异常可以同时声明抛出，用逗号分隔。 */ public class Demo7 { public static void main(String[] args) { int a = 10,b=0; try { method(a,b); } catch (ArithmeticException e) { e.printStackTrace(); } System.err.println("--------------"); try { method2(a,b); } catch (ArithmeticException e) { e.printStackTrace(); } catch (ParseException e) { e.printStackTrace(); } System.err.println("--------------"); } public static void method(int a,int b) throws ArithmeticException{ System.err.println(a/b); } public static void method2(int a,int b) throws ArithmeticException, ParseException{ //多个异常可以同时声明抛出，用逗号分隔 method(a,b); DateFormat df = new SimpleDateFormat("yyyy-MM-dd"); df.parse("a"); } } /** 程序执行结果 java.lang.ArithmeticException: / by zero at cn1.Demo7.method(Demo7.java:35) at cn1.Demo7.main(Demo7.java:18) -------------- java.lang.ArithmeticException: / by zero at cn1.Demo7.method(Demo7.java:35) at cn1.Demo7.method2(Demo7.java:39) at cn1.Demo7.main(Demo7.java:25) -------------- */
(5)自定义异常
如果涉及其他需求，JDK没有提供相应的异常对象，则可以自己定义异常。
定义格式：继承Exception或者RuntimeException。同时需要带参的构造方法，用于接收异常信息。
public class MyException extends Exception{
public MyException(String message){
super(message);
}
}
例子：cn.itcast2.demo8 cn.itcast2.MyException.java
package cn.itcast2; /* * 自定义异常： * 补充java没有提供的异常类 */ public class Demo8 { public static void main(String[] args) { //规定，一个班最多只能有100个人。 int classNumber = 101; //方式一：捕获异常 if(classNumber>100) { try { throw new MyException("班级人数大于100了，不能大于100！");//手动抛出自定义异常类对象 } catch (MyException e) { System.err.println("======="); System.err.println(e.getMessage()+"........."); e.printStackTrace(); System.err.println("======="); } } System.err.println("-------------"); try { method(); } catch (MyException e) { e.printStackTrace(); } } //方式二：声明抛出异常 public static void method() throws MyException { //声明抛出异常 //规定，一个班最多只能有100个人。 int classNumber = 101; if(classNumber>100) { throw new MyException("班级人数大于100了，不能大于100！");//手动抛出自定义异常类对象 } System.err.println("-------------"); } }
package cn.itcast2; /* * 自定义异常：超过100就不行 */ public class MyException extends Exception { public MyException(String message) { super(message); } }
(6)面试题：
A:Exception和RuntimeException的区别?
Exception:分为编译期异常和运行期异常。编译期异常是必须处理的。否则，代码不能编译通过。
RuntimeException:运行期异常,不需要编写异常处理代码,但是可能需要修正程序参数或者逻辑代码。
B:throws和throw的区别?
throws:在方法声明上,后面跟的是异常类名。
throws声明后面如果是一个运行时期异常，调用者不需要处理。这种方式没有意义。
throws声明后面跟的是一个编译期异常，调用者是必须处理的。
throw:在方法体中,后面跟的是异常对象名。
throw后面如果抛出的是运行时期异常对象，那么方法上是不需要进行声明的。
throw后面如果抛出的是编译时期异常对象，那么，一般在方法声明上都是要用throws声明该方法有异常。
C:finally的面试题
a:final,finally,finalize的特点及区别?
final：最终的意思，可以修饰类，成员变量，成员方法
修饰类，类不能被继承
修饰变量，变量是常量
修饰方法，方法不能被重写
finally：是异常处理的一部分，用于释放资源。
一般来说，代码肯定会执行，特殊情况：在执行到finally之前jvm退出了
finalize：是Object类的一个方法，用于垃圾回收
b:如果catch里面有return，请问finally里面的代码还执行吗?
如果执行，是在return前，还是后呢?
会执行，在前，确切的说在中间，先执行return的代码，再执行finally里面的代码，最后return
c:写一个程序，测试finally里面的操作对结果没有影响。
finally一般只用于释放资源。cn.itcast.demo9
D:jvm的默认处理方式? 打印，宕机
(7)对于异常，怎么选择呢?
A:能够自己处理的时候，尽量自己处理。
B:在方法里面尽量不要抛。
C:将来在实际开发中，我们会把不同的异常给出不同的界面进行显示给用户。
(8)子父关系中的异常处理?
class Fu {
public void show() throws Exception {
}
}
class Zi extends Fu {
public void show() throws RuntimeException {
}
}
class Demo {
public static void main(String[] args) {
}
}
子的重写方法中不能抛出比父更大的异常。
2:File(理解)
(1)因为硬盘上对数据的存储基本上都是以文件存在。为了方便对文件或者文件夹进行操作。
java就提供了一个类File供我们使用。本质上是对路径的封装。
(2)File类构造方法：
A:File file = new File("d:\a.txt");
B:File file = new File("d:\","a.txt");
C:File file = new File("d:");
File file2 = new File(file,"a.txt");
以上三种格式等价。
(3)File类的功能:
A:创建功能
创建文件：createNewFile()
创建文件夹：mkdir(),mkdirs()
例子：cn.itcast3.demo2
package cn.itcast3; import java.io.File; import java.io.IOException; /* * File类的普通方法： * 1:public boolean createNewFile() throws IOException 创建文件 * 2:public boolean mkdir() 创建文件夹 * 注意:现有文件夹，后有文件 * 3:public boolean mkdirs() 创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。 将所有父目录全部创建。 */ public class Demo2 { public static void main(String[] args) throws IOException { //创建文件夹与文件对象 File dir = new File("z"); File file = new File("z/z.txt"); //2:创建文件夹z boolean mkdir = dir.mkdir(); System.out.println(mkdir); //1:创建文件z.text boolean createNewFile = file.createNewFile(); System.out.println(createNewFile); //层级创建文件 File dir2 = new File("c/a/d/e/w/d/f/t/z"); boolean mkdir2 = dir2.mkdirs(); System.out.println(mkdir2); } }
注意：仅仅根据后缀名并不能判断是文件还是文件夹。
B:删除功能
删除文件或者文件夹：delete()
注意：
A:删除一个带内容的目录，必须先删除内容，在删除目录。
B:java中的删除不走回收站。
C:判断功能
判断file是否存在：exists()
判断file是否是文件：isFile()
判断file是否是文件夹：isDirectory()
例子：cn.itcast3.demo3-myself.text
import java.io.File; import java.io.IOException; /* * File类的普通方法： * 1：public boolean delete() 文件可以直接删除，文件夹删除时，必须保证里边已经没有内容了 * 2：public boolean isHidden()测试此抽象路径名指定的文件是否是一个隐藏文件 * 3:public boolean isFile() 判断是否是文件 * 4:public boolean isDirectory() 判断是否是文件夹 * 5:public boolean exists() 测试此抽象路径名表示的文件或目录是否存在。 */ public class Demo3 { public static void main(String[] args) throws IOException { //创建文件夹 File dir = new File("b"); dir.mkdir(); //需要先创建文件夹，然后创建文件 File file = new File("b/b.txt"); file.createNewFile(); /* //先删除文件，再删除文件夹 System.out.println(file.delete()); System.out.println(dir.delete());*/ //是否是隐藏文件 System.out.println(file.isHidden()); //是否是文件 System.out.println(file.isFile()); //是否是文件夹 System.out.println(dir.isDirectory()); // 测试此抽象路径名表示的文件或目录是否存在。 System.out.println(file.exists()); } }
D:重名名功能
把旧名称改变为新名称：renameTo()
注意：路径问题。
重命名涉及两个File对象。
将File1重命名成File2
在同一目录下：
file2文件已经存在，重命名失败
file2文件不存在，重命名成功
在不同目录下：
file2文件已经存在，重命名失败
file2文件不存在，剪切成功
例子：cn.itcast3.demo4
package cn.itcast3; import java.io.File; /* * File类的普通方法： * public boolean renameTo(File dest) 同目录：重命名/不同目录：剪切加重命名 */ public class Demo4 { public static void main(String[] args) { File file = new File("a.txt"); File file2 = new File("b.txt"); File file3 = new File("d/c.txt"); boolean renameTo = file.renameTo(file2); System.out.println(renameTo); boolean renameTo2 = file2.renameTo(file3); System.out.println(renameTo2); } }
E:获取功能
基本获取
获取绝对路径：getAbsolutePath()
获取相对路径：getPath()
获取名称：getName()
获取大小：length() //英文字母1个字节，中文字母两个字节
获取最后修改时间：lastModified()
例子：cn.itcast3.demo5
package cn.itcast3; import java.io.File; import java.util.Date; /* * File类的普通方法： * 1：public String getAbsolutePath() : 返回此抽象路径名的绝对路径名字符串。 * 2：public String getPath(): 将此抽象路径名转换为一个路径名字符串。 * 3：public String getParent()：返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。 * 4:public File getParentFile()：返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。 * 5:public String getName():返回由此抽象路径名表示的文件或目录的名称。 * 6:public long length() 返回：文件存储内容的长度 * 7：public long lastModified()：返回上一次修改时间毫秒值 */ public class Demo5 { public static void main(String[] args) { File file = new File("a.txt"); File file2 = new File("D:/Lesson/JAVA/JAVA基础/北京/150315/day19/code/day19/a.txt"); //1 System.out.println(file.getAbsolutePath()); System.out.println(file2.getAbsolutePath()); System.out.println("==========="); //2 System.out.println(file.getPath()); System.out.println(file2.getPath()); System.out.println("==========="); //3 String p = file.getParent(); System.out.println(p); String p2 = file2.getParent(); System.out.println(p2); System.out.println("==========="); //4 File pFile = file.getParentFile(); System.out.println(pFile); File pFile2 = file2.getParentFile(); System.out.println(pFile2); System.out.println("==========="); //5 String name = file.getName(); System.out.println(name); String name2 = file2.getName(); System.out.println(name2); System.out.println("==========="); //6 System.out.println(file.length()); //7 System.out.println(file.lastModified());//返回毫秒值1428829519158L System.out.println(new Date(file.lastModified()));//返回日期格式 } }
高级获取
获取指定目录下所有文件或者文件夹的名称数组：list()
获取指定目录下所有文件或者文件夹的File数组：listFiles()
返回所有盘符：listRoots()
例子1：cn.itcast3.demo6
package cn.itcast3; import java.io.File; import java.util.Arrays; /* * 文件高级获取： * 1：public static File[] listRoots() 获取所有盘符的文件对象 * 2：public String[] list() 这些字符串指定此抽象路径名表示的目录中的文件和目录。即该File下的所有文件及目录(字符串)。 * 3:public File[] listFiles() 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。 即File下的所有文件及目录(File对象)。 */ public class Demo6 { public static void main(String[] args) { //1： File[] listRoots = File.listRoots(); System.out.println(Arrays.toString(listRoots)); //2： File dir = new File("src/cn/itcast"); String[] list = dir.list(); System.out.println(Arrays.toString(list)); //3: File[] listFiles = dir.listFiles(); System.out.println(Arrays.toString(listFiles)); for (File file : listFiles) { System.out.println(file.getName()); } } }
例子2：cn.itcast3.demo7：获取srccnitcast目录下所有.java结尾的文件（注意是文件 ，不是文件夹）
package cn.itcast3; import java.io.File; /* * 获取srccnitcast目录下所有.java结尾的文件 */ public class Demo7 { public static void main(String[] args) { //创建文件对象，表示指定的文件夹 File dir = new File("src/cn/itcast"); //方法一：（如果有文件夹是.java结尾的，则不能过滤该文件夹） // //获取该文件夹下的所有File对象字符串表现(文件，文件夹) // String[] list = dir.list(); // //获取该数组中的每一个元素 // for (String fileordir : list) { // boolean endsWith = fileordir.endsWith(".java"); // if(endsWith) { // System.out.println(fileordir); // } // } //方法二： //获取该文件夹下的所有File对象对象表现(文件，文件夹) File[] listFiles = dir.listFiles(); //获取该数组中的每一个元素 for (File fileordir : listFiles) { //先判断是否为文件 if(fileordir.isFile()) { boolean endsWith = fileordir.getName().endsWith(".java"); if(endsWith) { System.out.println(fileordir.getName()); } } } } }
文件过滤器：
接口 FilenameFilter 重写accept()方法
方式1，定义类实现FilenameFilter，然后用file.list(该类的实例对象)
方式2，匿名内部类
例子：cn.itcast3.demo8
package cn.itcast3; import java.io.File; import java.io.FilenameFilter; import java.util.Arrays; /* * File的方法： * public String[] list(FilenameFilter filter) * public File[] listFiles(FilenameFilter filter) * // 3:public File(File parent,String child) * 文件过滤器 * FilenameFilter： * boolean accept(File dir, String name) 将list/listFiles方法所在目录下所有的File对象都判断一次是否符合条件。符合条件返回true，不符合，返回false * * 获取srccnitcast目录下所有.java结尾的文件,要求使用过滤器 */ public class Demo8 { public static void main(String[] args) { //创建文件对象，表示指定的文件夹 File dir = new File("src/cn/itcast"); //获取该文件夹下的所有符合条件的File对象字符串表现(文件，文件夹) String[] list = dir.list(new FilenameFilter(){ //匿名内部类 @Override public boolean accept(File dir, String name) { File thisFile = new File(dir,name); if(thisFile.isFile()){ if(name.endsWith(".java")) { return true; } } return false; }}); System.out.println(Arrays.toString(list)); } }
---------------------------------------------------------------------------------------------------------------
例子程序：
1、返回某文件夹下所有以java结尾的文件
a)使用list方法
b)使用listFiles方法
c)使用list方法加文件过滤器
d)使用listFiles方法加文件过滤器
import java.io.File; import java.io.FilenameFilter; import java.util.Arrays; /** * 7：返回某文件夹下所有以java结尾的文件。 * a)使用list方法 * b)使用listFiles方法 * c)使用list方法加文件过滤器 * d)使用listFiles方法加文件过滤器 */ public class Test7 { public static void main(String[] args) { //a)使用list方法 (不能判断是文件还是文件夹) /* File file=new File("src/cn1"); String[] strings=file.list(); for(String s:strings){ if(s.endsWith(".java")){ System.out.println(s); } }*/ //使用listFiles方法 /* File file = new File("src/cn1"); File[] files = file.listFiles(); for (File f : files) { if (f.isFile()) { if(f.getName().endsWith(".java")){ System.out.println(f.getName()); } } }*/ //c)使用list方法加文件过滤器 /* File file=new File("src/cn1"); String[] strings=file.list(new FilenameFilter() { @Override public boolean accept(File dir, String name) { File file1=new File(dir,name); if(file1.isFile()){ if(file1.getName().endsWith(".java")){ return true; } } return false; } }); System.out.println(Arrays.toString(strings));*/ //d)使用listFiles方法加文件过滤器 /*File file=new File("src/cn1"); File[] files=file.listFiles(new FilenameFilter() { @Override public boolean accept(File dir, String name) { File file1=new File(dir,name); if(file1.isFile()){ if(file1.getName().endsWith(".java")){ return true; } } return false; } }); for(File f:files){ System.out.println(f.getName()); }*/ } }
2、完成一个文件的创建，判断，删除。
import java.io.File; import java.io.IOException; /** * 3:完成一个文件的创建，判断，删除。 */ public class Test3 { public static void main(String[] args) throws IOException { File file=new File("src/cn2/a.test"); //文件的创建 file.createNewFile(); //判断 System.out.println(file.isFile()); System.out.println(file.isDirectory()); //删除 file.delete(); } }
3、完成文件的创建、重命名、删除。
import java.io.File; import java.io.IOException; /** * 5：完成文件的创建、重命名、删除。 */ public class Test5 { public static void main(String[] args) throws IOException { //文件的创建 File file=new File("d.txt"); file.createNewFile(); //重命名 File file1=new File("src/cn1/e.txt"); file.renameTo(file1); //删除 file1.delete(); } }
4、完成多级目录的创建。
import java.io.File; import java.io.IOException; /** * 6：完成多级目录的创建。 */ public class Test6 { public static void main(String[] args) throws IOException { File dir=new File("src/a/b/c/d/e"); dir.mkdirs(); File file=new File("src/a/a.txt"); file.createNewFile(); } }