Java零基础学习（IO的概述 异常 File文件类）

本文主要是介绍Java零基础学习（IO的概述 异常 File文件类），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Java零基础学习（IO的概述 异常 File文件类）

• IO流的概述及前奏

1.IO流概述：
	IO流用来处理设备之间的数据传输
	上传文件和下载文件，复制文件
2.IO流前奏
	讲解IO流之前为什么先讲解异常和File类呢？
	因为File表示的是Io流将来要操作的文件，所以我们需要学习File类
	而常见操作文件无非就是上传和下载文件，在这个操作的过程中可能出现问题
	出现问题之后，我们需要对对应的代码进行处理。我们就需要学习异常

• 异常的概述和分类

  1.异常的概述：
  	异常就是Java程序运行过程中出现的错误。
  2.异常的分类
  	问题 Throwable
          Error  错误，属于严重性问题 我们在代码中无法处理
          Exception 异常，属于一般性问题，我们主要处理他
          运行期异常：发生运行在运行期间的异常，可以选择解决，你可以选择不解决
          编译期异常：发生在编译期间，必须解决，不解决程序无法运行。
  

  • JVM默认是如何处理异常的

  1.JVM默认处理异常
  	main函数收到这个问题时，有两种处理方式：
  		a.自己将该问题处理，然后继续运行
  		b.自己没有针对的处理方式，只能交给调用main的JVM来处理
  	JVM有一个默认的异常处理机制，就是将该异常进行处理
  	并且将该异常的名称，异常的信息，异常的出现位置打印在了控制台上，同时程序停止运行
  2.案例演示
  	比如1/0:看看JVM如何默认处理异常
  public class MyTest {
      public static void main(String[] args) {
          System.out.println(1/0);
          System.out.println("下面的代码");
      }
  }
  处理结果：
  Exception in thread "main" java.lang.ArithmeticException: / by zero
  就是将你的异常打印出来，然后将程序停止运行
  

  • try...catch的方式处理异常

  1.异常处理的两种方式
  	a.try...catch...Finally
  	b.throws
  2.try...catch处理异常的基本格式
  	try{
          可能出现问题的代码；
  	}catch(异常名 变量名){
          针对问题的处理；
  	}finally{
          释放资源；
  	}
  	
  	变形格式：
  	try{
          可能出现问题的代码；
  	}catch{
          针对问题的处理；
  	}
  	注意事项：
  		a.tr中的代码越少越好
  		b.catch中要做处理，哪怕是一条输出语句也可以。（不能将异常信息隐藏）
  3.案例演示：
  	try...catch...finally的方式处理异常
  public class MyTest {
      public static void main(String[] args) {
          try {
              System.out.println(1/0);
          } catch (Exception e) {
              e.printStackTrace();
          }finally {
              System.out.println("除数不能为0");
          }
      }
  }
  运行结果：
  java.lang.ArithmeticException: / by zero
  	at demo15.MyTest.main(MyTest.java:6)
  除数不能为0
  

  • try...catch的方式处理异常2

  try {
   可能出现问题的代码 ;
  }catch(异常名1 变量名1){
   对异常的处理方式 ;
  }catch (异常名2 变量名2){
    对异常的处理方式 ;
  }....
  案例演示:	try...catch的方式处理多个异常
  	注意事项：
  		1:能明确的尽量明确，不要用大的来处理。
      	2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。
  

  • JDK7针对多个异常的处理

  try {
  
   可能出现问题的代码 ;
  
  }catch(异常名1 | 异常名2 | ....   变量名){
  
  对异常的处理方案 ;
  
  }
  好处：简化了代码
  坏处：对多个异常的处理方式是一样的
  
  注意事项：
  	多个异常之间只能是平级关系，不能出现父子继承关系
  

  • 编译期异常和运行期异常的区别

  Java中的异常被分为两大类
  	编译期异常和运行期异常
  		所有的RuntimeException类及其子类的实力被称为运行时异常，其他的异常就是编译期异常
  	编译期异常
  		Java程序必须显示处理，否则就会发生错误，无法通过编译
  	运行时异常
  		无需显示处理，也可以和编译时异常一样处理
  

  • Throwable的几个常见方法

  1.Throwable的几个常见方法
  	a:getMessage():		获取异常信息，返回字符串
  	b:toString():		获取异常类名和异常信息，返回字符串
  	c:printStackTrace():获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void
  2.案例演示
  	举例分别演示编译时异常和运行时异常的抛出
  
  	编译时异常的抛出，如果不抛出程序就无法运行
  	public static void test() throws ParseException {
          String dateStr = "2020-10===10";
          SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
          dateFormat.parse(dateStr);
      }
  
      运行时异常的处理
      public static void main(String[] args) {
          while (true) {
              //InputMismatchException
              Scanner sc = new Scanner(System.in);
              System.out.println("请录入一个整数");
              try {
                  int i = sc.nextInt();
                  System.out.println(i);
                  break;
              } catch (InputMismatchException e) {
                  //e.printStackTrace();
                  System.out.println("请重输入一个整数");
              }
          }
      }
  

···

• finally关键字的特点及作用

1.finally的特点
	被finally控制的语句题一定会执行（前提是jvm没有停止）
	特殊情况：在执行到finally之前jvm推出了（比如System.exit(0)）
2.finally的作用：用于释放资源，在IO流操作和数据库操作中会见到
3.演示
  public static void main(String[] args) {
  	Scanner scanner = null;
  	try {
  		System.out.println(1 / 0);
  		scanner = new Scanner(System.in);
  		System.out.println("请输入一个整数");
  		int i = scanner.nextInt();
  		System.out.println(i);
  	} catch (InputMismatchException e) {
  		System.err.println("输入类型错误");
  		//finally 他的特点就是不管你try里面的代码有没有发生异常，finally里面的代码都会执行，
            // 一般有些善后收尾的代码可以放在finally来做
  	} finally {
  		//释放资源
  		System.out.println("finally 执行了");
  		if (scanner != null) {
  		    scanner.close();
  		}
  	}
}

• finally关键字的面试题

1.final、finally和finalize的区别
	final：是一个状态修饰符，可以用来修饰类，变量，成员方法
		被修饰的类不能被子类继承，修饰的变量其实就是一个常量，不能被再次赋值，被修斯的方法不能被重写
	finally：用在try...catch...语句中，作用：释放资源，特点：始终被执行，除非JVM退出
	finalize：Object类中的一个方法，用来回收垃圾
2.如果catch中有return语句，请问finally的代码还会执行吗？如果会，请问是在return前还是在return后
	答：会执行，是在return前执行

• 自定义异常的概述和基本使用

1.为什么需要自定义异常：
	因为在往后的开发过程中，我们可能会遇到各种问题，但是JDK不可能针对每一种问题都给出具体的异常类与之对应
	为了满足需求，我们就需要自己定义异常
举例：考试成绩就必须满足成绩在0--100之间，如果不满足就产生异常
	
	//异常类
public class ScoreException extends RuntimeException {
    	public ScoreException(String msg) {
        	super(msg);
    	}
}
	//测试类
public class MyTest3 {
    	public static void main(String[] args) {
      		Scanner sc = new Scanner(System.in);
        	System.out.println("请录入你的成绩");
        	double score = sc.nextDouble();
        	isScore(score);
    	}
    	private static void isScore(double score) {
        	if (score >= 0 && score <= 100) {
        	    System.out.println("成绩合法");
        	} else {
        	    throw new ScoreException("成绩不合法");
        	}
    	}
}
2.自定义类异常概述 需要将我们自定义的异常类纳入到我们的异常体系中
	继承自Exception
	继承自RuntimeExeception
3.案例演示
	需求，从银行取钱，钱不够了，给出提示
	//异常类
public class NoMoneyException extends RuntimeException {
    	public NoMoneyException(String msg) {
        	super(msg);
    	}
}
	//测试类
public class MyTest {
    static double money = 500;
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入取款金额");
        double v = scanner.nextDouble();
        //捕获自定义异常
        try {
            withdrawal(v);
        } catch (NoMoneyException e) {
            e.printStackTrace();
        }
        System.out.println("下面代码");
        System.out.println("下面代码");
        System.out.println("下面代码");
    }

    private static void withdrawal(double v) {
        if (v <= money) {
            money -= v;
            System.out.println("取款成功");
        } else {
            //余额不足异常。
            //throw 抛出的自定义异常
            throw new NoMoneyException("余额不足");
        }
    }
}

• 异常的注意事项以及如何使用异常处理

1.异常的注意事项（针对编译期异常）
	a.子类重写父类方法是，子类的方法必须抛出相同的异常类或父类异常的子类，或者子类不抛出异常也是可以的。（父亲坏了，儿子不能比父亲更坏）
	b.如果父类抛出多个异常，子类重写父类时，只能抛出相同的异常或者是他的子集，子类不能抛出父类没有的异常，或者子类不抛出异常也是可以的
	c.如果被重写的方法没有抛出异常，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try，不能throws
2.如何使用异常处理
	原则：如果该功能内部可以将问题处理，用try，如果处理不了，交由调用者处理，这是用throws
	区别：
		后续程序需要继续运行就try
		后续程序不需要继续运行就throws

• File类的概述和构造方法

  1.File类的概述
  	文件和目录路径名的抽象表示形式
  	这个File类可以用来表示文件，也可以用来表示文件路径
  2.构造方法
  	File(String pathname):根据一个路径得到File对象
  	File(String parent,String child):根据一个目录和子文件/目录得到File对象
  	File(File parent,String child):根据一个父File对象和子文件/目录得到File对象
  
  

  • File类的创建功能

  1.创建功能
  	public boolean createNewFile():创建一个新的文件，如果存在这个文件，就不用了创建
  	public boolean mkdir():创建文件夹，如果存在这样的文件夹，就不创建了，注意：这个方法只能创建单层目录，如果有多层目录得一层一层创建
  	public boolean mkdirs():创建文件夹，如果符文件夹不存在，会帮你创建出来，可以创建多层目录，当然也可以创建单层目录
  2.注意
  	如果你创建的文件或者文件夹忘记写盘符路径，就默认在项目路径下
  	相对路径：没有盘符的路径
  	绝对路径：带有盘符的路径
  
  

  • File类的删除功能

  1.删除功能
  	public boolean delete():删除文件或者文件夹
  	注意：删除文件夹时，只能删除空文件夹，如果文件夹里面有文件，就不能删除
  2.注意事项
  	Java中的删除不走回收站，要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹，删除时候一定要注意不要删除有用的文件
  
  

  • File的重命名功能

  1.重命名功能
  	public boolean renameTo(File dest):把文件重命名为指定的文件路径
  2.注意事项
  	如果路径名相同就是改名
  	如果路径不相同就是改名并剪切
  
  

  • File的判断功能

  public boolean isDirectory():	判断是否是目录
  public boolean isFile():	判断是否是文件
  public boolean exists():	判断是否存在
  public boolean canRead():	判断是否可读
  public boolean canWrite():	判断是否可写
  public boolean isHidden():	判断是否隐藏
  public boolean isAbsolute(); 判断是否使用的是绝对路径
  
  

  • File类的获取功能

  public String getAbsolutePath()：	获取绝对路径
  public String getPath():		获取相对路径
  public String getParent()   返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
  public File getParentFile()  返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。 
  public long getTotalSpace()  返回此抽象路径名指定的分区大小。 返回总容量 单位字节
  public long getFreeSpace()   返回此抽象路径名指定的分区中未分配的字节数。返回剩余容量 单位字节
  public String getName():		获取名称
  public long length():			获取长度。字节数
  public long lastModified():		获取最后一次的修改时间，毫秒值
  public String[] list():			获取指定目录下的所有文件或者文件夹的名称数组
  public File[] listFiles():		获取指定目录下的所有文件或者文件夹的File数组 
  
  

  • 文件名称过滤器的概述和使用

  1.文件名称过滤器的概述
  	public String[] list(FilenameFilter filter)
  	public File[] listFiles(FilenameFilter filter)
  2.文件名称过滤器的使用:	需求：判断E盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
  - 分析:
  - a: 把E:\\demo这个路径封装成一个File对象
  - b: 获取所有的以.jpg结尾的文件数组		(相当于过滤)
  - c: 遍历数组
  public class MyTest {
     	public static void main(String[] args) {
          // public String[] list ():获取指定目录下的所有文件或者文件夹的名称数组
          File file = new File("C:\\Users\\ShenMouMou\\Desktop\\demo");
          String[] arr = file.list();
          for (String name : arr) {
              //System.out.println(name);
              //我要获取.jpg 文件的名称
              File file1 = new File(file, name);
              if (file1.isFile() && file1.getName().endsWith(".jpg")) {
                  System.out.println(file1.getName());
              }
          }
  
      }
  }
  
  

这篇关于Java零基础学习（IO的概述 异常 File文件类）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！