JAVA day13:File、IO流基本概念、异常捕获
目录
一、File类
课堂练习：
创建并实例化File对象
创建File对象指定文件所在的目录（文件夹）
通过字节输入流（FileInputStream），读取电脑中文件的内容
二、JAVA的I/O流
1.概述
2.l/O流的概念
3.读写数据的方法
4.IO流的分类
字节流
字节流时不要用中文
//数据流写入
//数据流读出
//从一个文本文件中，循环输出该文件中的数据，直至没有数据
图片拷贝的练习
三、异常捕获基础
四、异常
Java异常!
java.lang.ArrayIndexOutOfBoundsException（数组越界）处理方法
java.lang.NullPointerException出现的几种原因：
java.lang.ArithmeticException: / by zero
String str5 =new String("444");比较
五、异常代码实例
定义自己的异常类
测试
测试无用户异常练习
一、File类
File类代表与平台无关的文件和目录。
File能新建、删除、重命名文件和目录，但File 不能访问文件内容本身。如果需要访问文件内容本身，则需要使用输入/输出流。
//实例化一个file
File file1 = new File("F:\\a.txt");//不存在的时候也不会报错，只会和空一样输出0
// F:\a.txt有完整盘符的路径称为绝对路径，会导致文件信息和程序信息不能绑定
// \path1\a.txt没有盘符的路径叫相对路径，当前class所在的文件夹下
File file2 = new File(".\\path1\\a.txt");//\\path1\\a.txt
System.out.println("yingyong:1-12:"+file1.length());
//验证相对路径位置=新建一个看位置
File file3 = new File("\\path2");
//file3.mkdir();//在F盘
System.out.println("新建成功否？"+file3.mkdir());//因为file3.mkdir()返回值是bool所以可以边新建边看成功了没
//运行一遍时建了一个，所以运行第二遍会false，因为已经建立了。重复建立
//若将项目直接复制到E盘也能正常运行！此时path2在E盘，重复建立文件或文件夹都会失败，得先删掉之前的
//所以\\path2是在项目所在盘根目录
//相对路径前加一个点是当下项目里
File file4 = new File("");
System.out.println("获取文件长度："+file2.length());
System.out.println("获取文件名："+file2.getName());
System.out.println("获取文件路径（代码中路径）："+file1.getPath());//（代码中相对则获相对，代码中绝对则或绝对）
System.out.println("获取文件路径（带根盘符的绝对路径）："+file2.getAbsoluteFile());
System.out.println("获取文件路径（带根盘符的绝对路径）："+file3.getAbsoluteFile());
System.out.println("获取文件路径（）："+file2.getAbsolutePath());
System.out.println("获取文件路径（）："+file3.getAbsolutePath());
System.out.println("获取文件父路径（）："+file2.getParent());
System.out.println("获取文件父路径（）："+file3.getParent());
File f1=new File(".\\path1\\a.txt");
File f2=new File(".\\path2");
System.out.println("f1是否存在"+f1.exists());
System.out.println("f2是否存在"+f2.exists());
System.out.println("f1文件新建"+f1.mkdirs());//多级目录
//System.out.println("f2文件夹新建"+f2.mkdir());
//System.out.println("f1文件新建"+f1.createNewFile());//建完外层目录才能用，createNewFile这个方法只能在一层目录下创建文件，不能跳级创建，尽管可以用mkdir(s)创建多层不存在的目录，但是不要直接一个File对象搞定目录和文件都需要创建的情况，可以在已有目录下直接用createNewFile创建文件
System.out.println("f2文件新建"+f2.createNewFile());
System.out.println("f1是否是文件"+f1.isFile());
System.out.println("f2是否是文件"+f2.isFile());
System.out.println("f1是否是文件夹"+f1.isDirectory());
System.out.println("f2是否是文件夹"+f2.isDirectory());
//删除一个文件
System.out.println("删除f1："+f1.delete());
System.out.println("f1是否存在"+f1.exists());
//程序套路
if(f1.exists()){
//不做操作
}else{//新建文件
f1.createNewFile();
System.out.println("f1新建成功");
}
//精简
if(!f1.exists()){//新建文件
f1.createNewFile();
System.out.println("f1新建成功");
}
//遍历文件
File f3=new File(".\\path0");
String[] names = f3.list();
for (int i = 0; i < names.length; i++) {
System.out.println("文件"+i+":"+names[i]);
}
File[] files = f3.listFiles();
for (int i = 0; i < files.length; i++) {
System.out.println("file"+i+":"+files[i]);
}课堂练习：
/**
* 判断文件是否可读/可写
*/
@Test
public void test1(){
File f = new File("C:\\Users\\qin\\Documents\\hello\\三国演义第1回.txt");
// System.out.println(f.canRead()); //文件是否可读
System.out.println(f.canWrite()); //文件是否可写入
}
/**
* 判断文件是否存在
*/
@Test
public void test2(){
File f = new File("C:\\Users\\qin\\Documents\\hello\\三国演义第100回.txt");
System.out.println(f.exists());
}
/**
* 判断File对象是否是文件或文件夹
*/
@Test
public void test3(){
// File f = new File("C:\\Users\\qin\\Documents\\hello\\三国演义第1回.txt");
File f = new File("C:\\Users\\qin\\Documents\\hello");
System.out.println(f.isFile()); //判断File对象是否是一个文件，true=是
System.out.println(f.isDirectory()); //判断File对象是否是一个文件夹，true=是
}
/**
* 创建文件
* @throws IOException
*/
@Test
public void test4() throws IOException{
File f = new File("C:\\Users\\qin\\Documents\\hello\\三国演义第6回.doc");
f.createNewFile();
System.out.println("创建文件成功！");
}
/**
* 删除文件
*/
@Test
public void test5(){
File f = new File("C:\\Users\\qin\\Documents\\hello\\三国演义第6回.doc");
f.delete();
System.out.println("文件删除成功！");
}
/**
* 获得文件（文件夹）的绝对路径（全路径）
*/
@Test
public void test6(){
File f = new File("C:\\Users\\qin\\Documents\\hello\\三国演义第5回.txt");
System.out.println(f.getAbsolutePath());
}
/**
* 创建文件夹
*/
@Test
public void test7(){
File f = new File("C:\\Users\\qin\\Documents\\hello\\java\\world");
f.mkdirs();
System.out.println("文件夹创建成功");
}
/**
* 获取上级目录
*/
@Test
public void test8(){
File f = new File("C:\\Users\\qin\\Documents\\hello\\java\\world");
System.out.println(f.getParent());
}创建并实例化File对象
//创建并实例化File对象
File f = new File("C:\\Users\\qin\\Documents\\hello");
System.out.print("请输入要查找的文件名：");
String name = new Scanner(System.in).next();
//listFiles()：获得文件夹中所有的文件及文件夹
for(File fi : f.listFiles()){
if(name.equals(fi.getName())){ //getName()：获得文件的名称
System.out.println("找到了你要查找的文件，文件名是："+fi.getName());
}
}创建File对象指定文件所在的目录（文件夹）
//创建File对象指定文件所在的目录（文件夹）
// File f = new File("C:"+File.separator+"Users\\qin\\Documents\\hello");
File f = new File("C:\\Users\\qin\\Documents\\hello");
File[] fs = f.listFiles(); //获得当前目录（文件夹）下所有的文件及文件夹（File对象）
//遍历数组输出所有文件
for(File fi : fs){
String name = fi.getName(); //获取文件名
if("txt".equals(IOUtils.getSuffix(name))){ //判断如果后缀名是txt
System.out.println(name);
}
}通过字节输入流（FileInputStream），读取电脑中文件的内容
/**
* 通过字节输入流（FileInputStream），读取电脑中文件的内容
* @throws IOException
*/
@Test
public void test1() throws IOException{
//创建FileInputStream对象，作用是：以字节为单位读取文件的内容
FileInputStream fis = new FileInputStream("C:\\Users\\qin\\Documents\\hello\\三国演义第1回.txt");
//读取文件内容read()：如果返回值不是-1，就说明还存在未读的字节
int i=0;
String sum = "";
while((i=fis.read()) != -1){
sum += (char)i;
}
System.out.println(sum);
fis.close(); //关流
}
@Test
public void test2() throws IOException{
//创建FileOutputStream对象，作用是：以字节为单位向文件中写入内容
FileOutputStream fos = new FileOutputStream("C:\\Users\\qin\\Documents\\hello\\三国演义第2回.txt");
//向文件写入内容
fos.write("Hello Java".getBytes()); //将字符串转换成字节数组写入到文件
fos.close(); //关流
System.out.println("文件写入成功！");
}
/**
* 文件拷贝（复制粘贴）
* @throws IOException
*/
@Test
public void test3() throws IOException {
//通过FileInputStream读取图片内容，以字节为单位
FileInputStream fis = new FileInputStream("C:\\Users\\qin\\Documents\\hello\\IMG_9001_1.jpg");
//通过FileOutputStream向文件中写入内容（拷贝），以字节为单位
FileOutputStream fos = new FileOutputStream("C:\\Users\\qin\\Documents\\hello\\IMG_9001_2.jpg");
//拷贝的思路：边读边写
int b;
while((b = fis.read()) != -1){ //读取字节
fos.write(b); //写入字节
}
//关流的顺序：先用后关，后用先关
fos.close();
fis.close();
System.out.println("图片拷贝完成！");
}二、JAVA的I/O流
1.概述
·输入：读取外部数据（磁盘、光盘等存储设备的数据)到程序(内存)中。
·输出：将程序(内存）数据输出到磁盘、光盘等存储设备中
Java的IO流主要包括输入、输出两种IO流，
每种输入、输出流又可分为字节流和字符流两大类:
字节流以字节为单位来处理输入、输出操作
字符流以字符为单位来处理输入、输出操作
| bit |
二进制位 | 0/1 |
| Byte | 字节 | 10101010 |
字符编码方式决定字符大小1字符=2字节=16个二进制位
2.l/O流的概念
IO流(Input/Output)
·在Java中将信息的输入与输出过程抽象为IO流·输入是指数据流入程序
·输出是指数据从程序流出
·一个流就是一个从数据源向目的地的数据序列
·I/O流类一旦被创建就会自动打开
通过调用close方法,可以显式关闭任何一个流,如果流对象不再被引用.Java的垃圾回收机制也会隐式地关
3.读写数据的方法
不论数据从哪来，到哪去，也不论数据本身是何类型，读写数据的方法大体上都是一样的:
读：打开一个流->读信息->关闭流
写：打开一个流->写信息->关闭流
4.IO流的分类
·按流向分:
输入流
输出流
·按处理的单位:
字节流（8位的字节)
字符流（16位的字节)
·按流的功能
节点流:可以从或向一个特定的地方(节点)读写数据。如FileReader。
处理流（用来包装节点流)︰是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流
字节流
字节流时不要用中文
read(),是每次读取一个字节,但中文一个字符占2个字节(GBK)或者3个字节(UTF-8) * 所以它读的时候,只读到了一半就没了,所以会产生类似于乱码的符号
只有字节数组的长度 >= 文件的字节个数,才一定不会出现乱码
但是使用IO流读取数据，写到文本文件，你读取一个字节，我就写一个字节，中间没有做任何的转换，他会自己转换，只是过程中没法再代码中对一个汉字操作。
//数据流写入
File file = new File(".\\path0\\a.txt");
//文件输出流构造方式：可以传参数，也可以直接传地址
FileOutputStream fos1 = new FileOutputStream(file);
FileOutputStream fos2 = new FileOutputStream(".\\path0\\a.txt");
//字节 16进制-》10进制：ASCII码对照表里十进制0
//fos1.write(1000);//?
//fos1.write(1);//一个方块
//fos1.write(10000000);//€ 属性里大小等于1字节
//fos1.write(49);//1
//fos1.write(57);//9
//中文输入
byte[] a = "你好，淳淳和宇宇".getBytes();
System.out.println("字节数组的长度：" + a.length);//utf8 一个汉字用三字节表示;取决于编码的方式
fos1.write(a);
//字符截取
byte[] b = "abcdef".getBytes();
System.out.println("字节数组的长度：" + b.length);//utf8 一个汉字用三字节表示;取决于编码的方式
fos1.write(b,2,2);//截取的数据，起始点，截取长度，从”abcde“的第二个索引开始，长度为2，就是”cd“.
//换行符
byte[] c="淳淳\r\n宇宇".getBytes();//\r\n表示回车+换行,要一起用，加一起2字节
System.out.println("字节数组的长度：" + c.length);
fos1.write(c);
fos1.write(49);
//空格也算1字节，也能写入
byte[] d="淳淳 宇宇".getBytes();//\r\n表示回车+换行,要一起用，加一起2字节
System.out.println("字节数组的长度：" + d.length);
fos1.write(d);
//对流所有的操作结束后一定要关流
fos1.close();//数据流读出
File file = new File(".\\path0\\a.txt");
//文件数据流读出构造方式：可以传参数，也可以直接传地址
FileInputStream fis1 = new FileInputStream(file);
FileInputStream fis2 = new FileInputStream(".\\path0\\a.txt");
//一个汉字读三次，但=2？
/*int data1=fis1.read();
System.out.println("1.读出来的数据为："+data1);
int data2=fis1.read();
System.out.println("2.读出来的数据为："+data2);
int data3=fis1.read();
System.out.println("3.读出来的数据为："+data3);*/
//缓存的概念
byte[] cache=new byte[4];
int datal = fis1.read(cache);//读出的小于[]里的则有几个读几个，多余[]里的，只读括号里的。
System.out.println("读出来的数据为："+datal);
for (int i = 0; i < cache.length; i++) {
System.out.println(i+"读出来的数据为："+cache[i]);
}
//对流所有的操作结束后一定要关流
fis1.close();
//从一个文本文件中，循环输出该文件中的数据，直至没有数据
File file = new File(".\\path0\\a.txt");
//文件数据流读出构造方式：可以传参数，也可以直接传地址
FileInputStream fis1 = new FileInputStream(file);
FileInputStream fis2 = new FileInputStream(".\\path0\\a.txt");
//循环读出
/*int lo= (int) file.length();//文件长度
byte[] cache=new byte[lo+3];//数组用来存文件
int data= fis1.read(cache);
System.out.println("读出来的数据为："+data);
for (int i = 0; i < cache.length; i++) {
System.out.println(i+"读出来的数据为："+cache[i]);
}*/
int data = 0;//读取到数据流中第一位的真实字节数据
/*for (int i = 0; i < 30; i++) {//可验证-1=多的、空的
data = fis1.read();
System.out.println(data);
}*/
while((data=fis1.read()) != -1){//读取当前文件中的所有数据
System.out.println(data);
}
//读图片大小
File file2 = new File(".\\yc.png");
long data_length = file2.length();
System.out.println("图片大小="+data_length);
//对流所有的操作结束后一定要关流
fis1.close();
图片拷贝的练习
File file = new File(".\\yc.png");
File file1 = new File(".\\yc_copy2.png");
if (!file1.exists()){
file1.createNewFile();
}
//文件读、写构造数据流
FileInputStream fis = new FileInputStream(file);//读
FileOutputStream fos = new FileOutputStream(file1);//写
//循环读
byte[] cache=new byte[1024];//1KB数组用来存文件
int temp= 0;
//fis.read()!=-1 表示是否读取完整个文件或者是否读取完最后一个字符
while ((temp=fis.read(cache))!=-1) {//读1KB写1KB
fos.write(cache,0,temp);//每次都从0开始写了=覆盖写法，需要改成追加写法
}
//对流所有的操作结束后一定要关流
//先开后关，后开先关
fos.close();
fis.close();
三、异常捕获基础
//try--catch--finally:异常捕获（又叫异常处理）
//1、如果try语句块中的内容真的出现了异常，程序将执行catch语句块的内容
//2、如果try语句块中的内容没有出现异常，程序将不会执行catch语句块的内容，继续往下执行
//3、如果异常处理语句中出现finally语句块，无论是否捕获到异常finally语句一定会被执行
//4、一个try语句看可以跟随多个catch语句看，来捕获处理多种类型的异常
String[] strArr = {"吉林", "长春", "四平"};
Student stu = null;
try {
System.out.println(strArr[3]); //数组下标越界异常，ArrayIndexOutOfBoundsException
System.out.println(stu.getName()); //空指针异常，NullPointerException
} catch (ArrayIndexOutOfBoundsException e) { //只处理ArrayIndexOutOfBoundsException异常只有当异常被捕获的时候，才会执行
e.printStackTrace(); //打印出捕获到的异常的详细信息
// System.out.println("果然你的代码错了，我已经捕获到了，哈哈哈");
System.out.println(strArr[2]);
} catch (NullPointerException e) { //只处理NullPointerException异常
e.printStackTrace(); //打印出捕获到的异常的详细信息
stu = new Student();
stu.setName("张三");
System.out.println(stu.getName());
} finally { //无论是否出现异常，finally语句快必然执行
System.out.println("我是finally，我必须执行");
}
System.out.println("哈哈哈，大傻瓜");private static void t() throws Exception {
try {
Student stu = null;
System.out.println(stu.getName());
} catch (Exception e) {
throw e;
}
}四、异常
Java异常!
·任何一种程序设计语言设计的程序在运行时都有可能出现错误，
例如除数为O，数组下标越界，要读写的文件不存在等等。
·捕获错误最理想的是在编译期间，但有的错误只有在运行时才会发生。
·对于这些错误，一般有两种解决方法:
遇到错误就终止程序的运行。
由程序员在编写程序时，就考虑到错误的检测、错误消息的提示，以及错误的处理。
- 异常:在Java语言中,将程序执行中发生的不正常情况称为“异常”。
彩
- Java中的异常用于处理非预期的情况，如文件没找到，网络错误，非法的参数
Java程序运行过程中所发生的异常事件可分为两类:
- Error:JVM系统内部错误、资源耗尽等严重情况
- Exception:其它因编程错误或偶然的外在因素导致的一
般性向题，例如:
·空指针访问
·试图读取不存在的文件
·网络连接中断
java.lang.ArrayIndexOutOfBoundsException（数组越界）处理方法
当你使用不合法的索引访问数组时会报数组越界这种错误，数组arr的合法错误范围是[0, arr.length-1];当你访问这之外的索引时会报这个错。
你的class叫什么就把Nullref改成什么，比如：
java.lang.NullPointerException出现的几种原因：
1、字符串变量未初始化
2、接口类型的对象没有用具体的类初始化，比如：
Map map // 会报错
Map map = new Map(); //则不会报错了
3、当一个对象的值为空时，你没有判断为空的情况。
4、字符串与文字的比较，文字可以是一个字符串或Enum的元素，如下会出现异常
String str = null;
if（str.equals（“Test”））{
//这里的代码将不会被触发，因为会抛出java.lang.NullPointerException异常。
}
5、优先使用String.valueOf（）方法代替toString（）
当程序代码需要对象的字符串表示形式时，请避免使用该对象的toString方法。如果你的对象的引用等于null，NullPointerException则会抛出，使用静态String.valueOf方法，该方法不会抛出任何异常并打印"null"
6、class被声明了类型， 默认 class = null; 这样在调用class中方法的时候系统只能给你个空指针异常， 给其实例化就好了：class = new Class();
7、返回null，方法的返回值不要定义成为一般的类型，而是用数组。这样如果想要返回null的时候就能避免许多不必要的NullPointerException
java.lang.ArithmeticException: / by zero
当我们定义的被除数为整型时（short、int、long）会抛出此异常， 被除数为整型时不可为零。
String str5 =new String("444");比较
System.out. println("第二个判断:"+(int3 == int4));
String str3 ="333";
String str4 ="333";
System.out. println("第二个判断:"+ (str3==str4));
String str5 =new String("444");
String str6 =new String("444");
System.out. println("第三个判断:"+ (str5==str6));
因为相当于地址比较：
System.out. println("第四个判断:"+ (str5.equals(str6)));值相同；地址不同
五、异常代码实例
package Demo01;
public class Demo01 {
public static void main(String[] args) {
int int3 = 333;
int int4 = 333;
System.out. println("第二个判断:"+(int3 == int4));
String str3 ="333";
String str4 ="333";
System.out. println("第二个判断:"+ (str3==str4));
String str5 =new String("444");
String str6 =new String("444");
System.out. println("第三个判断:"+ (str5==str6));
System.out. println("第四个判断:"+ (str5.equals(str6)));
}
}
package Demo01;
//异常
public class Demo02 {
public static void main(String[] args) {
CeShi1();//有可能有异常的语句，但是相当于局部变量了，得把这个在try外初始化
}
private static void CeShi1(){
CeShi2();
}
private static void CeShi2(){
CeShi3();
}
private static void CeShi3(){
int [] arr = {2,3,4,5};
int index=5;
int result = getElement(arr,index);
System.out.println("查找结果为："+result);
}
/**
* 获取指定int型数组中的元素
* @param arr 需要进行元素获取的数组
* @param index 想要获取元素在数组中的位置
* @return 获取到的元素
*/
protected static int getElement(int[] arr,int index){
//1、index非负整数
//2、index的大小不应该超出数组长度
//if(index<0||(index>arr.length-1)){//把所有index出现问题的操作放在这里
// throw new ArrayIndexOutOfBoundsException("抛出：数组越界！！！");
//}
//System.out.println("抛出异常的时候：没有运行");
int element = -1;
try{//执行具有异常情况的代码 抓住异常
element = arr[index-1];//有可能有异常的语句，但是相当于局部变量了，得把这个在try外初始化
}catch(/**需要捕获的异常类型**/ArrayIndexOutOfBoundsException exp){
System.out.println("出现越界问题！");
}
return element;
}
}
package Demo01;
//异常
public class Demo03 {
public static void main(String[] args) {
try{//执行具有异常情况的代码 抓住异常
CeShi1();//有可能有异常的语句
}catch(Exception exp){
System.out.println("捕获到ceshi1的异常");
}
}
private static void CeShi1() throws Exception{//抛出异常
System.out.println("你好");
throw new Exception("1111");//直接抛个异常d得有throws Exception对其进行捕获或声明以便抛出
}
}
package Demo01;
//异常
public class Demo04 {
public static void main(String[] args) {
try{//执行具有异常情况的代码 抓住异常
CeShi1();//有可能有异常的语句,当有异常在多个方法中传递时每个方法都得给throws Exception对其进行捕获或声明以便抛出
}catch(Exception exp){
System.out.println("捕获到ceshi1的异常");
}
}
private static void CeShi1() throws Exception{//抛出异常
CeShi2();
}
private static void CeShi2()throws Exception{
CeShi3();
}
private static void CeShi3() throws Exception{
System.out.println("你好");
throw new Exception("1111");//直接抛个异常d得有throws Exception对其进行捕获或声明以便抛出
}
}
package Demo01;
//异常
public class Demo05 {
public static void main(String[] args) {
try{//执行具有异常情况的代码 抓住异常
CeShi1();//有可能有异常的语句,当有异常在多个方法中传递时每个方法都得给throws Exception对其进行捕获或声明以便抛出
}catch(Exception exp){
System.out.println("捕获到ceshi的异常");
}
}
private static void CeShi1() throws Exception{//抛出异常
CeShi2();
}
private static void CeShi2()throws Exception{//变灰说明它没用上，当在ceshi2里加一个没被抛出的异常，就会不灰
try{
CeShi3();
}catch (Exception exp){
System.out.println("异常被测试2抛出");
}
throw new Exception("测试2中的异常");
}
private static void CeShi3() throws Exception{
System.out.println("测试3执行");
throw new Exception("测试3中的异常");//直接抛个异常d得有throws Exception对其进行捕获或声明以便抛出
}
}
package Demo01;
import java.io.FileNotFoundException;
//异常
public class Demo06 {
public static void main(String[] args) {
try {//执行具有异常情况的代码 抓住异常
CeShi1();//有可能有异常的语句,当有异常在多个方法中传递时每个方法都得给throws Exception对其进行捕获或声明以便抛出
} catch (Exception exp) {
System.out.println("捕获到ceshi的异常");
}
}
private static void CeShi1() throws Exception {//抛出异常
CeShi2();
}
private static void CeShi2() throws Exception {//变灰说明它没用上，当在ceshi2里加一个没被抛出的异常，就会不灰
try {
control=1;
CeShi3();
} catch (ArrayIndexOutOfBoundsException exp) {//Exception exp异常包括FileNotFoundException异常，所以当有捕获Exception时再写他的子类就会显示已捕获
System.out.println("捕获到ArrayIndexOutOfBoundsException异常");
} catch (FileNotFoundException exp2) {
System.out.println("捕获到FileNotFoundException异常");
}
}
static int control = 0;
private static void CeShi3() throws Exception {
System.out.println("测试3执行");
if (control == 0) {
throw new ArrayIndexOutOfBoundsException("测试3中的异常");//直接抛个异常d得有throws Exception对其进行捕获或声明以便抛出
}else {
throw new FileNotFoundException("2222");
}
}
}
package Demo01;
import java.io.FileNotFoundException;
import java.io.IOException;
//异常
public class Demo07{
public static void main(String[] args) throws Exception{
try {
CeShi1();
CeShi2();
CeShi3();
}catch (IOException exp1) {
System.out.println("捕获到IO的异常，具体显示信息为:"+exp1);
}/*catch (FileNotFoundException exp2) {//FileNotFoundException是IOException的子类
System.out.println("捕获到文件没有找到的异常");
}*/catch (ArrayIndexOutOfBoundsException exp3) {
System.out.println("捕获到数组越界的异常，具体显示信息为:"+exp3);
/*
对于try里面发生的异常，他会根据发生的异常和catch里面的进行匹配(怎么匹配？按照catch块从上往下匹配)，
当它匹配某一个catch块的时候，他就直接进入到这个catch块里面去了，
后面在再有catch块的话，它不做任何处理，直接跳过去，全部忽略掉。
如果有匹配的catch，它就会忽略掉这个catch后面所有的catch。
*/
}
System.out.println("结束");
}
/*
代码执行的顺序：
* 1.try内的代码从出现异常的那一行开始，中断执行
* 2.执行对应的catch块内的代码
* 3.继续执行try catch结构之后的代码
*注意点：
* 1.如果catch内的异常类存在子父类的关系，那么子类应该在前，父类在后
* 2。如果最后中有返回语句，那么最后返回的结果肯定以最终中的返回值为准
* 3。如果最后语句中有回报，那么没有被处理的异常将会被吞掉
*重写的注意点：
* 1.儿子不能比父亲的本事大
* 2.儿子要比父亲开放
* 3.儿子不能比父亲惹更大的麻烦（子类的异常的类型不能是父类的异常的父类型）
*/
private static void CeShi1()throws Exception{
throw new IOException("我是IO异常");
}
private static void CeShi2()throws Exception{
throw new FileNotFoundException("我是文件没有找到的异常");
}
private static void CeShi3()throws ArrayIndexOutOfBoundsException{
throw new ArrayIndexOutOfBoundsException("我是数组越界的异常");
}
}
package Demo01;
import java.io.FileNotFoundException;
import java.io.IOException;
//异常
public class Demo08 {
static int con=1;
public static void main(String[] args) throws Exception{
try {
if(con==0){
CeShi1();
}else{
CeShi2();
}
//CeShi3();
}catch (IOException exp1) {
System.out.println("捕获到IO的异常，具体显示信息为:"+exp1);
}/*catch (FileNotFoundException exp2) {//FileNotFoundException是IOException的子类
System.out.println("捕获到文件没有找到的异常");
}*/catch (ArrayIndexOutOfBoundsException exp3) {
System.out.println("捕获到数组越界的异常，具体显示信息为:"+exp3);
}
}
private static void CeShi1()throws IOException{//throws可以粗狂的捕获
throw new IOException("我是IO异常");
}
private static void CeShi2()throws IOException{//throws FileNotFoundException或throws IOException都行，输出也都一样是java.io.FileNotFoundException:
//FileNotFoundException是IOException的子类
throw new FileNotFoundException("我是文件没有找到的异常");
}
private static void CeShi3()throws ArrayIndexOutOfBoundsException{
throw new ArrayIndexOutOfBoundsException("我是数组越界的异常");
}
}
package Demo01;
import java.io.FileNotFoundException;
import java.io.IOException;
//测试RuntimeException和它的两个子类NullPointerException、ArrayIndexOutOfBoundsException同时出现
//答：谁先throw执行谁
//原理上，当出现异常的时候，代码会跳转到捕获异常的代码段，也就是catch中去，try语句接下来的代码是不会继续执行的，所以接下来的异常就不会进行捕获
public class Demo09 {
static int con=1;
public static void main(String[] args) throws Exception{
try {
/*CeShi1();
CeShi2();
CeShi3();*/
System.out.println("无异常");
}catch (ArrayIndexOutOfBoundsException exp) {
System.out.println("捕获到异常的具体显示信息为:"+exp);
}catch(NullPointerException exp2){
System.out.println("捕获到异常的具体显示信息为:"+exp2);
}
catch(RuntimeException exp3){
System.out.println("捕获到异常的具体显示信息为:"+exp3);
}finally {//无论是否异常都会执行的语句
System.out.println("异常结束");
}
}
private static void CeShi1()throws RuntimeException{
throw new NullPointerException("我是空指针的异常");
}
private static void CeShi2()throws ArrayIndexOutOfBoundsException{
throw new ArrayIndexOutOfBoundsException("我是数组越界的异常");
}
private static void CeShi3()throws RuntimeException{
throw new RuntimeException("我是运行期间异常");
}
}
package Demo01;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Demo10 {
static int con=1;
public static void main(String[] args) throws Exception{
try {
//CeShi1();
//CeShi2();
//CeShi3();
}catch (ArrayIndexOutOfBoundsException exp) {
System.out.println("捕获到异常的具体显示信息为:"+exp);
}catch(NullPointerException exp2){
System.out.println("捕获到异常的具体显示信息为:"+exp2);
}catch(Exception exp3){//IOException exp3出错了得改大喽
System.out.println("捕获到异常的具体显示信息为:"+exp3);
}finally {
System.out.println("异常结束");
}
}
private static void CeShi1()throws RuntimeException{
throw new NullPointerException("我是空指针的异常");
}
private static void CeShi2()throws ArrayIndexOutOfBoundsException{
throw new ArrayIndexOutOfBoundsException("我是数组越界的异常");
}
private static void CeShi3()throws RuntimeException{
throw new RuntimeException("我是运行期间异常");
}
}
定义自己的异常类
package Demo01;
//定义自己的异常类
public class WycException extends Exception{//继承
//构造函数
public WycException(){
super();//super（参数）：调用父类中的某一个构造函数（应该为构造函数中的第一条语句）。
}
public WycException(String msg){
super(msg);
}
}
测试
package Demo01;
public class ceshiWyc {
public static void main(String[] args) throws Exception{
try {
CeShi1();
}catch (WycException exp) {
System.out.println("捕获到异常的具体显示信息为:"+exp);
}finally {
System.out.println("异常结束");
}
}
private static void CeShi1()throws Exception{
throw new WycException("我是自定义的异常");
}
}
测试无用户异常练习
//测试类
package Demo01;
public class ceshiUser {
static String[] data_name={"淳淳","宇宇","琪琪"};
static String[] data_secret={"0523","1022","1230"};
static String name = "";
static String secret = "";
public static void main(String[] args) throws Exception{
//name = "淳淳";
//secret = "1022";
//用户名及密码校验
//1.用户名及密码不匹配
//2.无该用户
try{
CheckIput("淳淳","1022");
}catch (NoUserException exp1){
System.out.println("无该用户"+exp1);
}
catch (SecretErrorException exp2){
System.out.println("用户名及密码不匹配"+exp2);
}
}
private static void CheckIput(String name,String secret)throws NoUserException,SecretErrorException{
boolean have_user = false;
for (int i = 0; i < data_name.length; i++) {
if (data_name[i].equals(name)){
have_user=true;
if (secret==data_secret[i]){
System.out.println("登陆成功");
}else {
throw new SecretErrorException("用户名及密码不匹配的异常");
}
}
}
if(!have_user){
throw new NoUserException("无该用户的异常");
}
}
}
//异常类
package Demo01;
public class NoUserException extends Exception{
public NoUserException(){
super();
}
public NoUserException(String msg){
super(msg);
}
}
package Demo01;
public class SecretErrorException extends Exception{
public SecretErrorException(){
super();
}
public SecretErrorException(String msg){
super(msg);
}
}