精华内容
下载资源
问答
  • 在学习对硬盘文件操作类File时我们会遇到如下的情况: 我们来创建一个新文件: public class FileTest { public static void main(String[] args) { testOfCreateNewFile();//报错 } public static void ...

    问题

    在学习对硬盘文件操作类File时我们会遇到如下的情况:
    我们来创建一个新文件:

    public class FileTest {
        public static void main(String[] args) {
            testOfCreateNewFile();//报错
        }
    
    public static void testOfCreateNewFile(){
            File file = new File("D:\\javaspace\\study.txt");
            boolean isNewFile = false;
            isNewFile = file.createNewFile();//报错
            System.out.println(isNewFile);
        }

    编译器一般会报错:Unhandled exception: java.io.IOException,意思是没有进行IO异常的处理。这里我们很奇怪?我们的代码语法上是没有错误的为什么编译不通过?我们其实忽略了方法中潜在的异常:如果路径中的javaspace目录不存在呢?或者说在多线程文件被中途删除了呢?所以系统会提示我们去处理或者抛出这个异常,我的博客里有一篇博客专门讲了如何去处理这个异常,这里我们简单的写书正确处理异常的代码即可:

      public static void testOfCreateNewFile(){
            File file = new File("D:\\javaspace_idea\\texture\\study.txt");
            boolean isNewFile = false;
            try {
                isNewFile = file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
            }
            System.out.println(isNewFile);
        }

    然后我们再来看看创建目录的过程:

    public class FileTest {
        public static void main(String[] args) {
           testOfMkdirs();
        }
    
     public static void testOfMkdirs(){
            File file = new File("D:\\a\\b\\c");
            boolean isMadirs;
            isMadirs = file.mkdirs();
            System.out.println(isMadirs);
        }

    这里编译器是可以编译通过的,没有要求我们对异常进行处理,那你可能问了,如果父路径中a、b文件夹不存在的话不是类似于上述的创建文件出现的IO异常吗?这个问题是值得我们去深究的。

    解释

    首先我们查询一下官方的文档:
    CNF
    MKD
    官方文档中的createNewFile方法中标注的需要抛出异常的,但是mkdirs是没有标注的,其实到这里我们就可以解决这个问题了,但是我们想知道它到底为什么不需要抛出异常,这里我们就需要看mkdirs方法到底是如何实现的。所以我们打开了File类中的mkdirs方法:

    //File中mkdirs的实现
      public boolean mkdirs() {
            if (exists()) {
                return false;
            }
            if (mkdir()) {//【1】
                return true;
            }
            File canonFile = null;
            try {//【2】
                canonFile = getCanonicalFile();
            } catch (IOException e) {
                return false;
            }
    
            File parent = canonFile.getParentFile();
            return (parent != null && (parent.mkdirs() || parent.exists()) &&
                    canonFile.mkdir());//【3】
        }

    这里我们不去完整解释这个代码的意思,我们从三个地方来看看:首先【1】中出现了mkdir()方法,我们知道mkdir和mkdirs的区别就是s可以在父目录不存在的情况下创建父目录,而mkdir是不行的,这说明mkdirs和mkdir是有关系的。再来看【2】是一个对异常的处理,也许到这里你可以大致明白为什么mkdirs不用抛出异常了吧,因为方法内部已经对异常进行了处理。这里还选了第三个地方进行解释【3】:我们奇怪为什么mkdirs能创建父目录,其实这里出现的mkdir迭代已经说明问题,mkdirs中其实在父目录不存在的时候会进行判断,然后迭代mkdir来创建父目录,直至它存在,所以总结下来这个方法是不需要处理异常的。

    展开全文
  • python自定义异常类型和raise抛出异常

    万次阅读 2018-08-18 10:41:44
    这时候你可以通过创建一个新的异常类来拥有自己的异常异常类继承自 Exception ,可以直接继承,或者间接继承。 1.自定义异常类型 #1.用户自定义异常类型,只要该继承了Exception即可,至于的主题内容...

           实际开发中,有时候系统提供的异常类型不能满足开发的需求。这时候你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类,可以直接继承,或者间接继承。

    1.自定义异常类型 

    #1.用户自定义异常类型,只要该类继承了Exception类即可,至于类的主题内容用户自定义,可参考官方异常类
    class TooLongExceptin(Exception):
        "this is user's Exception for check the length of name "
        def __init__(self,leng):
            self.leng = leng
        def __str__(self):
            print("姓名长度是"+str(self.leng)+",超过长度了")

    2.如何手动抛出异常:raise

    系统的自带的异常只要触发会自动抛出,比如NameError,但用户自定义的异常需要用户自己决定什么时候抛出。
    raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类(也就是 Exception 的子类)。
    大多数的异常的名字都以"Error"结尾,所以实际命名时尽量跟标准的异常命名一样。

    #1.用户自定义异常类型
    class TooLongExceptin(Exception):
        "this is user's Exception for check the length of name "
        def __init__(self,leng):
            self.leng = leng
        def __str__(self):
            print("姓名长度是"+str(self.leng)+",超过长度了")
    
    #2.手动抛出用户自定义类型异常
    def name_Test():
            name = input("enter your naem:")
            if len(name)>4:
                raise TooLongExceptin(len(name))  #抛出异常很简单,使用raise即可,但是没有处理,即捕捉
            else :
                print(name)
    
    #调用函数,执行
    name_Test()
    -----------------执行时满足条件后抛出一个用户定义的异常如下:--------------------------------------
    enter your naem:是打发斯蒂芬
    Traceback (most recent call last):
    姓名长度是6,超过长度了
      File "D:/pythoyworkspace/file_demo/Class_Demo/extion_demo.py", line 21, in <module>
        name_Test()
    __main__.TooLongExceptin: <exception str() failed>
    

    3.捕捉用户手动抛出的异常

    #1.捕捉用户手动抛出的异常,跟捕捉系统异常方式一样
    def name_Test():
        try:
            name = input("enter your naem:")
            if len(name)>4:
                raise TooLongExceptin(len(name))
            else :
                print(name)
    
        except TooLongExceptin as e_result:  #这里异常类型是用户自定义的
            print("捕捉到异常了")
            print("打印异常信息:",e_result)
    
    #调用函数,执行
    name_Test()
    ==========执行结果如下:==================================================
    enter your naem:aaafsdf
    捕捉到异常了
    Traceback (most recent call last):
    打印异常信息: 姓名长度是7,超过长度了
    姓名长度是7,超过长度了
      File "D:/pythoyworkspace/file_demo/Class_Demo/extion_demo.py", line 16, in name_Test
        raise TooLongExceptin(len(name))
    __main__.TooLongExceptin: <exception str() failed>
    
    During handling of the above exception, another exception occurred:
    
    Traceback (most recent call last):
      File "D:/pythoyworkspace/file_demo/Class_Demo/extion_demo.py", line 26, in <module>
        name_Test()
      File "D:/pythoyworkspace/file_demo/Class_Demo/extion_demo.py", line 22, in name_Test
        print("打印异常信息:",e_result)
    TypeError: __str__ returned non-string (type NoneType)

    统一声明:关于原创博客内容,可能会有部分内容参考自互联网,如有原创链接会声明引用;如找不到原创链接,在此声明如有侵权请联系删除哈。关于转载博客,如有原创链接会声明;如找不到原创链接,在此声明如有侵权请联系删除哈。

    展开全文
  • 一、编译与运行时异常 ...抛出运行时异常,在方法的声明上,就可以不用throws来识别(区别编译时异常) b.可以不用在运行时对异常进行处理 例题 public class Demo01 { public static void main(String[] args) throw

    一、编译与运行时异常

    1.编译异常:系统会强制你去处理(try{}catch{}
    2.运行时异常--RuntimeException:
    a.抛出运行时异常,在方法的声明上,就可以不用throws来识别(区别编译时异常)
    b.可以不用在运行时对异常进行处理
    例题
    public class Demo01 {
    public static void main(String[] args) throws Exception {
        Text text = new Text();
        //这里测试的是编译异常,Text中的fun1方法抛出异常给调用者text,抛出异常
        text.fun1();
    
    
        Exception in thread "main" java.lang.Exception
        at com.lanou3g.exception.Text.fun1(Demo01.java:30)
        at com.lanou3g.exception.Demo01.main(Demo01.java:17)
    
    
        //测试运行时异常
        text.fun2();
    
    我是运行时异常
    Exception in thread "main" java.lang.RuntimeException
        at com.lanou3g.exception.Text.fun2(Demo01.java:35)
        at com.lanou3g.exception.Demo01.main(Demo01.java:19)
    
    
        //测试圆面积--这类我们输入-1,在Text里我们进行运行异常处理
        double area = text.getArea(-1);
        System.out.println(area);
    
    
    Exception in thread "main" java.lang.RuntimeException: 半径不对
        at com.lanou3g.exception.Text.getArea(Demo01.java:42)
        at com.lanou3g.exception.Demo01.main(Demo01.java:22)
    
    }
    }
    class Text {
        public void fun1() throws Exception {
             throw new Exception();
        }
        public void fun2()  {
            System.out.println("我是运行时异常");
            throw new RuntimeException();
        }
        //计算圆面积
        public double getArea(double r) {
        //对于圆面积的计算,我们都知道输入的半径应该要大于0,不然毫无意义,所以这里我们抛出运行时异常,停止程序,修改代码
            if (r<= 0) {
                throw new RuntimeException("半径不对");
    
            }
             return r*r*Math.PI;
        }
    }
    

    二、继承中方法重写异常

     例题:
    
      class Father{
      //这里父类fun方法抛出异常了,我们在子类中重写这个方法时,我们可以抛出也可以不抛出异常
      但是,如果父类如果没有进行fun方法抛出异常,那么子类中就一定不能抛出该方法的异常
          public void fun() throw Exception{
    
          }
      }
      class Son extends Father{
          //重写父类fun方法
          public void fun(){
    
          }
      }
    
    
    class Son extends  Father {
        public void fun() {
            try {
                method();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
        }
        //这个是Son类中的抛出异常的方法,那么我们如//果在子类的重写父类方法中调用该异常方法,//我们应该怎么在子类的fun方法中进行处理
    //  ----我们只能使用try{}catch{}进行处理,不能进行抛出异常处理(因为,父类并没有进行抛出异常处理,子类就不能进行,上面说过了
        public void method() throws Exception {
    
        }
    }

    三、File类

    1.作用:a.操作文件  b.操作文件夹 c.操作文件的路径
    
    2.构造方法
    a.File(String pathname);通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
    b.File(String parent,String child);  根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
    c.File(File parent,String chile);    根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
    3.方法
    a.创建功能
    public boolean createNewFile();    当且仅当不存在具有此抽象路径名指定名称的文件时,不可分地创建一个新的空文件。
    public boolean mkdir(); 创建此抽象路径名指定的目录。
    public boolean mkdirs(); 创建此抽象路径名指定的目录,包括所有必需但不存在的父目录。
    b.删除功能
    public boolean delete();  删除此抽象路径名表示的文件或目录。
    c.判断功能
    public boolean isDirectory()//判断是否是文件夹
    public boolean isFile();//判断是否是文件
    public boolean exists();//判断文件/文件夹是否存在
    d.获取功能
    public String getPath()//将此抽象路径名转换为一个路径名字符串。
    public String getName();// 返回由此抽象路径名表示的文件或目录的名称。
    public long length();// 返回由此抽象路径名表示的文件的长度。
    public String getAbsolutePath();//  返回此抽象路径名的绝对路径名字符串。
    public File getAbsoluteFile();//    返回此抽象路径名的绝对路径名形式。
    public File getParentFile();//  返回此抽象路径名父目录的抽象路径名;如果此路径名没有指定父目录,则返回 null。
    public String getParent(); 返回此抽象路径名父目录的路径名字符串;如果此路径名没有指定父目录,则返回 nullpublic String [] list();//  返回一个字符串数组,这些字符串指定此抽象路径名表示的目录中的文件和目录。
    public File [] listFiles();// 返回一个抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件。
    4.字段摘要(静态成员变量)
    a.static String pathSeparator//  与系统有关的路径分隔符,为了方便,它被表示为一个字符串。
    b.static String separator;//  与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。
    例题:
    
     public class Demo01{
         public static void main(String [] args) throws IOException{
    
         }
         //静态成员变量
         public static void fun1(){
             String pathseparator = File.pathSeparator;
             System.out.println(pathseparator);
             System.out.println(pathseparator);
    
    注:在不同平台下,所获取的分隔符不同
    Mac:路径分隔符是 : 冒号
    Windows:分隔符是 ; 分号
    /
    String separtor = File.separator;
    System.out.println(separtor);
    Mac:分隔符 /
    Window:分隔符 \

    /

    /构造方法
    //相对路径:有参照物
    //绝对路径:硬盘上的路径,这个路径唯一
    public static void fun3(){
    //这里Mac系统下Desktop(桌面)/Test(这是名为Test的文件夹)
        File file = new File ("/Users/lanou/Desktop/Test");
        System.out.println(file);
        结果:/Users/lanou/Desktop/Test
     //判断该路径是否存在
     boolean b1 = file.exists();
     System.out.println(b1);
     结果:true
      //使用相对路径,参照物是当前工程根目录
      File file1 = new File("src/wl.txt");
      boolean b2 = file.exists();
      System.out.println(b2);
      结果:true
    
       //获取绝对路径
      String absolutePath = file1.getAbsolutePath();
      System.out.println(absolutePath);
      结果:/Users/lanou/eclipse-workspace/sh-day023/src/wl.txt
    
      //使用构造方法二
      String parent = "/Users/lanou/Desktop";
      String child = "/Test";
      //父路径 和 子路径
      File file2 = new File(parent,child);
      boolean b3 = file2.exists();
      System.out.println(b3);
      结果:true
    
      //构造方法3
      File f = new File(parent);
      File file3 = new File (f,child);
      System.out.println(file3.exists());
      结果:true
    }
    //创建文件--方法
    public static void fun4(){
    
        File file = new File("/Users/lanou/Desktop/Test/haha.txt");
        boolean b1 = file.createNewFile();
        System.out.println(b1);
        结果:文件没有创建过--true,反之--false
        File b2 = new File("src/dp.txt");
        boolean b = b2.createNewFile();
        System.out.println(b);
        结果:结果:文件没有创建过--true,反之--false
        注:无论带不带后缀,都是文件
    }
     //删除,所删除的东西,不经过垃圾回收站,删除的东西要小心
     public  static void fun5(){
         File file = new File ("/Users/lanou/Desktop/Test/x");
         boolean b1 = file.delete();
         System.out.println(b1);
        结果:有此文件删除--true,反之--false
     }
    //判断文件是否存在
     public static void fun6(){
         File file = new File ("/Users/lanou/Desktop/Test/haha.txt");
         boolean b1 = file.isDirectory();
         System.out.println(b1);
       结果:有此文件夹--true,反之--false
       boolean b2 = file.isFile();
       System.out.println(b2);
       结果:有此文件--true,反之--false
    
     }
     //获取路径,我们所获取的路径,不管是否存在,都会打印所实例的对象路径
     public static void fun7(){
         File file = new File("/Users/lanou/Desktop/Test/www.txt");
         Sytring path = file.getPath();
         System.out.println(path);
         结果:/Users/lanou/Desktop/Test/www.txt
        //获取文件名字
        String name = file.getName();
        System.out.println(name);
        结果:www.txt
        //获取文件所占用的字节
        long length = file.length();
        System.out.println(length);
        结果:这里面,我在www.txt里面输入了一个"wang" 打印是 4个字节
        注:英文--1个字节
            中文--3个字节(这里UTF-8)
            不同编码格式字节数不一样的
    //获取父级路径
       File parentFile = file.getParentFile();
       System.out.println(parentFile);
       结果:/Users/lanou/Desktop/Test
     }
      //list与 listFiles方法
      public void fun8(){
          File file = new File ("/Users/lanou/Desktop/Test");
          String [] list = file.list();
          for(String string : file.list){
              System.out..println(string);
            结果:
    .DS_Store
    g
    haha
    haha.txt
    hahah.txt
    www.txt
    x
    注:这个是我所创建的Test文件夹下所有文件和文件夹的名字,且仅仅能查看一层,.DE-Store是隐藏文件,
    
      File [] listFiles = file.listFiles();
      for(File file2 :listFiles){
          System.out.println(file2);
          结果
    /Users/lanou/Desktop/Test/.DS_Store
    /Users/lanou/Desktop/Test/g
    /Users/lanou/Desktop/Test/haha
    /Users/lanou/Desktop/Test/haha.txt
    /Users/lanou/Desktop/Test/hahah.txt
    /Users/lanou/Desktop/Test/www.txt
    /Users/lanou/Desktop/Test/x
    注:listFiles返回的是文件与文件夹的全路径名,是以对象形式
            } 
    
          }
      //遍历Test下所有的文件夹下所有文件和文件夹
     public static void fun9(){
         File file = new File("/Users/lanou/Desktop/Test");
        File [] listFiles = file.listFiles();
        for(File f : listFiles){
            if(f.isDirectory()){
                getFileName(f);
            }else{
                System.out.println(f);
    结果:
    /Users/lanou/Desktop/Test/.DS_Store
    /Users/lanou/Desktop/Test/haha.txt
    /Users/lanou/Desktop/Test/hahah.txt
    /Users/lanou/Desktop/Test/www.txt
    /Users/lanou/Desktop/Test/x/.DS_Store
    
    /Users/lanou/Desktop/Test/x/y/z/www.txt
            }
        }
      }
    
    }
    展开全文
  • file类抛出异常为read-only file system,但是用context的openfileoutput和openfileinput方法却没有出现问题,这个要怎么解决??
  • Java 中的异常处理除了包括捕获异常和处理异常之外,还包括声明异常和拋出异常,可以通过 throws 关键字在方法上声明该方法要拋出的异常,然后在方法内部通过 throw 拋出异常对象。本节详细介绍在 Java 中如何声明...

    Java 中的异常处理除了包括捕获异常和处理异常之外,还包括声明异常和拋出异常,可以通过 throws 关键字在方法上声明该方法要拋出的异常,然后在方法内部通过 throw 拋出异常对象。本节详细介绍在 Java 中如何声明异常和拋出异常。

    throws 关键字和 throw 关键字在使用上的几点区别如下

    • throws 用来声明一个方法可能抛出的所有异常信息,throw 则是指拋出的一个具体的异常类型。
    • 通常在一个方法(类)的声明处通过 throws 声明方法(类)可能拋出的异常信息,而在方法(类)内部通过 throw 声明一个具体的异常信息。
    • throws 通常不用显示地捕获异常,可由系统自动将所有捕获的异常信息抛给上级方法; throw 则需要用户自己捕获相关的异常,而后再对其进行相关包装,最后将包装后的异常信息抛出。

    throws 声明异常

    当一个方法产生一个它不处理的异常时,那么就需要在该方法的头部声明这个异常,以便将该异常传递到方法的外部进行处理。可以使用 throws 关键字在方法的头部声明一个异常,其具体格式如下:

    returnType method_name(paramList) throws Exception 1,Exception2,…{…}


    其中,returnType 表示返回值类型,method_name 表示方法名,Exception 1,Exception2,… 表示异常类。如果有多个异常类,它们之间用逗号分隔。这些异常类可以是方法中调用了可能拋出异常的方法而产生的异常,也可以是方法体中生成并拋出的异常。

    例 1

    创建一个 readFile() 方法,该方法用于读取文件内容,在读取的过程中可能会产生 IOException 异常,但是在该方法中不做任何的处理,而将可能发生的异常交给调用者处理。在 main() 方法中使用 try catch 捕获异常,并输出异常信息。代码如下:

     
    1. import java.io.FileInputStream;
    2. import java.io.IOException;
    3. public class Test04
    4. {
    5. public void readFile() throws IOException
    6. {
    7. //定义方法时声明异常
    8. FileInputStream file=new FileInputStream("read.txt"); //创達 FileInputStream 实例对象
    9. int f;
    10. while((f=file.read())!=-1)
    11. {
    12. System.out.println((char)f);
    13. f=file.read();
    14. }
    15. file.close();
    16. }
    17. public static void main(String[] args)
    18. {
    19. Throws t=new Test04();
    20. try
    21. {
    22. t.readFile(); //调用 readFHe()方法
    23. }
    24. catch(IOException e)
    25. { //捕获异常
    26. System.out.println(e);
    27. }
    28. }
    29. }


    以上代码,首先在定义 readFile() 方法时用 throws 关键字声明在该方法中可能产生的异常,然后在 main() 方法中调用 readFile() 方法,并使用 catch 语句捕获产生的异常。

    注意:在编写类继承代码时要注意,子类在覆盖父类带 throws 子句的方法时,子类的方法声明中的 throws 子句不能出现父类对应方法的 throws 子句中没有的异常类型,因此 throws 子句可以限制子类的行为。也就是说,子类方法拋出的异常不会超过父类定义的范围。

    throw 拋出异常

    throw 语句用来直接拋出一个异常,后接一个可拋出的异常类对象,其语法格式如下:

    throw ExceptionObject;


    其中,ExceptionObject 必须是 Throwable 类或其子类的对象。如果是自定义异常类,也必须是 Throwable 的直接或间接子类。例如,以下语句在编译时将会产生语法错误:

     
    1. throw new String("拋出异常"); //因为String类不是Throwable类的子类


    当 throw 语句执行时,它后面的语句将不执行,此时程序转向调用者程序,寻找与之相匹配的 catch 语句,执行相应的异常处理程序。如果没有找到相匹配的 catch 语句,则再转向上一层的调用程序。这样逐层向上,直到最外层的异常处理程序终止程序并打印出调用栈情况。

    例 2

    在某仓库管理系统中,要求管理员的用户名需要由 8 位以上的字母或者数字组成,不能含有其他的字符。当长度在 8 位以下时拋出异常,并显示异常信息;当字符含有非字母或者数字时,同样拋出异常,显示异常信息。代码如下:

     
    1. import java.util.Scanner;
    2. public class Test05
    3. {
    4. public boolean validateUserName(String username)
    5. {
    6. boolean con=false;
    7. if(username.length()>8)
    8. { //判断用户名长度是否大于8位
    9. for(int i=0;i<username.length();i++)
    10. {
    11. char ch=username.charAt(i); //获取每一位字符
    12. if((ch>='0'&&ch<='9')||(ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z'))
    13. {
    14. con=true;
    15. }
    16. else
    17. {
    18. con=false;
    19. throw new IllegalArgumentException("用户名只能由字母和数字组成!"");
    20. }
    21. }
    22. }
    23. else
    24. {
    25. throw new IllegalArgumentException("用户名长度必须大于 8 位!");
    26. }
    27. return con;
    28. }
    29. public static void main(String[] args)
    30. {
    31. Test05 te=new Test05();
    32. Scanner input=new Scanner(System.in);
    33. System.out.println("请输入用户名:");
    34. String username=input.next();
    35. try
    36. {
    37. boolean con=te.validateUserName(username);
    38. if(con)
    39. {
    40. System.out.println("用户名输入正确!");
    41. }
    42. }
    43. catch(IllegalArgumentException e)
    44. {
    45. System.out.println(e);
    46. }
    47. }
    48. }


    如上述代码,在 validateUserName() 方法中两处拋出了 IllegalArgumentException 异常,即当用户名字符含有非字母或者数字以及长度不够 8 位时。在 main() 方法中,调用了 validateUserName() 方法,并使用 catch 语句捕获该方法可能拋出的异常。

    运行程序,当用户输入的用户名包含非字母或者数字的字符时,程序输出异常信息,如下所示。

     
    1. 请输入用户名:
    2. administrator@#
    3. java.lang.IllegalArgumentException: 用户名只能由字母和数字组成!


    当用户输入的用户名长度不够 8 位时,程序同样会输出异常信息,如下所示。

    请输入用户名:
    admin
    java.lang.IllegalArgumentException: 用户名长度必须大于 8 位!
    展开全文
  • 在PLSQL程序开发过程中,很重要的部分就是对程序异常的监控和处理,包括如何触发异常,何时进行处理,如何进行处理,是否将程式中的所有异常集中在一起,通过公共异常处理的procedure或function,如果没有完善的程式...
  • python抛出异常

    千次阅读 2018-08-23 09:31:03
    当 Python 试图执行无效代码时,就会抛出异常。在第 3 章中,你已看到如何使用 try 和 except 语句来处理 Python 的异常,这样程序就可以从你预期的异常中恢复。但你也可以在代码中抛出自己的异常。抛出异常相当于是...
  • for循环中抛出异常_不要抛出循环!

    千次阅读 2020-06-28 05:13:58
    在AspectJ中,这是通过创建围绕代码部分编织的方面来完成的,这些方面由切入点定义,如果您希望在代码库的不同部分中针对不同种类的异常使用不同的行为,则必须仔细编写这些切入点SQLExceptions应该以不同方式处理...
  • 声明抛出异常是Java中处理异常的第二种方式 如果一个方法(中的语句执行时)可能生成某种异常,但是并不能确定如何处理这种异常,则此方法应显式地声明抛出异常,表明该方法将不对这些异常进行处理,而由该方法的调用...
  • 见下方示例代码: import java.io.*; public class Father { public void father_function() throws ... new File("a.txt"); } } class Son extends Father { @Override public void father_function() ...
  • 简介 如果你编写过C++程序,相信你应该有过被“烫烫烫”、“屯屯屯”支配的恐惧。作为程序员,我们每天就是在写代码bug,然后改bug。通过本文你可以看懂自己程序发生的错误或异常,如何自己... File "<stdin>",.
  • new File抛出FileNotFoundException解决

    千次阅读 2019-06-20 00:56:14
    最近做一个把图片存到手机本地的需求时,在调用new File()之后,既然抛出了FileNotFoundException,File也没有创建成功。 最后发现了原来是makedir方法用错了,我写的路径是个多级文件夹,比如"/dome/pic",而...
  • 在Python中手动引发(抛出异常

    千次阅读 2019-12-04 10:09:30
    如何在Python中引发异常,以便以后可以通过except块捕获该异常
  • 抛出异常位置:创建文件流, 运行时fileName的值为:"201829815:14:33591.txt"。 注释掉的代码部分是我尝试的解决办法,但抛出相同异常。 请不吝赐教,谢谢!FileStream的 官方帮助文档...
  • 在声明方法时候抛出异常, 如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异常(可以是一种类型,也可以是多种...
  • Java把电脑中的文件和文件夹(目录)封装为了一个File类,我们可以使用File类对文件和文件夹进行操作:创建一个文件/文件夹,删除文件/文件夹,获取文件/文件夹,判断文件/文件夹是否存在,对文件夹进行遍历,获取...
  •  在Java中常见的两种异常处理:捕捉异常(try-catch-finally)和抛出异常(throw-throws) 1.捕捉异常(try/catch/finally): 用捕捉异常时,不能try、catch、finally单独使用,需要配套使用,入try-catch、try-...
  • JAVA基础知识之File类

    万次阅读 多人点赞 2018-07-13 10:46:30
    一、File类定义 1. File类主要是JAVA为文件这块的操作(如删除、新增等)而设计的相关 2. File类的包名是java.io,其实现了Serializable, Comparable两大接口以便于其对象可序列化和比较public class File ...
  • Java中的异常File类的使用

    千次阅读 2016-11-25 16:41:21
    Java中的异常File类的使用 一、异常的概念  1、什么是异常?  通俗理解:异于平常,本来一件事情正常执行,可能中途会有特殊情况,导致当前事情无法正常执行而影响执行结果,这个中途特殊情况即异常。  ...
  • IO流:IO流用来处理设备之间的数据传输,上传文件和下载文件因为IO流操作的对象就是File文件,而且操作过程中会出现很多的异常,所以还要学习异常File文件类异常:Java程序在运行过程中出现的错误Throwable是所有...
  • 异常:Exception 1、分类: 1、编译期异常:checkedException。...运行过程中抛出的错误。 2、JDK常见异常: 1、运行期异常: NUllPointerWxception 空指针异常,使用了没有实例化的对象引用。 Ar...
  • 为何电脑创建不了这个TXT![图片](https://img-ask.csdn.net/upload/201711/16/1510764882_705140.jpg)
  • Java File类介绍(源码分析)

    千次阅读 2019-03-19 11:28:30
    一、File类 File类的源码在Java.io包下。
  • Java_File类和MultipartFile

    千次阅读 2021-03-18 17:02:02
    主要用于文件和目录的创建、文件的查找和文件的删除等。 File类代表磁盘中实际存在的文件和目录,这个文件或者目录的路径可以是绝对路径,也可以是相对路径。 2.2 构造器 1、根据路径名字符串转换为...
  • 异常捕获和file类

    2017-03-29 21:22:48
    1)异常是什么:异常是在程序的编写过程中出现的一些异于常态的事情,比如说a除以b,当b被赋值为0时,则程序就会抛出异常 2)异常的处理方法:通过try..catch的方法来捕获异常或者通过throws的方法来抛出异常 3)...
  • Python程序中自定义异常类

    千次阅读 2018-08-31 12:00:20
    通过创建一个新的异常类,程序可以命名它们自己的异常异常应该是典型的继承自Exception,通过直接或间接的方式。 以下为与RuntimeError相关的实例,实例中创建了一个,基类为RuntimeError,用于在异常触发时...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 142,626
精华内容 57,050
关键字:

创建file类抛出的异常是