异常是什么？什么是常用类?

第一节异常

1. 异常的概念

异常(Exception) 即例外，程序没有按自己预想的结果运行出来，出现了非正常情况，即“程序得病了”。怎么让我们写的程序做出合理的处理，不至于崩溃是我们关注的核心。异常机制就是当程序出现错误，程序如何安全退出的机制。

所谓错误是指在程序运行的过程中发生的一些例外事件（如：除0，数组下标越界，所要读取的文件不存在）。

在这里插入图片描述

Java异常类是Java提供的用于处理程序中错误的一种机制。设计良好的程序应该在异常发生时提供处理这些错误的方法，使得程序不会因为异常的发生而阻断或发生不可预见的结果。

Java程序的执行过程中如出现例外事件，可以生成一个异常类对象，该异常对象封装了例外事件的信息并将被提交给Java运行时系统，这个过程称为抛出( throw )异常。

当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获（catch）异常。

2. 异常的分类

JDK中定义了很多异常类，这些类对应了各种各样可能出现的例外事件。我开着车走在路上，一头猪冲在路中间，我刹车，这叫一个异常。我开着车在路上，发动机坏了，我停车，这叫错误。系统处于不可恢复的崩溃状态。发动机什么时候坏？我们普通司机能管吗？不能。发动机什么时候坏是汽车厂发动机制造商的事。

![图片2 (2)].png](https://img-blog.csdnimg.cn/20200525215259992.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RpcmZ0X2Rpbg==,size_16,color_FFFFFF,t_70#pic_center)

Error:称为错误，由Java虚拟机生成并抛出，包括动态链接失败、虚拟机错误等，程序对其不做处理。Error 类层次描述了 Java 运行时系统内部错误和资源耗尽错误。这类错误是我们无法控制的，同时也是非常罕见的错误。所以在编程中，不去处理这类错误。Error 表明系统 JVM 已经处于不可恢复的崩溃状态中。我们不需要管他。如:写代码时突然断电，或者内存溢出。

Exception:所有异常的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显示地声明或捕获。

Runtime Exception

Runtime Exception类是 Exception 类的子类，叫做运行时异常，Java 中的所有运行时异常都会直接或者间接地继承自 RuntimeException 类。

这一类特殊的异常，如被0除、数组下标超范围等，其产生比较频繁，处理麻烦，如果显示的声明或捕获将会对程序可读性可运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不必对其处理）;我们可以通过程序的健壮性来处理，不推荐使用异常处理机制来处理。

例如：

NullPointerException: 当程序访问只有引用没有对象的成员属性或成员方法。怎么处理？

ArithmeticException: 除数为 0ClassCastException:多态时类型转换错误

ArrayIndexOutOfBoundsException: 访问的元素下表超过数组长度

NumberFormatException: 数字格式异常！

CheckException(**需要处理的)

Java 中凡是继承自 Exception，而不继承自 RuntimeException 类的异常都是非运行时异常，也叫检查时异常。如:IOException。必须要对其进行处理，否则无法通过编译。这类异常的产生不是程序本身的问题，通常由外界因素造成的。为了预防这些异常产生时，造成程序的中断或得到不正确的结果，Java 要求编写可能产生这类异常的程序代码时，一定要去做异常的处理。

3. 异常处理

1）异常产生

之所以出现异常，是因为内部抛出了异常对象，这个异常对象的产生分为系统内部产生，或程序员手动抛出异常。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b8dbn29W-1590414500703)(/图片3.png)]

2）异常捕获 try catch finally

对于编译（非运行）时异常（ checked exception ），必须要对其进行处理，否则无法通过编译。处理方式有两种：

异常捕获
异常处理

在这里插入图片描述

try代码段包含可能产生例外的代码

try代码段后跟有一个或多个catch代码段

每个catch代码段声明其能处理的一种特定类型的异常并提供处理的方法

当异常发生时，程序会中止当前的流程，根据获取异常的类型去执行相应的catch代码段

一个 try 后面可以跟多个 catch，但不管多少个，最多只会有一个catch 块被执行。

finally段的代码无论是否发生异常都有执行

try语句

try{…}语句制定了一段代码，该段代码就是一次捕获并处理意外的范围。

在执行过程中，该段代码可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理。

如果没有意外产生，所有的catch代码段都被略过不执行。

catch语句

在catch语句块中是对异常进行处理的代码，每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。

在catch中声明的异常对象封装了异常事件发生的信息，在catch语句块中可以使用这个对象的一些方法获取这些信息。

例如：

getMessage()方法，用来得到有关异常事件的信息

printStackTrace()方法，用来跟踪异常事件发生时执行堆栈的内容

finally语句

finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其它部分以前，能够对程序的状态作统一的管理。无论try所制定的程序块中是否抛出异常，finally所指定的代码都要被执行。

通常在finally语句中可以进行资源的清除工作，如：

关闭打开的文件

删除临时文件

3）向外声明( 抛出) 异常 throws

图片5.png

在产生异常的方法声明后面写上 throws 某一个 Exception 类型，如 throws Exception，将异常抛出到外面一层去

异常与重写声明

子类声明的异常范围不能超出父类的异常范围

在这里插入图片描述

4. 使用自定义的异常

1）概念

所谓自定义异常，通常就是定义一个类，去继承 Exception 类或者它的子类。因为异常必须直接或者间接地继承自 Exception 类。通常情况下，会直接继承自 Exception 类，一般不会继承某个运行时的异常类。

2）步骤

在这里插入图片描述
使用自定义异常一般有如下步骤：

1、通过继承java.lang.Exception类声明自己的异常类

2、在方法适当的位置生成自定义异常的实例，并用throw语句抛出

3、在方法声明部分用throws语句声明该方法可能抛出的异常

第三节常用类

1. 字符串相关类

1）String

不可变的字符序列

2）StringBuffer

可变字符序列，并且线程安全，但是效率低

3）StringBuilder

可变字符序列，线程不安全，但是效率高（一般用他！）

1）String

由于使用特别多，所以有特殊快捷的创建方式通过双引号 "" 直接创建对象

构造方法

在这里插入图片描述

常用方法

在这里插入图片描述

还有 valueOf()系列，可以将基本类型的数据转为字符串，当然一般不用这么麻烦

字符串分割 split()

2）StringBuffer和StringBuilder

这两个类使用方式类似。一般用于做字符串拼接，删除，替换，反转，截取，插入等。

通过查看源码，认识StringBuffer和StringBuilder的构造方式，以及与String的转换方式

2. 包装类

JAVA并不是纯面向对象的语言。Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的。但是我们在实际使用中经常需要将基本数据转化成对象，便于操作。比如：集合的操作中。例如使用Map对象要操作put()方法时，需要传入的参数是对象而不是基本数据类型。为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的类统称为包装类(Wrapper Class)。包装类均位于java.lang包

在这里插入图片描述

在这八个类名中，除了Integer和Character类以后，其它六个类的类名和基本数据类型一直，只是类名的第一个字母大写即可。

对于包装类说，这些类的用途主要包含两种：

a、作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。

b、包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法（这些操作方法的作用是在基本类型数据、包装类对象、字符串之间提供转化！）。

包装类和基本类型之间存在自动装箱和自动拆箱操作，所以可以互相方便地切换。

3. 日期类

作为与我们息息相关的日期，在开发中也是很常见的。在程序中，日期的存储也是个数字，是个长整型的数字。0代表1970年1月1日 00:00:00，而我们处于东八区，所以为1970年1月1日 08:00:0 ，往前推，负数表示之前的时间，往后算正数表示之后的时间。

而在日常中，我们表示日期是使用字符串表示，如 1970年1月1日 08:15 、 1970/01/01 08:15 1970-01-01 08:15 等等，因此就涉及到如何将长整型数与字符串互转的问题，这也是学习的重点。

1) pre8常用日期相关类

类	常见方法
System<br/>系统类	currentTimeMillis(): 当前时间
Date<br/>日期类	new Date() :当前时间<br />new Date(指定时间):指定时间<br />getTime(): 获取时间<br/>setTime(指定时间):设置指定时间
SimpleDateFormat<br/>格式器	new SimpleDateFormat(模板)<br />format() : 格式化为字符串<br />parse():转成日期

(1) 当前时间

//当前毫秒数
long timeNum =System.currentTimeMillis();
System.out.println(timeNum);
//当前日期
Date nowDate =new Date();
System.out.println(date);

(2) Date

//0 时间点  东八区 1970年1月1日 08:00:0 
Date date =new Date(0L);
System.out.println(date);
//指定一个时间
Date myDate =new Date(189712329239L);
System.out.println(myDate);
System.out.println(myDate.getTime()); //获取长整型数字
//修改时间
myDate.setTime(0L);
System.out.println(myDate);

(3) SimpleDateFormat

日期格式化，在日期格式化的过程中，会用到模板，这个在api中有详细说明

在这里插入图片描述

字符串的表示形式与日期互换，使用日期转换器SimpleDateFormat ，代码如下:

public static void main(String[] args) throws ParseException {
    Date myDate2 =new Date(0L);
    //字符串的形式
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //转字符串
    String dateStr =dateFormat.format(myDate2);
    System.out.println(dateStr);
    //转成日期
    myDate = dateFormat.parse("2020-02-25 11:16:30"); //这里有异常
    System.out.println(myDate.getTime());
}

<span style="font-size:20px;color:red;background:#ff0">注意parse()存在的异常ParseException </span>

2) 8日期相关的常用api

(1) jdk8的日期类

java8提供了更为简介的，更明了的常用日期类

类	常见方法
Year<br />年	now():今年
Month<br/>月	JANUARY:一月<br/>FEBRUARY二月<br/>..
LocalDate<br/>本地日期	now()：不包含时分秒的本时区的当前时间<br />of(年，月，日):构建本时区的时间
LocalDateTime<br/>本地时间	now()：包含时分秒的本时区的当前时间<br />of(年，月，日，时，分，秒):构建本时区的时间<br/>format() : 格式化为字符串<br />parse():转成日期

//今年
System.out.println("今年"+Year.now());
//6月
System.out.println("月份:"+Month.FEBRUARY);
//今天不包含时分秒
LocalDate today = LocalDate.now();
System.out.println("今天:"+today);
//此时此刻
LocalDateTime now = LocalDateTime.now();
System.out.println("现在:"+now);
//您的生日
LocalDate yourBirthDate = LocalDate.of(1999, Month.JUNE, 15);
System.out.println("生日:"+yourBirthDate);
//您的学习时间
LocalDateTime dateTime = LocalDateTime.of(2020, 2, 25, 12, 30,40);
System.out.println("时间:"+dateTime);

(2) jdk8的格式化类

类	常见方法
DateTimeFormatter<br/>格式器	ofPattern(模板):<br />

//日期转换器
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//格式化日期字符串
LocalDateTime now = LocalDateTime.now();
String nowStr = now.format(formatter);  //放入格式器
System.out.println(nowStr);

String dateStr= "2020-02-25 11:23:04";
//转成日期 
LocalDateTime date= LocalDateTime.parse(dateStr, formatter);//放入格式器
//获取日
System.out.println(date.getDayOfMonth());

(3) jdk8的间隔类

java8提供了方便计算的间隔相关的类 ,<span style="font-size:20px;color:red;background:#ff0">这部分了解即可。</span>

类	常见方法
Period<br/>时期	between():间隔年月日
Duration<br/>持续期间	ofDays(天数):天<br/>ofHours(小时数):时<br/>ofMinutes(分钟数):分<br/>ofSeconds(秒数):秒
Instant<br/>瞬间	now():现在<br/>plus():添加<br/>minus():相减
ChronoUnit<br/>期量单位	YEARS、MONTHS、DAYS、HOURS、MINUTES、SECONDS<br/>getDuration() ：获取Duration<br />between():间隔

LocalDate today = LocalDate.now();
LocalDate birthDate = LocalDate.of(1999, 3, 15);
//时期间隔 年月日
Period p = Period.between(birthDate, today);
System.out.printf(p.getYears()+"年"+p.getMonths()+"d"+p.getDays()+"日");

LocalDate startDate = LocalDate.of(1993, 8, 19);
LocalDate endDate = LocalDate.of(1994, Month.JANUARY,16);
//期量单位 间隔
long between =ChronoUnit.YEARS.between(startDate, endDate);     
System.out.println("两年之间的差   : " + between); //0 不是1不满一年不计算在内
between =ChronoUnit.MONTHS.between(startDate, endDate);     
System.out.println("两月之间的差   : " + between); //4 不是5不满一月不计算在内       

//瞬间 
Instant inst1 = Instant.now();
Instant inst2 = inst1.minus(Duration.ofSeconds(10));
System.out.println("毫秒相隔 : " + Duration.between(inst1, inst2).toMillis());
System.out.println("秒相隔 : " + Duration.between(inst1, inst2).getSeconds());

4. Math类

java.lang.Math 提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为 double 型。

在这里插入图片描述

5.File类

File 代表文件和目录路径名的抽象表示形式

File 类的常见构造方法：public File(String pathname)

以 pathname 为路径创建 File 对象，如果 pathname 是相对路径，则默认的当前路径在系统属性 user.dir 中存储。 File 的静态属性 separator 存储了当前系统的路径分隔符。

常见的方法

 public boolean canRead()     
 public boolean canWrite()     
 public boolean exists()      
 public boolean isDirectory()    
 public boolean isFile()      
 public boolean isHidden()     
 public long lastModified()  
 public long length() 
 public String getName()      
 public String getPath()

代码示例

import java.io.File; 
/**  * 程序  -->文件 需要建立联系  * 抽象为 File 类 
 *   * 1、文件夹 与文件  抽象-->File  * 2、分割符:  *    路径分隔符:  ; pathSeparator   *    目录分隔符:  \   /   separator   *    静态常量: 
 *   * 1、构建 File 
   File(String pathname)  
 * File(File parent, String child)  
 * File(String parent, String child)  
 * 
 */ 

public class FileDemo01 { 

 /** 
  * @param args 
  */ 
 public static void main(String[] args) { 
  System.out.println(File.pathSeparator); 
  System.out.println(File.separator); 
  //绝对路径 与文件建立联系 
  File src = new File("E:\\test\\03.gif"); 
  src = new File("E:/test/03.gif"); 
  src = new File("E:"+File.separator+"test"+File.separator+"03.gif"); 

  System.out.println(src.exists()); 
     //相对路径 
  File src2 = new File("E:/test","03.gif"); 
  src2 = new File(new File("E:/test"),"03.gif"); 
  System.out.println(src.exists()); 
 } 
}

import java.io.File; 
import java.io.FilenameFilter; 
import java.io.IOException; 

/**  * 1、创建对象  new File(完整路径)   -->绝对路径  new File(上级路径，本名); -->相对路径   new File(上级抽象表示形式, 本名)  2、方法 1)区分目录 or 文件 
isFile() isDirectory() 2)获取路径 名称 
 getPath() 
 getAbsolutePath() 
 getName()   3)判断文件是否存在 
 exists()   4)创建文件 
 createNewFile()   5)创建目录  mkdir() -->创建一层，确保父路径存在，如果父路径不存在，不能创建 mkdirs() -->父路径不存在，全部创建 6)列表 
listFiles() 7)删除文件 
delete()  
 * 
 * 
 */ 
public class FileDemo02 { 

 public static void main(String[] args) throws IOException { 
  File src2 = new File("E:/test","03.gif");   boolean flag =src2.isFile(); //是否为文件 
   flag =src2.isDirectory(); 
  System.out.println(flag);   //获取文件名称或路径 
  String name = src2.getName(); 
  System.out.println(name); 
  String path = src2.getPath(); 
  path = src2.getAbsolutePath(); 
  System.out.println(path); 
     //文件是否存在 
  flag = src2.exists();   if(!flag){ //不存在创建 
   src2.createNewFile(); 
  }   //创建目录 
  src2 = new File("E:/test/test2/test3");   src2.mkdir(); //确保父路径存在，才能创建   src2.mkdirs();// 如果父路径不存在，则创建 
     //列出当前文件夹的子目录 
  src2 = new File("E:/xp/20130401");   if(src2.isDirectory()){ //目录才有子目录 
   File[] subFiles = src2.listFiles(new FilenameFilter(){ 

    @Override 
    public boolean accept(File dir, String name) { 
     /* 
     System.out.println(name); 
     if(name.contains("xls")){ 
      return true; 
     }*/ 

     return !new File(dir,name).isDirectory(); 
    } 
   }); 
   for(File temp:subFiles){ 
    System.out.println(temp); 
   } 
  } 
  //delete()  
  src2 = new File("E:/test","03.gif"); 
  boolean flag2 =src2.delete(); 

  System.out.println(flag2); 
 } 
}

通过 File 对象创建空文件或目录（在该对象所指的文件或目录不存在的情况下）。

public boolean createNewFile()throws IOException     
public boolean delete()  
public boolean mkdir()
mkdirs()

/** *递归打印文件夹  */  
public static void printName(File src){   
    if(null ==src){    
        return;   
    }   
    System.out.println(src.getPath());     
    if(src.isDirectory()){    
        for(File sub:src.listFiles()){     
            printName(sub);    
        }  
    }   
}