devbox
煮酒与君饮
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JAVA小白学习日记Day8

作者：煮酒与君饮 | 2024-07-31 06:00:26

赞

踩

JAVA小白学习日记Day8

1.异常

异常：程序中一些程序处理不了的特殊情况。java中异常会以类的形式出现，当程序中出现异常，就会中断程序，代码不会继续运行。

异常分类：

1.检查型异常（编译异常）：在编译时就会抛出的异常（在代码上报错），需要在代码中编写处理方式，和程序之外的资源访问，直接继承Exception。

2.运行时异常：在代码运行阶段可能会出现的异常，可以没有明文处理，可以通过代码避免异常的发生。继承RunTimeException。

处理异常：

1.throws：

在方法声明的位置上使用 throws 关键字抛出，谁调用我这个方法，我就抛给谁。抛给调用者来处理。这种处理异常的态度：上报。

throws的抛出范围更小，可以为空。声明方法中可能抛出的异常，声明抛出多种异常。

方法重写的约束：返回值类型，方法名，参数列表不能变，访问权限只能更开放。

 代码：

  1. package com.easy723;
  2.  
  3. public class EasyExceptionA {
  4.  
  5. }
  6. class BigStudent extends Student{
  7.     @Override
  8.     public void info () throws StudentNameIsNullException{
  9.         //throws抛出范围更小，可以为空
  10.     }
  11. }
  12. //自定义异常
  13. class Student {
  14.     String name;
  15.     //throws 声明方法中可能抛出的异常
  16.     //throws 声明抛出多种异常
  17.  
  18.     //方法重写：子类对父类中继承过来的方法进行重新定义
  19.     //约束：返回值类型，方法名，参数列表不能变，访问权限只能更开放。重写的方法抛出的异常，只能更精确，范围更小，不能扩大。
  20.  
  21.     public void info() throws StudentNameIsNullException,NullPointerException{
  22.         //name==null是一种特殊情况，不符合业务需求
  23.         if (name==null){
  24.             throw new StudentNameIsNullException("student name is null");
  25.         }
  26.         System.out.println("我的名字是："+name);
  27.     }
  28.     //运行时异常可以不声明抛出
  29.     public void infoA(){
  30.         if (name==null){
  31.             throw new NullPointerException("name is null");
  32.         }
  33.     }
  34. }
  35.  
  36. //检查型异常   是Exception的直接子类
  37. class StudentNameIsNullException extends Exception{
  38.     public StudentNameIsNullException(){
  39.  
  40.     }
  41.     public StudentNameIsNullException(String msg){
  42.         super(msg);
  43.     }
  44. }

2.try…catch...finally：

这个异常不会上报，自己把这个事儿处理了。异常抛到此处为止，不再上抛了。

注意：

只要异常没有捕捉，采用上报的方式，此方法的后续代码不会执行。当try处理多种异常时，遇到第一个异常就中断，跳转到catch。

try语句块中的某一行出现异常，该行后面的代码不会执行。try不能单独编写，必须有其他语句块。

try…catch捕捉异常之后，后续代码可以执行。

finally块无论是否出现异常都会执行的代码块，一般用在关闭资源。如果只有finally，try中不能有检查型异常。try块中没有检查型异常，不能再catch块中随意捕捉。

catch块是合并处理方案，一个catch块捕捉多种异常。可以通过声明父类异常来捕捉所有子类异常，catch异常捕捉的顺序：子类异常优先处理（前放），父类异常后处理。如果catch块抛出异常，没有finally就会中断程序，如果有，运行finally并且正常返回，此方法结束。

代码：

  1. package com.easy723;
  2.  
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileNotFoundException;
  6. import java.io.IOException;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9.  
  10. public class EasyException {
  11.     //异常   程序中一些程序处理不了的特殊情况
  12.     //异常类  Exception
  13.     //见过的异常：Null Pointer Exception，ArrayIndexoutOf...
  14.     public static void main(String[] args) {
  15.         String str=null;
  16. //        String name="张三";
  17. //        boolean b=str.equals(name);
  18. //        b=name.equals(str);//把确定不为空的放前面避免异常
  19.         //System.out.println(str.length());
  20.         int i=12;
  21.         int a=0;
  22.         if(a!=0) {
  23.             System.out.println(i / a);//没有if判断直接运行会报错：ArithmeticException
  24.         }else {
  25.             System.out.println("a不能做除数");
  26.         }
  27.         System.out.println("++++++++++++");
  28.         //当程序中出现异常，就会中断程序，代码不会继续运行
  29.         //异常分类：
  30.         //1.检查型异常（编译异常）：在编译时就会抛出的异常（在代码上报错），需要在代码中编写处理方式
  31.         //和程序之外的资源访问  直接继承Exception
  32.         //2.运行时异常：在代码运行阶段可能会出现的异常，可以没有明文处理，可以通过代码避免异常的发生
  33.         //继承RunTimeException
  34.  
  35.         //处理异常
  36.         //try...catch...finally
  37.         //声明抛出  throws
  38.  
  39.         //声明异常
  40.  
  41.         //处理文件
  42.         File file=new File("D:\\easy.test");
  43.         //检查型异常（编译异常）
  44.         FileInputStream fis=null;//因为finally要调用fis，所以在外部声明
  45.         try {
  46.             //尝试捕捉异常   其中可能会抛出异常的代码
  47.             fis=new FileInputStream(file);
  48.         }catch (FileNotFoundException e){
  49.             //捕捉到异常后要处理的代码
  50.             e.printStackTrace();//打印异常日志
  51.         }finally {
  52.             //无论是否出现异常都会执行的代码块 一般用在关闭资源
  53.             if (fis!=null){
  54.                 try {
  55.                     fis.close();
  56.                 } catch (IOException e) {
  57.                     e.printStackTrace();
  58.                 }
  59.             }
  60.         }
  61.  
  62.         //try  处理多种异常
  63.         try {
  64.             System.out.println(12/0);//第一个异常就中断，跳到catch，后两个异常不会运行
  65.             Object strA="";
  66.             System.out.println((Integer)strA);
  67.             fis=new FileInputStream(file);
  68.         }catch (ArithmeticException e){
  69.             //出现ArithmeticException要执行的代码
  70.             System.out.println("出现ArithmeticException");
  71.         }catch (ClassCastException e){
  72.             System.out.println("出现ClassCastException");
  73.         }catch (FileNotFoundException e){
  74.             System.out.println("出现FileNotFoundException");
  75.         }finally {
  76.             if (fis!=null){
  77.                 try {
  78.                     fis.close();
  79.                 } catch (IOException e) {
  80.                     e.printStackTrace();
  81.                 }
  82.             }
  83.         }
  84.         //catch 合并处理方案  一个catch块捕捉多种异常
  85.         //1.
  86.         try {
  87.             System.out.println(12/0);
  88.             Object strA="";
  89.             System.out.println((Integer)strA);
  90.             fis=new FileInputStream(file);
  91.         }catch (ArithmeticException|ClassCastException|FileNotFoundException e){
  92.  
  93.         }
  94.         //2.通过声明父类异常，捕捉所有子类异常
  95.         try {
  96.             System.out.println(12/0);
  97.             Object strA="";
  98.             System.out.println((Integer)strA);
  99.             fis=new FileInputStream(file);
  100.         }catch (Exception e){
  101.  
  102.         }
  103.  
  104.         //catch异常捕捉的顺序  子类异常优先处理（前放），父类异常后置处理
  105.         try {
  106.             List list=new ArrayList<>();
  107.             list.remove(8);//Indexout
  108.             int[] arr=new int[2];
  109.             arr[8]=22;//ArrayIndex
  110.             String strA="abc";
  111.             strA.charAt(8);//Stringindex
  112.         }catch (ArithmeticException e){
  113.             e.printStackTrace();
  114.         }catch (StringIndexOutOfBoundsException e){
  115.             e.printStackTrace();
  116.         }catch (IndexOutOfBoundsException e){
  117.             e.printStackTrace();
  118.         }
  119.  
  120.         System.out.println(test());//3
  121.     }
  122.         //如果catch块抛出异常，没有finally就会中断程序
  123.     //如果有finally，会运行finally并且正常返回，此方法正常运行结束
  124.     public static int test(){
  125.         try {
  126.             System.out.println(12/0);
  127.             return 1;
  128.         }catch (Exception e){
  129.             return 2;
  130.         }finally {
  131.             return 3;
  132.         }
  133.     }
  134.     //try不能单独编写，必须有其他语句块
  135.     public static void testA(){
  136.         try {
  137.             System.out.println(12/0);
  138.         }catch (Exception e){
  139.  
  140.         }
  141.     }
  142.     public static void testB(){
  143.         FileInputStream fis=null;
  144.         File file=null;
  145.         try {
  146.             System.out.println(12/0);
  147.             //如果只有finally，try中不能有检查型异常
  148.             //比如fis=new FileInputStream(file);
  149.         }finally {
  150.  
  151.         }
  152.     }
  153.     //try块中没有检查型异常，不能在catch块中随意捕捉
  154.     public static void testC(){
  155.         try {
  156.             int a=12+8;
  157.         }catch (NullPointerException e){
  158.             //可以
  159.         }
  160. //        catch (FileNotFoundException e){
  161. //            不行
  162. //        }
  163.     }
  164. }

2.文件（IO流）

java中对文件的处理通过java.io包。

在声明一个文件时，传入字符串当作文件地址。

注意：创建文件时，mkdir创建必须前面的路径都存在，mkdirs不用。删除文件夹时，文件夹必须是空的。

一些常用操作代码：

  1. package com.easy723;
  2.  
  3. import java.io.File;
  4. import java.io.IOException;
  5.  
  6. public class EasyFile {
  7.     //java中对文件的处理
  8.     //java.io包
  9.     public static void main(String[] args) {
  10.         //在java中声明一个文件  传入字符串当作文件地址
  11.         File f=new File("D:\\easy.txt");
  12.         //是否存在该文件
  13.         boolean bool=f.exists();
  14.         System.out.println(bool);
  15.  
  16.         //创建文件
  17.         if (!bool){
  18.             try {
  19.                 bool=f.createNewFile();
  20.                 if (bool){
  21.                     System.out.println("成功创建文件");
  22.                 }
  23.             }catch (IOException e){
  24.                 e.printStackTrace();
  25.             }
  26.         }else {
  27.             //删除文件夹时，文件夹必须是空的文件夹
  28.             bool=f.delete();
  29.             System.out.println("成功删除文件"+bool);
  30.         }
  31.         //获取是否是文件
  32.         bool=f.isFile();
  33.         System.out.println(bool);
  34.         //是否是文件夹
  35.         bool=f.isDirectory();
  36.         System.out.println(bool);
  37.         //创建文件
  38.         //mkdir创建必须前面的路径都存在，mkdirs不用
  39.         //f.mkdir();
  40.  
  41.  
  42.     }
  43. }

IO流（输入/输出流）

流：流动的数据，是二进制。

分类：根据流动的方向不同：输入流（向java程序流）和输出流。

根据流动的介质（单位）不一样：字符流和字节流（字符流只能读取文本txt .xml .html .properties。字节流可以读取所有的文件类型）。

根据功能（作用）不一样：节点流和工具流    （打印流 数据流  对象流）

总结：创建对象的方式

1.new     2.克隆      3.反序列化       4.反射

序列化和反序列化：

序列化：将内存对象转换成序列（流）。这个对象必须是可序化的。

优点：

实现了数据的持久化，通过序列化可以把数据持久地保存在硬盘上(磁盘文件)。

利用序列化实现远程通信，在网络上传输字节序列。

反序列化：将对象序列读入程序，转换成对象的方式。反序列化会创建新对象，与之前的不是一个数据。

工具流：

1.转换流

字符流比字节流在操作上更加方便，Java提供了转换流来实现字节流向字符流的转换。

2.缓冲流

缓冲流：增强基本流的功能，在基本流的基础上演变而来。
按照数据类型进行分类分为：
字节缓冲流：BufferedInputStrem  BufferedOutputStream
字符缓冲流：BufferedReader  BufferedWriter

缓冲流的基本原理：是在创建流对象时会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统的IO次数，提高读写的效率。

代码：

  1. package com.easy723;
  2.  
  3. import com.sun.xml.internal.ws.policy.privateutil.PolicyUtils;
  4.  
  5. import java.io.*;
  6.  
  7. public class EasyFileIO {
  8.     //IO 输入流/输出流
  9.     //流动的是数据  二进制
  10.     //分类：根据流动的方向不同   输入流（向java程序流）  输出流
  11.     //根据流动的介质（单位）不一样   字符流和字节流
  12.     //字符流只能读取文本txt .xml .html .properties
  13.     //字节流可以读取所有的文件类型
  14.     //根据功能（作用）不一样    节点流和工具流    打印流 数据流  对象流
  15.     public static void main(String[] args) {
  16.         //字节输入流
  17.         InputStream is;
  18.         //字节输出流
  19.         OutputStream os;
  20.         //字符输入流
  21.         Reader r;
  22.         //字符输出流
  23.         Writer w;
  24.         //
  25.         //readFile();
  26.         //writeFile();
  27.         //readFileBuffer();
  28.         //writeObject();
  29.         readObject();
  30.         //总结：创建对象的方式
  31.         //1.new
  32.         //2.克隆
  33.         //3.反序列化
  34.         //4.反射
  35.     }
  36.     public static void readObject(){
  37.         //将对象序列读入程序，转换成对象的方式：反序列化
  38.         //反序列化会创建新的对象
  39.         FileInputStream fis=null;
  40.         ObjectInputStream ois=null;
  41.         try {
  42.             fis=new FileInputStream("D:\\easy.txt");
  43.             ois=new ObjectInputStream(fis);
  44.             Object obj=ois.readObject();
  45.             System.out.println(obj);
  46.  
  47.         }catch (Exception e){
  48.             e.printStackTrace();
  49.         }finally {
  50.             if (ois!=null){
  51.                 try {
  52.                     ois.close();
  53.                 }catch (IOException e){
  54.                     e.printStackTrace();
  55.                 }
  56.             }
  57.             if (fis!=null){
  58.                 try {
  59.                     fis.close();
  60.                 }catch (IOException e){
  61.                     e.printStackTrace();
  62.                 }
  63.             }
  64.         }
  65.     }
  66.     public static void writeObject(){
  67.         //将内存对象转换成序列（流），叫做序列化
  68.         //这个对象必须是可序列化的
  69.         Staff staff=new Staff();
  70.         staff.name="张三";
  71.         staff.sex="男";
  72.         staff.salary=3500;
  73.         ObjectOutputStream oos=null;
  74.         FileOutputStream fos=null;
  75.         try {
  76.             fos=new FileOutputStream("D:\\easy.txt");
  77.             oos=new ObjectOutputStream(fos);
  78.             oos.writeObject(staff);
  79.         }catch (IOException e){
  80.             e.printStackTrace();
  81.         }finally {
  82.             if (oos!=null){
  83.                 try {
  84.                     oos.close();
  85.                 }catch (IOException e){
  86.                     e.printStackTrace();
  87.                 }
  88.             }
  89.             if (fos!=null){
  90.                 try {
  91.                     fos.close();
  92.                 }catch (IOException e){
  93.                     e.printStackTrace();
  94.                 }
  95.             }
  96.         }
  97.     }
  98.     public static void writeFile(){
  99.         String str="哈哈哈哈哈";
  100.         byte[] arr=str.getBytes();
  101.         FileOutputStream fos=null;
  102.         try {
  103.             fos=new FileOutputStream("D:\\easy.txt",true);
  104.             fos.write(arr);
  105.         }catch (IOException e){
  106.             e.printStackTrace();
  107.         }finally {
  108.             if (fos!=null){
  109.                 try {
  110.                     fos.close();
  111.                 }catch (IOException e){
  112.                     e.printStackTrace();
  113.                 }
  114.             }
  115.         }
  116.     }
  117.     public static void readFileBuffer(){
  118.         FileInputStream fis=null;//文件字节输入流
  119.         // 工具流
  120.         //转换流：字节流转换成字符流
  121.         InputStreamReader isr=null;
  122.         //缓冲流：
  123.         BufferedReader br=null;
  124.         try{
  125.             fis=new FileInputStream("D:\\easy.txt");
  126.             isr=new InputStreamReader(fis);
  127.             br=new BufferedReader(isr);
  128.             String line=br.readLine();
  129.             System.out.println(line);
  130.         }catch (IOException e){
  131.             e.printStackTrace();
  132.         }finally {
  133.             if (fis!=null){
  134.                 try {
  135.                     fis.close();
  136.                 }catch (IOException e){
  137.                     e.printStackTrace();
  138.                 }
  139.             }
  140.         }
  141.     }
  142.     public static void readFile(){
  143.         FileInputStream fis=null;
  144.         try{
  145.             fis=new FileInputStream("D:\\easy.txt");
  146.             byte[] arr=new byte[6];
  147.             //读取多少转换多少
  148.             int length=0;
  149.             while((length=fis.read(arr))!=-1){
  150.                 //arr中就是读取的数据
  151.                 String str=new String(arr,0,length);
  152.                 //或者String.valueOf(arr);
  153.                 System.out.print(str);
  154.             }
  155.         }catch (IOException e){
  156.             e.printStackTrace();
  157.         }finally {
  158.             if (fis!=null){
  159.                 try{
  160.                     fis.close();
  161.                 }catch (IOException e){
  162.                     e.printStackTrace();
  163.                 }
  164.             }
  165.         }
  166.     }
  167. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/907311
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号