Unit08： 文本数据IO操作 、 异常处理
* java.io.ObjectOutputStream
* 对象输出流，作用是进行对象序列化
package day08; import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List; /**
* java.io.ObjectOutputStream
* 对象输出流，作用是进行对象序列化
* 对象序列化:将一个java中的对象转换为一组字节的
* 过程
* 对象流是高级流。
* @author adminitartor
*
*/
public class ObjectOutputStream_WriteObject {
public static void main(String[] args) throws Exception {
Person person = new Person();
person.setName("苍老师");
person.setAge(18);
person.setGender("女"); List<String> otherInfo
= new ArrayList<String>();
otherInfo.add("是一名演员");
otherInfo.add("爱好是写大字");
otherInfo.add("促进中日文化交流");
otherInfo.add("是广大男性同胞的启蒙老师");
person.setOtherInfo(otherInfo); System.out.println(person); /*
* 将Person对象写入文件
*/
FileOutputStream fos
= new FileOutputStream("person.obj"); ObjectOutputStream oos
= new ObjectOutputStream(fos);
/*
* void writeObject(Object obj)
* 将给定的对象转换为一组字节后写出
*
* 若想将一个对象序列化，要求该对象所属的
* 类必须实现可序列化接口，否则会抛出异常。
*/
oos.writeObject(person);
System.out.println("对象写出完毕!"); oos.close(); }
}
ObjectOutputStream_WriteObject.java
* 该类用于测试对象流的读写对象操作
package day08; import java.io.Serializable;
import java.util.List; /**
* 该类用于测试对象流的读写对象操作
* @author adminitartor
*
*/
public class Person implements Serializable{
private String name;
private int age;
private String gender;
/*
* transient关键字
* 被该关键字修饰的属性在进行对象序列化的时候
* 值会被忽略。将无需保存的属性用该关键字修饰
* 可以达到对象序列化时的"瘦身"工作,减少资源
* 开销
* 除此之外，该关键字没有其他任何作用。
*/
private transient List<String> otherInfo; Person(){ } public Person(String name, int age, String gender, List<String> otherInfo) {
super();
this.name = name;
this.age = age;
this.gender = gender;
this.otherInfo = otherInfo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
/**
* 通常一个方法内部抛出什么异常，方法上就要
* 使用throws声明该异常的抛出，以通知调用者
* 这里可能出现什么问题，要求其处理。
* 只有一类异常抛出时可以不声明，
* 就是RuntimeException及其子类异常
* @param age
* @throws Exception
*/
public void setAge(int age) throws Exception{
if(age<0||age>100){
throw new Exception("年龄不合法!");
}
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public List<String> getOtherInfo() {
return otherInfo;
}
public void setOtherInfo(List<String> otherInfo) {
this.otherInfo = otherInfo;
} @Override
public String toString() {
return name+","+age+","+gender+","+
otherInfo;
}
}
Person.java
* java.io.ObjectInputStream
* 对象输入流，用于进行:对象返序列化
package day08; import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream; /**
* java.io.ObjectInputStream
* 对象输入流，用于进行:对象返序列化
*
* @author adminitartor
*
*/
public class ObjectInputStream_ReadObject {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/*
* 将person.obj文件中的对象读取出来
*/
FileInputStream fis
= new FileInputStream("person.obj"); ObjectInputStream ois
= new ObjectInputStream(fis); Person person = (Person)ois.readObject();
System.out.println("读取对象完毕!");
System.out.println(person); ois.close();
}
}
ObjectInputStream_ReadObject.java
* java.io.OutputStreamWriter
* 该流也叫做转换流，是字符输出流的一个常用实现类。
package day08; import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter; /**
* Writer，Reader
* 这俩个流是所有字符流的父类
* 字符流:以字符为单位读写数据。
*
* java.io.OutputStreamWriter
* 该流也叫做转换流，是字符输出流的一个常用
* 实现类。
* @author adminitartor
*
*/
public class OutputStreamWriter_Write {
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("osw.txt"); OutputStreamWriter osw
= new OutputStreamWriter(fos,"UTF-8"); osw.write("我爱北京*");
osw.write("*上太阳升"); System.out.println("写出完毕!");
osw.close();
}
}
OutputStreamWriter_Write.java
* java.io.InputStreamReader
* 转换流
package day08; import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader; /**
* java.io.InputStreamReader
* 转换流
* @author adminitartor
*
*/
public class InputStreamReader_Read {
public static void main(String[] args) throws IOException {
FileInputStream fis
= new FileInputStream("osw.txt"); InputStreamReader isr
= new InputStreamReader(fis,"UTF-8"); int d = -1;
while((d = isr.read())!=-1){
System.out.print((char)d);
} isr.close();
}
}
InputStreamReader_Read.java
* java.io.PrintWriter
* 常用的缓冲字符输出流
* 特点是:可以按行写出字符串，并且具有自动行刷新
package day08; import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter; /**
* java.io.PrintWriter
* 常用的缓冲字符输出流
* 特点是:可以按行写出字符串，并且具有自动行刷新
* PrintWriter内部嵌套java.io.BufferedWriter
* 所以缓冲功能是靠内部的BW实现的。
* @author adminitartor
*
*/
public class PrintWriter_Println {
public static void main(String[] args) throws IOException {
/*
* PrintWriter提供了多种构造方法
* 方便快速创建。
* 其中有直接针对文件写操作的构造方法:
* PrintWriter(String path)
* PrintWriter(File file)
*/
PrintWriter pw
= new PrintWriter("pw.txt","utf-8"); pw.println("锄禾日当午");
pw.println("清明上河图"); System.out.println("写出完毕!");
pw.close();
}
}
PrintWriter_Println.java
* 当使用PrintWriter处理其他流的时候，
* 可以指定自动行刷新，即:每当使用println方法
* 写出内容后，会自动flush
package day08; import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter; /**
* 当使用PrintWriter处理其他流的时候，
* 可以指定自动行刷新，即:每当使用println方法
* 写出内容后，会自动flush
* @author adminitartor
*
*/
public class PrintWriter_AutoFlush {
public static void main(String[] args) throws IOException {
FileOutputStream fos
= new FileOutputStream("pw1.txt");
//若需要按照指定字符集，需要加上转换流
OutputStreamWriter osw
= new OutputStreamWriter(fos,"UTF-8");
/*
* 当创建PrintWriter时第一个参数为流，
* 那么就支持传入第二个参数，该参数为
* boolean值，表示是否自动行刷新。当
* 该值为true则具备自动行刷新
*/
PrintWriter pw
= new PrintWriter(osw,true);
/*
* 具备自动行刷新的PW在调用println方法
* 写出一行字符串后会自动flush。
* 注意，调用print方法不会自动刷新
*/
pw.println("随便吧");
pw.println("我已经不知道该写啥了"); System.out.println("写出完毕!");
pw.close();
}
}
PrintWriter_AutoFlush.java
* java.io.BufferedReader
* 缓冲字符输入流，特点:使用它可以按行读取字符串
package day08; import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader; /**
* java.io.BufferedReader
* 缓冲字符输入流，特点:使用它可以按行读取字符串
* @author adminitartor
*
*/
public class BufferedReader_ReadLine {
public static void main(String[] args) throws IOException {
FileInputStream fis
= new FileInputStream(
"src"+File.separator+
"day08"+File.separator+
"BufferedReader_ReadLine.java"
); InputStreamReader isr
= new InputStreamReader(fis); BufferedReader br
= new BufferedReader(isr); /*
* String readLine()
* 按行读取字符串
* 连续读取若干字符，直到遇见换行符为止，
* 然后将换行符之前的内容以一个字符串返回
* 但是返回的字符串中不含有最后的换行符
* 当返回值为NULL时，表示读取到末尾了
*/
String line = null;
while( (line = br.readLine()) != null ){
System.out.println(line);
} br.close();
}
}
BufferedReader_ReadLine.java
* 异常捕获机制中的try-catch
package day08;
/**
* 异常捕获机制中的try-catch
* @author adminitartor
*
*/
public class Exception_Try_Catch {
public static void main(String[] args) {
System.out.println("程序开始了"); try{ String str = "a";
System.out.println(str.length()); System.out.println(str.charAt(0)); System.out.println(Integer.parseInt(str)); //try中出错代码之下的代码都不会被执行
System.out.println("!!!!!!!!"); }catch(NullPointerException e){
System.out.println("出现了空指针!"); }catch(StringIndexOutOfBoundsException e){
System.out.println("字符串下标越界了!");
/*
* 应当有一个好习惯，在最后一个catch中捕获
* Exception.
* 并且多个catch捕获异常时，子类异常在上先
* 捕获，而父类异常在下后捕获。
*/
}catch(Exception e){
System.out.println("反正就是出了个错!");
} System.out.println("程序结束了");
}
}
Exception_Try_Catch.java
* 异常捕获机制中的finally块
package day08;
/**
* 异常捕获机制中的finally块
* finally块只能定义在异常捕获机制的最后
* finally块可以保证其中的代码一定被执行，无论
* try块中的代码是否抛出异常，甚至return。
*
* 通常会将诸如释放资源等一类的代码定义在finally中
* 比如:使用流后的close工作可以放在finally中确保
* 一定可以关闭流。
* @author adminitartor
*
*/
public class Exception_Finally {
public static void main(String[] args) {
System.out.println("程序开始了"); try {
String str = "";
System.out.println(str.length());
return;
} catch (Exception e) {
System.out.println("出错了");
} finally{
System.out.println("finally代码执行了!");
} System.out.println("程序结束了");
}
}
Exception_Finally.java
* finally在流处理中的应用
package day08; import java.io.PrintWriter; /**
* finally在流处理中的应用
* @author adminitartor
*
*/
public class Exception_Finally2 {
public static void main(String[] args) {
PrintWriter pw = null;
try {
pw = new PrintWriter("pw.txt");
pw.println("hello");
} catch (Exception e) {
System.out.println("出错了!");
} finally{
if(pw != null){
pw.close();
}
}
}
}
Exception_Finally2.java
* throw关键字
package day08;
/**
* throw关键字
* 用于将一个异常抛出
* 通常两种情况下会主动抛出异常:
* 1:遇到满足语法要求，但是不满足业务逻辑要求时，
* 可以当作异常对待抛出，通知调用者这是非法操作。
* 2:当遇到了一个异常，但是当前代码不应当解决该
* 异常时，可以将其抛出交给调用者解决。
* @author adminitartor
*
*/
public class Exception_Throw {
public static void main(String[] args) {
Person p = new Person();
try{
/*
* 当调用一个含有throws声明异常抛出
* 的方法时，编译器要求必须有处理该
* 异常的手段，有两种:
* 1:使用try-catch捕获
* 2:在当前方法上继续使用throws声明
* 这个异常的抛出
* 具体用哪个取决于异常应该归谁处理。
*/
p.setAge(10);
}catch(Exception e){
System.out.println("出错了!");
}
System.out.println(p.getAge());
}
}
Exception_Throw.java
* 子类在重写父类含有throws声明异常抛出的方法时
* 子类该方法中throws的重写准则
package day08; import java.awt.AWTException;
import java.io.IOException;
import java.sql.SQLException;
/**
* 子类在重写父类含有throws声明异常抛出的方法时
* 子类该方法中throws的重写准则
* @author adminitartor
*
*/
public class Exception_Override {
public void dosome()
throws IOException,AWTException{ }
} class Son extends Exception_Override{
/**
* 抛出部分异常
*/
// public void dosome() throws IOException{
//
// }
/**
* 不再抛出任何异常
*/
// public void dosome(){
//
// } /**
* 可以抛出父类方法抛出异常的子类型异常
*/
// public void dosome() throws FileNotFoundException{
//
// } /**
* 不可以抛出父类方法抛出异常的父类型异常
*/
// public void dosome() throws Exception{
//
// } /**
* 不可以抛出额外异常
*/
// public void dosome() throws SQLException{
//
// }
}
Exception_Override.java
* Exception中的常用方法
package day08;
/**
* Exception中的常用方法
* @author adminitartor
*
*/
public class Exception_API {
public static void main(String[] args) {
System.out.println("程序开始了");
try {
String str = "abc";
System.out.println(Integer.parseInt(str));
} catch (Exception e) {
//输出错误堆栈信息
e.printStackTrace();
//获取异常消息
String message = e.getMessage();
System.out.println(message);
}
System.out.println("程序结束了");
}
}
Exception_API.java
异常的使用：
IllegalAgeException文件，是生成的，Source → Generate Constructors from Superclass ;
作用：(年龄不合法异常,当指定的年龄范围在0-100以外的数字时会抛出该异常)
Person文件：在set Age 方法这里使用了 IllegalAgeException 自己定义的这个异常；
Exception_Throw文件：使用set Age方法时候，要进行异常处理，并且把鼠标放在
“catch (IllegalAgeException e)”上面，还会有异常提示；
package day08; import java.io.Serializable;
import java.util.List; /**
* 该类用于测试对象流的读写对象操作
* @author adminitartor
*
*/
public class Person implements Serializable{
private String name;
private int age;
private String gender;
/*
* transient关键字
* 被该关键字修饰的属性在进行对象序列化的时候
* 值会被忽略。将无需保存的属性用该关键字修饰
* 可以达到对象序列化时的"瘦身"工作,减少资源
* 开销
* 除此之外，该关键字没有其他任何作用。
*/
private transient List<String> otherInfo; Person(){ } public Person(String name, int age, String gender, List<String> otherInfo) {
super();
this.name = name;
this.age = age;
this.gender = gender;
this.otherInfo = otherInfo;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
/**
* 通常一个方法内部抛出什么异常，方法上就要
* 使用throws声明该异常的抛出，以通知调用者
* 这里可能出现什么问题，要求其处理。
* 只有一类异常抛出时可以不声明，
* 就是RuntimeException及其子类异常
* @param age
* @throws Exception
*/
public void setAge(int age) throws IllegalAgeException{
if(age<0||age>100){
throw new IllegalAgeException("年龄不合法!");
}
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public List<String> getOtherInfo() {
return otherInfo;
}
public void setOtherInfo(List<String> otherInfo) {
this.otherInfo = otherInfo;
} @Override
public String toString() {
return name+","+age+","+gender+","+
otherInfo;
}
}
Person.java
package day08;
/**
* 年龄不合法异常
* 当指定的年龄范围在0-100以外的数字时会抛出
* 该异常
* @author adminitartor
*
*/
public class IllegalAgeException extends Exception{ public IllegalAgeException() {
super();
// TODO Auto-generated constructor stub
} public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
// TODO Auto-generated constructor stub
} public IllegalAgeException(String message, Throwable cause) {
super(message, cause);
// TODO Auto-generated constructor stub
} public IllegalAgeException(String message) {
super(message);
// TODO Auto-generated constructor stub
} public IllegalAgeException(Throwable cause) {
super(cause);
// TODO Auto-generated constructor stub
} }
IllegalAgeException.java
package day08;
/**
* throw关键字
* 用于将一个异常抛出
* 通常两种情况下会主动抛出异常:
* 1:遇到满足语法要求，但是不满足业务逻辑要求时，
* 可以当作异常对待抛出，通知调用者这是非法操作。
* 2:当遇到了一个异常，但是当前代码不应当解决该
* 异常时，可以将其抛出交给调用者解决。
* @author adminitartor
*
*/
public class Exception_Throw {
public static void main(String[] args) {
Person p = new Person(); /*
* 当调用一个含有throws声明异常抛出
* 的方法时，编译器要求必须有处理该
* 异常的手段，有两种:
* 1:使用try-catch捕获
* 2:在当前方法上继续使用throws声明
* 这个异常的抛出
* 具体用哪个取决于异常应该归谁处理。
*/
try {
p.setAge(1000);
} catch (IllegalAgeException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} System.out.println(p.getAge());
}
}
Exception_Throw.java