【黑马程序员】IO流

IO概述：
 操作数据的工具
 IO流，即数据流，数据像水流一样通过IO工具进行传输。
 程序  <IO>   硬盘
 绝对路径与相对路径
1:异常(理解)
 (1)就是程序的非正常情况。
 (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里面进行匹配。
     有对应的匹配，就走对应的处理方案。
     没有，就找父匹配，有就走对应的处理方案。
     如果找不到，那么就由jvm采用默认处理方案。

   JDK7的新特性：在处理多个平级的异常的时候
    catch(ExceptionA | ExceptionB | ExceptionC ... e) {
    
    }

  B:
   throws：声明异常抛出，定义在函数声明上
   throw：抛出异常  是写在方法体内的
 (5)面试题：
  A:Exception和RuntimeException的区别?
   Exception:分为编译期异常和运行期异常。编译期异常是必须处理的。否则，代码不能编译通过。
   RuntimeException:运行期异常,不需要编写异常处理代码,但是可能需要修正程序参数或者逻辑代码。
  B:throws和throw的区别?
   throws:在方法声明上,后面跟的是异常类名。
          throws声明后面如果是一个运行时期异常，调用者不需要处理。这种方式没有意义。
          throws声明后面跟的是一个编译期异常，调用者是必须处理的。
   throw:在方法体中,后面跟的是异常对象名。
          throw后面如果抛出的是运行时期异常对象，那么方法上是不需要进行声明的。
          throw后面如果抛出的是编译时期异常对象，那么，一般在方法声明上都是要用throws声明该方法有异常。
  C:finally的面试题
   a:final,finally,finalize的特点及区别?
   b:如果catch里面有return，请问finally里面的代码还执行吗?
     如果执行，是在return前，还是后呢?
   c:写一个程序，测试finally里面的操作对结果没有影响。
    finally一般只用于释放资源。
 
 (6)怎么选择呢?
  A:能够自己处理的时候，尽量自己处理。
  B:在main方法里面尽量不要抛。
  C:将来在实际开发中，我们会把不同的异常给出不同的界面进行显示给用户。
 (7)子父关系中的异常处理?
  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()

   注意：仅仅根据后缀名并不能判断是文件还是文件夹。
  B:删除功能
   删除文件或者文件夹：
    delete()

   注意：
    A:删除一个带内容的目录，必须先删除内容，在删除目录。
    B:java中的删除不走回收站。
  C:判断功能
   判断file是否存在：exists()
   判断file是否是文件：isFile()
   判断file是否是文件夹：isDirectory()

  
  D:重名名功能
   把旧名称改变为新名称：renameTo()
    注意：路径问题。
   重命名涉及两个File对象。
   将File1重命名成File2
    在同一目录下：
     file2文件已经存在，重命名失败
     file2文件不存在，重命名成功
    在不同目录下：
     file2文件已经存在，重命名失败
     file2文件不存在，剪切成功
  E:获取功能
   基本获取
    获取绝对路径：getAbsolutePath()
    获取定义的路径：getPath()
    获取名称：getName()
    获取大小：length()
    获取最后修改时间：lastModified()
   高级获取
    获取指定目录下所有文件或者文件夹的名称数组：list()
    获取指定目录下所有文件或者文件夹的File数组：listFiles()
    返回所有盘符：listRoots()
    文件过滤器：
     接口 FilenameFilter  重写accept()方法 dir:文件所在的目录    name：文件名称
     方式1，定义类实现FilenameFilter，list(这个类的实例对象)   
     方式2，匿名内部类    

递归(理解)
 (1)方法定义中调用方法本身的现象
  举例：老和尚给小和尚讲故事，我们学编程
 (2)递归的注意事项；
  A:要有出口，否则就是死递归
  B:次数不能过多，否则内存溢出
  C:构造方法不能递归使用
 (3)递归的案例：
  A:递归求阶乘
  B:兔子问题
  C:递归输出指定目录下所有指定后缀名的文件绝对路径
  D:递归删除带内容的目录(小心使用)
递归(理解)
 (1)方法定义中调用方法本身的现象
  举例：老和尚给小和尚讲故事，我们学编程
 (2)递归的注意事项；
  A:要有出口，否则就是死递归
  B:次数不能过多，否则内存溢出
  C:构造方法不能递归使用
 (3)递归的案例：
  A:递归求阶乘
  B:兔子问题
  C:递归输出指定目录下所有指定后缀名的文件绝对路径
  D:递归删除带内容的目录(小心使用)

package cn.itcast_01;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * IO流的分类：
 * 		流向：
 * 			输入流	读取数据
 * 			输出流 写出数据
 * 		数据类型：
 * 			字节流
 * 				字节输入流	读取数据	InputStream
 * 				字节输出流	写出数据	OutputStream
 * 			字符流
 * 				字符输入流	读取数据	Reader
 * 				字符输出流	写出数据	Writer
 * 
 * 		注意：一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。
 * 
 * 需求：我要往一个文本文件中输入一句话："hello,io"
 * 
 * 分析：
 * 		A:这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
 * 		B:由于我是要往文件中写一句话，所以我们要采用字节输出流。
 * 
 * 通过上面的分析后我们知道要使用：OutputStream
 * 但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
 * 所以，我们要找一个具体的子类。
 * 而我们要找的子类是什么名字的呢?这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
 * 文件是哪个单词：File
 * 然后用的是字节输出流，联起来就是：FileOutputStream
 * 注意：每种基类的子类都是以父类名作为后缀名。
 * 		XxxOutputStream
 * 		XxxInputStream
 * 		XxxReader
 * 		XxxWriter
 * 查看FileOutputStream的构造方法：
 * 		FileOutputStream(File file) 
 *		FileOutputStream(String name)
 *
 * 字节输出流操作步骤：
 * 		A:创建字节输出流对象
 * 		B:写数据
 * 		C:释放资源
 */
public class FileOutputStreamDemo {
	public static void main(String[] args) throws IOException {
		// 创建字节输出流对象
		// FileOutputStream(File file)
		// File file = new File("fos.txt");
		// FileOutputStream fos = new FileOutputStream(file);
		// FileOutputStream(String name)
		FileOutputStream fos = new FileOutputStream("fos.txt");
		/*
		 * 创建字节输出流对象了做了几件事情：
		 * A:调用系统功能去创建文件
		 * B:创建fos对象
		 * C:把fos对象指向这个文件
		 */
		
		//写数据
		fos.write("hello,IO".getBytes());
		fos.write("java".getBytes());
		
		//释放资源
		//关闭此文件输出流并释放与此流有关的所有系统资源。
		fos.close();
		/*
		 * 为什么一定要close()呢?
		 * A:让流对象变成垃圾，这样就可以被垃圾回收器回收了
		 * B:通知系统去释放跟该文件相关的资源
		 */
		//java.io.IOException: Stream Closed
		//fos.write("java".getBytes());
	}
}

 

<pre class="java" name="code">package cn.itcast_01;

import java.io.FileOutputStream;
import java.io.IOException;

/*
 * 字节输出流操作步骤：
 * A:创建字节输出流对象
 * B:调用write()方法
 * C:释放资源
 * 
 * public void write(int b):写一个字节
 * public void write(byte[] b):写一个字节数组
 * public void write(byte[] b,int off,int len):写一个字节数组的一部分
 */
public class FileOutputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		// 创建字节输出流对象
		// OutputStream os = new FileOutputStream("fos2.txt"); // 多态
		FileOutputStream fos = new FileOutputStream("fos2.txt");

		// 调用write()方法
		//fos.write(97); //97 -- 底层二进制数据	-- 通过记事本打开 -- 找97对应的字符值 -- a
		// fos.write(57);
		// fos.write(55);
		
		//public void write(byte[] b):写一个字节数组
		byte[] bys={97,98,99,100,101};
		fos.write(bys);
		
		//public void write(byte[] b,int off,int len):写一个字节数组的一部分
		fos.write(bys,1,3);
		
		//释放资源
		fos.close();
	}
}

package cn.itcast;/* * Throwable：错误或异常的根类，只要是该类的子类，就一定是异常 * * Error：错误 代码无法自己解决的问题 * Exception:异常 可以使用代码解决的问题 * 非RuntimeException子类：编译时异常，编译时无法编译通过。 * RuntimeException子类:运行时异常，编译时不报错，运行时可能会报错，可以不处理。 * * JVM默认处理异常处理方式： * 即将该异常的名称、异常的信息、异常出现的位置打印在了控制台上，同时将程序停止运行。 * * 异常的操作： * 创建异常对象（JDK已定义的异常会自动创建对象，自定义异常需要手动创建） * 抛出异常（JDK已有定义的异常会自动抛出异常，自定义异常需要手动抛出） * 处理异常 */public class Demo01_IO {public static void main(String[] args) {int i = 10;int j = 0;System.out.println("异常前代码");System.out.println(i/j);System.out.println("异常后代码");}}

package cn.itcast;
/*
 * 将异常捕获并处理:
 * 		格式1：
 * 			try{
				需要检测的代码；
			}catch(异常类  变量){
				异常处理代码；
			}
 */
public class Demo02_Catch {

	public static void main(String[] args) {

		int i = 10;
		int j = 0;
		
		System.out.println("try前");
		
		try{
			System.out.println("try中，异常前");
//			需要检测的代码；
			System.out.println(i/j);
			System.out.println("try中，异常后");
		}catch(ArithmeticException e){
			System.out.println("catch中");
//			异常处理代码；
			System.out.println("请重新出入，除数不能为0");
		}
		
		System.out.println("try后");
	}

}