Exception和File

异常分为

编译时期异常:只要不是RuntimeException中异常都属于编译时期异常

运行时期异常:RuntimeException:可能由于不严谨导致的,eg:空指针异常

如:

public class ExceptionText1 {

public static void main(String[] args) {

    int a=10;

    int b=0;

    System.out.println(a/b);

    //ArithmeticException异常除数不能为0

}

}

 

处理异常的方式:

try…catch…finally:捕获异常

throws:抛出异常

处理异常:try…catch…finally

变形格式:try…catch     try…catch…catch    try…finally…()

try{    //可能出现问题的代码

}catch(异常类名 变量名){

    输出语句处理

}

Eg: public class ExceptionText2 {

public static void main(String[] args) {

    int a=10;

    int b=0;

    int []arr={1,2,3};

    try{

    System.out.println(a/b);

    }catch(Exception e){

       System.out.println("除数不能为0");;

    }

     System.out.println("over");

}

}

 

方式1:针对多个异常分别的try…catch:在实际开发中,较麻烦.

2.try{

     //可能出现问题的语句

}catch(异常类1  变量名){

     //输出语句处理

}catch(异常类2 变量名){

     //输出语句处理

}

public class Exception3 {

public static void main(String[] args) {

    int a=10;

    int b=0;

    int []arr={1,2,3};

    try{

       System.out.println(arr[3]);

       System.out.println(a/b);

    }catch(ArrayIndexOutOfBoundsException e){

       System.out.println("您访问了数组中不存在的索引");

    }catch(ArithmeticException e){

       System.out.println("除数不能玩为0");

}

    System.out.println("结束");

}

}

输出结果:

您访问了数组中不存在的索引

结束

当遇到第一个catch条件时 就会结束try…catch语句

 

 

还可以:  针对多个异常分别的进行try...catch

 

Jdk1.7后 出现的新的处理方式

try{

        //可能会出现的代码

        //

}catch(异常类名1|异常类名2…变量名){

       处理异常

}

1.针对多个异常类名之间时平级关系.    异常的等级需要一直.

2.这种格式在开发,虽有多个异常,但是针对具体的异常需要给出具体的处理

public class ExceptionText4 {

public static void main(String[] args) {

           int a = 10 ;

           int b = 0 ;

           int[] arr = {1,2,3} ;

           try{

              System.out.println(a/b);

              System.out.println(arr[3]);

           }catch(ArithmeticException |ArrayIndexOutOfBoundsException  e){

             System.out.println("程序出问题了...");

           }

           System.out.println("over");

        }

    }

开发中:应该讲异常具体化.

 

编译异常:java必须给出处理,否则编译不通过.

运行时期异常:可以处理,也可以像编译时期处理

public class ExceptionDemo1 {

public static void main(String[] args) {

    int a=10;

    int b=0;

    if(b!=0){

       System.out.println(a/b);

    }

    System.out.println("没有异常");

     method();

    System.out.println("下来IO流");

}

private static void method(){

    String s = "2017-11-21" ;

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:");

       Date d=new Date();

       try {

           d = sdf.parse(s);

           System.out.println("d:"+d);

       } catch (ParseException e) {

           System.out.println("解析出问题了...");

       }  

}

}

因为解析的结果格式不匹配,因此会出现catch里面的结果.

输出结果:

没有异常

解析出问题了...

下来IO流

 

异常处理的第二种方式:

throws:抛出异常

在方法上声明异常,(尽量不要在main()方法中抛出异常,方法中可以抛出)

throws和throw的区别:

 throws:抛出  后面跟异常类名,可以跟多个异常类名,中间用逗号隔开

throws在方法声明中抛出,表示异常的一种可能性

throws表示抛出异常的一种可能性.

throw:抛出 后面跟的异常对象,只能跟具体的一个异常对象

throw在方法中语句抛出,表示异常的绝对性

 

 throws要比throw用的比较多

try...catch...又比throws用的比较多

练习:

public class ExceptionText5 {

public static void main(String[] args) throws ParseException{

           method();

           try {

              method2();

           } catch (Exception e) {

           System.out.println("解析格式不正确");

           }

       }

       private static void method2() throws Exception {

           int a = 10 ;

           int b = 0 ;

           if(b==0){

              System.out.println(a/b);

              throw new ArithmeticException() ;//异常对象

           }else{

              System.out.println("没问题");

           }

       }

       private static void method() throws ParseException {

           String str = "2017-11-19" ;

           SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd") ;

           Date d = sdf.parse(str) ;

           System.out.println(d);

       }

    }

 

捕获异常的格式:try..catch..finally 

使用:finally的代码一定会执行.  只有当jvm退:System.exit(0). Finally里代码才不会执行

Finally经常用在IO流中,用来释放资源.

public class Exceptiontext6 {

public static void main(String[] args) {

       String s = "2017-11-23" ;

       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd:MM") ;

        Date d;

       try {

           d = sdf.parse(s) ;

           System.out.println("d:"+d);

       } catch (ParseException e) {

           System.out.println("解析出问题了...");

       }finally{

           System.out.println("fianlly的代码");

       }

    }

}

 

 

final,finalize,和finally的区别?

Final可以修饰类,方法,变量    表示终态的意思.

Final修饰的类不能被继承,方法不能被重写,变量不能被改变.变量成为常量.

Finalize:通过gc立即回收器回收不用的对象或者是变量, System.gc().实质调用了finalize()方法.

finally:不能单独使用,和try...catch...finally中一块使用finally中的代码一定会执行

 

sleep()和stop()的区别?

Sleep()是线程休眠,处于可唤醒状态.设置一个唤醒时间.在时间后.继续运行

Stop()是线程终止运行,开发中不建议使用

 

练习题:  :看程序写结果

public class FinallyDemo2 {

                          publicstatic void main(String[] args) {

                                   System.out.println(getInt());

                               }

                                    private static int getInt() {

                                   inta = 10 ;

                                   try{

                                    System.out.println(a/0);

                                    a = 20 ;

                                   }catch(ArithmeticExceptione){

                                            a= 30 ;

                                            returna ;

                                   }finally{

                                            a= 40 ;    

                                   }

                                   returna;

                               }

}

输出结果:30

问题:如果catch里面有return语句,那么finally中的代码还会执行吗?如果可以,是在return前执行还是return后执行?

会执行;并且在return 前执行!返回的为catch语句里面的值

 

自定义异常类:在开发中需要使用自己定义的异常类.

Eg:

public class MyException extends Exception{

public MyException(){

}

public MyException(String message){

super(message) ;

}

}

 

异常需要注意的:子类在重写父类方法时: 方法有抛出异常,那么子类重写的这个方法,不能够比父类中该方法异常大,最多一致

子类继承父类,要重写父类中的方法的时候,如果本身父类中该方法没有异常,那么在子类中重写该方法的时候,不能throws异常,只能try…catch异常

 

File流

用来描述文件或者目录(文件夹)的路径的抽象表现形式

public File(Stringpathname):给定路径以字符串来表示当前文件或者文件夹

public File(Stringparent,String child)根据 parent 路径名字符串和 child 路径名字符串创建一个新 File对象

public File(Fileparent, String child)根据 parent象路径名和child路径名字符串创建一个新File实例

eg:

public class FileDemo {

public static void main(String[] args) {

    File file=new File("E:\\demo\\a.txt");//第一种

    System.out.println(file);

    File file2 = new File("E:\\demo", "a.txt") ;

    System.out.println(file2);    //第二种

    File file3 = new File("E:\\demo") ;

    File file4 = new File(file3, "a.txt") ;

    System.out.println(file4);    //第三种

}

}

File对象创建文件或文件夹 创建的方法:

Public boolean  mkdir()创建此抽象路径名指定的目录(文件夹).如果有不会创建.

public boolean createNewFile():创建文件的,如果已经有这个文件了,不在创建,编译时需要抛出IOException.

public boolean mkdirs()创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。(创建文件夹,文件夹不存在,才开始创建)

public class FileClassText2 {

public static void main(String[] args) throws IOException {

    File file=new File("E:\\demo"); //创建文件夹成功

    System.out.println("mkdir:"+file.mkdir());

    File file2=new File("E:\\demo\\a.txt") ;

    System.out.println("createNewFile:"+file2.createNewFile());

    //使用creatnewFile需要抛出异常  创建一个空文件

    File file3=new File("E:\\demo\\b.txt");

    System.out.println("createNewFile:"+file3.createNewFile());

     //在创建文件前需要保证有文件夹

    //使用File对象封装

    File file4 = new File("E:\\aaa\\bbb\\ccc\\ddd") ;

    System.out.println("mkdirs:"+file4.mkdirs());

    //不存在父母录时:自动生成下面的文件夹

    File file5 = new File("a.txt") ;

    System.out.println("createNewFile:"+file5.createNewFile());

    //没有盘符:文件在当前项目下创建

}

}

 

删除文件或者文件夹:

Public boolean delete():删除此抽象路径表示的文件或目录.

不能删除带有文件或者文件夹的  要一个个删除.

public class FIleDelete {

public static void main(String[] args) {

    //在当前项目下创建

    File file = new File("aaa\\bbb\\ccc") ;

    System.out.println("mkdirs:"+file.mkdirs());

    File file2 = new File("a.txt") ;

    System.out.println("delete:"+file2.delete());

    //删除aaa\\bbb\\ccc

    File file3 = new File("aaa\\bbb\\ccc") ;

    System.out.println("delte:"+file3.delete());

    //会删除最后的一个文件夹   要删除需要一个个删除

}

}

 

File重命名功能:public Boolean renameTo(File dest)重新命名此抽象路径名的文件

 

File 新建对象("名称)       File 新建对象(”新名称”)    

第一个对象.renameTo(第二个对象);    //重命名成功

复制到另一个目录下 :相同     第二个对象前面增加地址

 

File的判断功能

public booleanisDirectory():判断是否是文件夹            

public booleanisFile():判断是否是一个标准文件          

public booleancanRead():判断是否可读

public booleancanWriter():判断是否可写

public booleanisHidden():判断是否是隐藏文件

public boolean isAbsolute():判断次路径名是否是绝对路径                                          

 

File的获取功能:

public File getAbsolutePath():获取当前文件或者文件夹绝对路径

public String getPath():获取相对路径

public long length()返回由此抽象路径名表示的文件的长度

public long lastModified()返回此抽象路径名表示的文件最后一次被修改的时间

public String getName():获取名称

 

File的高级功能:

public String[]list():返回的对象是一个字符串数组,当前盘符下所有文件以及文件夹的字符串名称

public File[] listFiles():返回对象是一个File数组,当前哪个盘下的所有的文件以及文件夹的File数组

 

public class FileDemo4 {

public static void main(String[] args) {

 File file=new File("D:\\");

   String[]strArr=file.list();

   for(String s:strArr){

       System.out.println(s);

    }//第一种  最好加上非空判断

   System.out.println("---");

    File[] fileArray = file.listFiles() ;

    for(File a :fileArray){

       System.out.println(a.getName());

    }

}

}

 

练习:检验输出D盘结尾为”.txt”的文件输出.

public class FileDemo5 {

public static void main(String[] args) {

       File st = new File("D:\\");

       File[]strArr=st.listFiles();

       if(strArr!=null){

       for(File s:strArr){

           if(s.isFile()){

              if(s.getName().endsWith(".txt")){

                  System.out.println(s.getName());

             }

           }

       }

       }

}

}

 

判断是否有后缀为”---”输出

一种方法:封装  listFiles获取所有   遍历判断  endsWith

第二种:文件名称过滤器

PublicString[] list(FilenameFilter filter)

PublicFile[] listFiles(FileFilter filter)

使用接口 实现一个方法: boolean accept(Filedir, String name)重写

 

 

IO流:

I流是实现设备与设备之间的数据传输:   硬件和内存

输入流和输出流.      

数据类型分为:字节流:字节输入流InputStream 字节输出流OutputStream

字符流:字符输入流:Reader   字符输出流:Writer

public static void main(String[] args) throws IOException {

    //创建输出流对象

    OutputStream op=new FileOutputStream("a.txt");

    op.write("hello,io,i'mcoming...".getBytes()) ;

    op.close();//关闭流,不能再写数据

}

}

 

对于输出流中写数据的方法:

public abstract void write(intb):将指定的字节写入到输出流中

public void write(byte[] b):将指定的字节数组写入到输出流中

public void write(byte[] b, intoff,int len):将字节数组的一部分写入到输出流中

 

 

 需要写入换行符号,每一个系统他们对应IO这块换行符号是不一样的

对于windows操作系统来说:换行符号:\r\n

对于Linux操操作系统来说:\n

对于Mac操作系统来说:\r