关于java:2021乐字节常用类

异样(Exception) 即例外，程序没有按本人料想的后果运行进去，呈现了非正常状况，即“程序得病了”。怎么让咱们写的程序做出正当的解决，不至于解体是咱们关注的外围。异样机制就是当程序呈现谬误，程序如何平安退出的机制。

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

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-4XIQC3AW-1607410455373)(/ 图片 1 (2)].png)

Java 异样类是 Java 提供的用于处理程序中谬误的一种机制。设计良好的程序应该在异样产生时提供解决这些谬误的办法，使得程序不会因为异样的产生而阻断或产生不可预感的后果。

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

当 Java 运行时零碎接管到异样对象时，会寻找能解决这一异样的代码并把以后异样对象交给其解决，这一过程称为 捕捉（catch）异样。

JDK 中定义了很多异样类，这些类对应了各种各样可能呈现的例外事件。我开着车走在路上，一头猪冲在路两头，我刹车，这叫一个异样。我开着车在路上，发动机坏了，我停车，这叫谬误。零碎处于不可复原的解体状态。发动机什么时候坏？咱们一般司机能管吗？不能。发动机什么时候坏是汽车厂发动机制造商的事。

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-VBFYzHNn-1607410455377)(/ 图片 2 (2)].png)

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 要求编写可能产生这类异样的程序代码时，肯定要去做异样的解决。

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

对于编译（非运行）时异样（checked exception），必须要对其进行解决，否则无奈通过编译。解决形式有两种：

异样捕捉
异样解决

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-b9KLbjev-1607410455385)(/ 图片 4.png)]

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 语句中能够进行资源的革除工作，如：

敞开关上的文件

删除临时文件

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-1OMiU5XT-1607410455389)(/ 图片 5.png)]

在产生异样的办法申明前面写上 throws 某一个 Exception 类型，如 throws Exception，将异样抛出到里面一层去

异样与重写 申明

子类申明的异样范畴不能超出父类的异样范畴

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-GVtjAfxW-1607410455393)(/ 图片 6.png)]

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

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-ctTbpyG9-1607410455395)(/ 土拍你 7.png)]

应用自定义异样个别有如下步骤：

1、通过继承 java.lang.Exception 类申明本人的异样类

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

3、在办法申明局部用 throws 语句申明该办法可能抛出的异样

1）String

不可变的字符序列

2）StringBuffer

可变字符序列，并且线程平安，然而效率低

3）StringBuilder

可变字符序列，线程不平安，然而效率高（个别用他！）

因为应用特地多，所以有非凡快捷的创立形式通过双引号 "" 间接创建对象

构造方法

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-w2FmjG0h-1607410455397)(/ 图片 8.png)]

罕用办法

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-YeV3qCg2-1607410455398)(/ 图片 9.png)]

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-QS5OH68K-1607410455400)(/ 图片 10.png)]

还有 valueOf()系列，能够将根本类型的数据转为字符串，当然个别不必这么麻烦

字符串宰割 split()

这两个类应用形式相似。个别用于做字符串拼接，删除，替换，反转，截取，插入等。

通过查看源码，意识 StringBuffer 和 StringBuilder 的结构形式，以及与 String 的转换形式

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

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-gYB0puMF-1607410455402)(/ 图片 16.png)]

在这八个类名中，除了 Integer 和 Character 类当前，其它六个类的类名和根本数据类型始终，只是类名的第一个字母大写即可。

对于包装类说，这些类的用处次要蕴含两种：

a、作为和根本数据类型对应的类类型存在，不便波及到对象的操作。

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

包装类和根本类型之间存在主动装箱和主动拆箱操作，所以能够相互不便地切换。

作为与咱们非亲非故的日期，在开发中也是很常见的。在程序中，日期的存储也是个数字，是个长整型的数字。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 等等，因而就波及到如何将长整型数与字符串互转的问题，这也是学习的重点。

类	常见办法
System<br/> 零碎类	currentTimeMillis(): 以后工夫
Date<br/> 日期类	new Date() : 以后工夫 new Date(指定工夫): 指定工夫 getTime(): 获取工夫 <br/>setTime(指定工夫): 设置指定工夫
SimpleDateFormat<br/> 格局器	new SimpleDateFormat(模板) format() : 格式化为字符串 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 中有具体阐明

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-U5cktGRQ-1607410455404)(/simple-pattern.png)]

字符串的示意模式与日期调换，应用日期转换器 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>

(1) jdk8 的日期类

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

类	常见办法
Year 年	now(): 往年
Month<br/> 月	JANUARY: 一月 <br/>FEBRUARY 二月 <br/>..
LocalDate<br/> 本地日期	now()：不蕴含时分秒的本时区的以后工夫 of(年，月，日): 构建本时区的工夫
LocalDateTime<br/> 本地工夫	now()：蕴含时分秒的本时区的以后工夫 of(年，月，日，时，分，秒): 构建本时区的工夫 <br/>format() : 格式化为字符串 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(模板):

// 日期转换器
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 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());

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

[外链图片转存失败, 源站可能有防盗链机制, 倡议将图片保留下来间接上传(img-0ZBtXAmn-1607410455405)(/ 图片 17.png)]

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);    
        }  
    }   
}

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);    
    }  
}

}

关于java:2021乐字节常用类

第一节异样

1. 异样的概念

2. 异样的分类

Runtime Exception

CheckException(** 须要解决的)

3. 异样解决

1）异样产生

2）异样捕捉 try catch finally

3）向外申明(抛出) 异样 throws

4. 应用自定义的异样

1）概念

2）步骤

第三节罕用类

1. 字符串相干类

1）String

构造方法

罕用办法

2）StringBuffer 和 StringBuilder

2. 包装类

3. 日期类

1) pre8 罕用日期相干类

(1) 以后工夫

(2) Date

(3) SimpleDateFormat

2) 8 日期相干的罕用 api

(1) jdk8 的日期类

(2) jdk8 的格式化类

(3) jdk8 的距离类

4. Math 类

5.File 类

第一节 异样

1. 异样的概念

2. 异样的分类

Runtime Exception

CheckException(** 须要解决的)

3. 异样解决

1）异样产生

2）异样捕捉 try catch finally

3）向外 申明(抛出) 异样 throws

4. 应用自定义的异样

1）概念

2）步骤

第三节 罕用类

1. 字符串相干类

1）String

构造方法

罕用办法

2）StringBuffer 和 StringBuilder

2. 包装类

3. 日期类

1) pre8 罕用日期相干类

(1) 以后工夫

(2) Date

(3) SimpleDateFormat

2) 8 日期相干的罕用 api

(1) jdk8 的日期类

(2) jdk8 的格式化类

(3) jdk8 的距离类

4. Math 类

5.File 类

第一节异样

3）向外申明(抛出) 异样 throws

第三节罕用类