API 介绍

Java API介绍

1.1 Java API提供的常用包如下：

包	描述
java.lang	编写Java程序时最广泛使用的包，自动导入所有的程序中，包含了Java程序的基础类和接口。包装类、String类等常用的类都包含在此包中，还提供了用于管理类的动态加载、外部进程创建、主机环境查询和安全策略实施等系统操作的类
java.util	包含系统辅助类，特别是Collection、List和Map等集合类
java.time	包含对日期时间进行处理的类，如创建日期对象，格式化日期等
java.io	包含与输入/输出有关的类，如文件操作等类
java.net	包含与网络有关的类，如Socket、ServerSocket等类
java.sql	包含与数据库相关的类，如Connection、Statement等类

1.2 枚举

1.2.1 枚举概述

事先考虑到某一变量可能的取值，尽可能用自然语言中表意清楚的单词来表示他的每一个值，用这种思路定义的类型被称为枚举类型

枚举是由一组固定的常量组成的类型。在Java中每个枚举都继承java.lang.Enum类,使用关键字enum定义，定义枚举的语法如下：

访问修饰符 enum 枚举名{
    常量1[，常量2.............[;]]
        //[其他成员]
}

通常，使用枚举表示一组有限的值，实现对输入的值进行约束

• 在枚举中可以定义多个常量，表示不同的枚举值，即枚举元素，之间用逗号隔开
• 在枚举中可以定义其他成员，包括构造方法等，置于枚举常量之后
• 可以使用“枚举名.常量名”的形式取出枚举中的指定内容
  定义表示性别的枚举，两个枚举常量分别代表“男”和“女”，实例如下

public enum Genders {
    Male,Female;
}

定义一个枚举包括七个枚举常量，代表一周中的七天，编写一周中每天的日程安排代码如下

枚举类

public enum Week {
    MOn,TUE,WED,THU,FRI,SAT,SUN;
}

方法类

public class Demo01 {
public void doWhat(Week day){//参数是给day传值
    //查看日程安排
    switch (day){//获取传给doWhat的值
        case MOn :
        case TUE:
        case WED:
        case THU:
        case FRI:
            System.out.println("工作日写代码");
            break;
        case SAT:
            System.out.println("星期六，休息看电影！");
            break;
        case SUN:
            System.out.println("星期日，休息！打篮球");
            break;
        default:
            System.out.println("一周活七天就够了");
            break;
    }
}
}

实现类

public class Test {
    public static void main(String[] args) {
        //方法1
       Demo01 demo01=new Demo01();//创建Demo01对象
       demo01.doWhat(Week.THU);//将常量取出来传给方法
       Week week=Week.SAT;//取出枚举中的某个方法
       demo01.doWhat(week);//将枚举中的某个方法传给实现类的方法
        //方法二循环全部
        //循环将Week的值传给实现类的方法
        //使用枚举类型的values()方法可以实现对枚举值的遍历操作
         Demo01 demo01=new Demo01();
        for (Week week:Week.values()){
            demo01.doWhat(week);
        }
    }
}

枚举类型Week存储一周七天枚举的常量，使用“Week.变量”可输出表示星期几的枚举类。switch结构传入的变量day是Week类型，及枚举类型:case关键字后的常量要与之匹配，必须是Week中定义的枚举常量

在上边方法中values()方法表示取得枚举中全部内容，返回一个对象数组，这是枚举本身支持的一个方法

注意

在switch结构中可以使用枚举类型作为判断变量，此时需注意，case关键字后一定不能在枚举值前加枚举类型名，如Week.THU，则会出现编译错误

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cjljEU0z-1676909103144)(C:/Users/%E5%BA%B7%E5%BA%B7/AppData/Roaming/Typora/typora-user-images/image-20230216110436703.png)]

enum关键字表示的是java.lang.Enum类型，即使用enum声明的枚举类型，就相当于定义一个类，此类默认继承java.lang.Enum类，因此可使用其中定义的所有方法，如想深入了解可以去API文本自定查阅

1.2.2枚举的好处

• 枚举可以使代码更易于维护，有助于确保为变量指定合法的、期望的值
• 使用枚举赋值，只需输入枚举名和"."，就可显示所有枚举值
• 枚举使代码更加清晰，允许用描述性的名称表示数据，使用时直观方便

1.2.3 枚举的方法

每一个枚举类型成员都可被看作Enum对象。所有枚举实例都可以调用Enum类的方法，实现枚举的遍历，比较等操作

枚举的常用方法

方法	描述
T[] values()	以数组形式返回枚举类型的所有成员
T valueOf()	将普通字符串转换为枚举实例
int compareTo()	比较两个枚举成员在定义时的顺序,结果为负整数、零或正整数，表示当前对象小于、等于或大于指定对象
int ordinal()	获取枚举成员的索引位置

综合使用枚举类常用的方法，实现枚举的遍历和比较等操作

星期枚举

public enum Week {
    MON,TUE,WED,THU,FRI,SAT,SUN;
}

测试类

public class Test {
    public static void main(String[] args) {
        //遍历枚举
        System.out.println("*********遍历枚举元素************");
        for (Week week:Week.values()){
            System.out.println(week);
        }
        //获取枚举的个数
        System.out.println("*********获取枚举的个数************");
        System.out.println("一周有"+Week.values().length+"天");
        //使用索引遍历枚举元素
        System.out.println("*********使用索引遍历枚举元素************");
        for (int i = 0; i <Week.values().length; i++) {
            System.out.println("索引"+Week.values()[i].ordinal()+",值"+Week.values()[i]);
        }
        //枚举元素比较
        System.out.println("*********枚举元素比较************");
        System.out.println((Week.valueOf("MON")).equals(Week.MON));
        System.out.println(Week.FRI.compareTo(Week.MON));
    }
}

运行结果如下

1.3 包装类

1.3.1 包装类概述

Java是面向对象的编程语言，但它的基本数据类型是不支持面向对象的机制，不具备面向对象特征，他们为程序开发带来了一定的方便性，如可以进行有效、常规的数据处理、但有些时候会受到一些制约

例如：所有引用类型的变量都继承Object类，可以当作Object类型变量使用，但基本数据类型不可以，如果方法的参数是Object类型，但实际上需要的数据是类似2、3这样的数值，就比较难处理

import java.util.ArrayList;

public class Demo02 {
    public static void main(String[] args) {
        ArrayList arrayList=new ArrayList();
        arrayList.add("香水梨");
        arrayList.add("苹果梨");
        arrayList.add(5);
        arrayList.add(2.8);
        arrayList.add('甜');
    
    }
}

代码中使用了包装类。包装类是指将基本数据类型封装到一个类中，也就是将基本类型包装成一个类类型。Java程序设计语言为每一种基本类型都提供了一个包装类，而这些包装类存在于java.lang包中，共有八个包装类。

1.3.2 包装类关系图

• 所有数据类型包装类都继承Number类，Number类是一个抽象类

• Number类包装了Byte、Short、Interger、Long、Float、Double等数据类型，并且实现其所定义的方法，这些方法以不同的数字格式返回对象的值

  1.3.3 包装类和基本数据类型的对应关系

类型	长度	默认值	包装类
Byte	8位	0	java.lang.Byte
short	16位	0	java.lang.Short
int	32位	0	java.lang.Integer
long	64位	0	java.lang.Long
float	32位	0.0	java.lang.Float
double	64位	0.0	java.lang.Double
char	16位	\u0000~\uFFFF	java.lang.Character
boolean	1位	false,true	java.lang.Boolean

包装类的用途主要有一下两个

• 包装类作为和基本数据类型对应的类型存在，方便对象的操作

• 包装类包含每种基本数据类型的相关属性，如最大值、最小值等，以及相关的操作方法

  1.3.3 包装类的基本方法

  • 基本数据类型转换为包装类

    public Type(type value)

    public Type(String value)

    其中，Type表示包装类，参数type为基本数据类型

  • 使用构造方法将基本数据类型值包装为包装类对象 例如要创建一个Integer类型的包装类对象

    Integer intValue=new Integer(21);

    或Integer intValue=new Integer(“21”)

  • 数据类型向包装类转换的用法

    public class Demo03 {
        public static void main(String[] args) {
            boolean b1=true;
            //1.通过构造方法基本的数据类型向包装类转型
            Boolean b1Obj=new Boolean(b1);
            Integer itObj=new Integer(35);
            Character chObj=new Character('男');
            System.out.println(b1Obj+","+itObj+","+chObj);
            //2.将字符串转换为Boolean对象
            Boolean bObj=new Boolean("true");
            Boolean bObj2=new Boolean("TRue");//不区分大小写
            Boolean bObj3=new Boolean("hello");//非true及false
            System.out.println(bObj+","+bObj2+","+bObj3);
        }
    }    
    

    以上输出结果为：

从以上结果可以看出当试图使用一个字符串来创建Boolean对象时，如果传入的字符串是"true"或不同字母大小写变化形式（如“TRue”），则会创建与true对应的boolean对象，如果传入其他字符串，则会创建与false对应的Boolean对象

调用包装类的valueOf()方法也可实现从基本数据类型到包装类型的转换，可自行查阅API帮助文档学习

​

• 包装类转型为基本数据类型

  包装类型转为基本数据类型通用采用如下方法：

  public type typeValue( );
  

  其中，type指的是基本数据类型，如bytyValue()、charValue()等，相应的返回值为byte、char。等包装类对象转型为基本数据类型，代码如下

包装类转换为基本数据类型

public class Demo03 {
    public static void main(String[] args) {
        boolean b1=true;
        //通过构造器实现基本数据类型向包装类转型
        Boolean b1Obj=new Boolean(b1);
        Integer itObj=new Integer(35);
        Character chObj=new Character('男');
        //包装类转型为基本数据类型
        Boolean bm1=b1Obj.booleanValue();
        int i=itObj.intValue();
        char ch=chObj.charValue();
        System.out.println(bm1+","+i+","+ch);
    }
}

效果图如下

基本数据类型变量和包装类对象间的转换关系

基本数据类型变量转包装类对象 Type（type value）/ Type (String value)

包装类对象转基本数据类型变量 type.Value()

1.4 装箱拆箱

Java基本数据类型变量和包装类对象之间的转换较繁琐，从JDK1.5之后提供了自动装箱（Autoboxing）和自动拆箱（AutoUnboxing）功能

• 自动装箱：把基本数据类型变量直接转换为对应的包装类对象，或者转换为Object对象

• 自动拆箱：与装箱相反，将包装类对象转换成对应的基本数据类型变量

  自动装箱和自动拆箱操作如下

public class Demo03 {
    public static void main(String[] args) {
       //基本数据类型变量转换为包装类（装箱）
        Integer inObj=5;
        Object boolObj=true;
        System.out.println(inObj+","+boolObj);
        //包装类转换为基本数据类型（拆箱）
        int it=inObj;
        System.out.println(it);
        if(boolObj instanceof Boolean){
            //先把Object对象强制转换为Boolean类型，在赋值给boolean变量
            boolean b=(Boolean)boolObj;
            System.out.println(b);
        }
    }
}

效果图如下

从以上示例中可以看出当jdk提供了自动装箱/拆箱功能后，大大简化了基本数据类型和和包装类相互转换的过程。但是进行自动装箱/拆箱时必须注意类型匹配。例如，Integer对象只能自动拆箱成int变量，不能试图自动拆箱成boolean类型变量；而int变量也只能自动装箱成Integer对象，不能自动装箱成Boolean对象。即使其可以赋值给Object对象，也只是利用了Java中向上自动转型的特征

注意

虽然Java平台提供了基本数据类型和包装类的自动转换功能，但程序员在程序中不能只使用对象，而抛弃基本数据类型

示例代码如下

Double a,b,c;

a=3;

b=4;

c=a+b;

在语法中是没有任何错误的，使用Double对象计算直角三角形的斜边长，但它的性能存在问题，基本数据类型和包装类对象间的相互转换工作增加了系统的额外负担。如果使用基本数据类型，则不会出现性能问题

包装类对象只能在基本数据类型需要用对象表示时才使用，包装类并不是用来取代基本数据类型的

1.5 日期类

在jdk1.8之前的版本中，所有关于时间和日期的API在使用上的缺陷

• 易用性差，时间的计算方式烦琐
• 不是线程安全的

1.5.1 创建日期对象

在jdk1.8中，日期和时间的类都位于java.time中，他是新的Java日期/时间ＡＰＩ的基础包，这些类都是不可变的、线程安全的在绝大多数情况下，这些能够有效地处理一些公共的需求java.time中表示日期的常用类

类	描述	示例
LocalDate	表示日期（年/月/日），不包含时间	2020/11/24
LocalTime	表示时间（时/分/秒/毫秒），不包含日期	15:32:12
LocalDateTime	表示日期和时间（年/月/日/时/分/秒/毫秒）	2020/11/24 15:32

• 都是不可变的对象
• 提供简单的日期或时间
  • 不包含与时区相关的信息

1.5.2 日期类的通用方法

获取日期时间类型对象的常用方法

方法	描述
日期类 now()	根据当前时间创建对象，返回日期对象
日期类 of(int year Month month, int dayOfMonth)	根据指定日期/时间创建日期类对象
Month getMonth()	获取月份，返回Month，这是一个表示月份的枚举
int getDayOfMonth()	返回当前日期对象的月份天数
int getYear()	返回当前日期对象的年份
日期类 plusDays() 日期类 plusWeeks() 日期类 plusMonths() 日期类 plusYears()	在指定日期基础上添加天数、周数、月数、年数，返回日期类型对象

获取当前日期或之间

LocalDate localDate = LocalDate.now(); //获取当前日期

LocalTime localTime = LocalTime.now(); //获取当前时间

日期格式化

有时需要按照定义的格式输出系统时间，这就需要使用DateTimeFormatter类的相关方法进行日期格式化处理，该类位于java.time.format包中。日期类中的format()方法用于将日期格式化为字符串，该方法接受一个DateTimeFormatter对象，除此之外，DateTimeFormatter类的format()方法也可以实现日期格式化，示例代码如下

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Formatter;

public class Demo04 {
    public static void main(String[] args) {
        LocalDate localDate=LocalDate.now();
        DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yyyy年-MM月-dd日");
        //两种格式化方式
        String ste2=localDate.format(formatter);
        String str1= formatter.format(localDate);
        System.out.println(ste2);
        System.out.println(str1);
    }
}

ofPattern()方法用于指定日期格式。参数为格式字符串，该方法的作用是指定日期输出格式

1.5.3 案例示例

根据当前日期，计算农场下次播种时间和收割时间，要求如下：

• 使用不同格式输出当前日期，如"yyyy年MM月dd日HH:mm:ss" “yyyy-MM-dd”

• 分别提取当前日期对应的年、月、日信息并输出

• 输入当前日期距离下次播种还有几个月，计算并输出下次播种时间

• 输入首个时间，并输出到控制台

  import java.time.LocalDate;
  import java.time.LocalDateTime;
  import java.time.format.DateTimeFormatter;
  import java.util.Scanner;
  
  public class Demo04 {
      public static void main(String[] args) {
          //获取现在时间
          LocalDateTime today=LocalDateTime.now();
          //创建格式化器
          DateTimeFormatter fm1=DateTimeFormatter.ofPattern("yyyy年-MM月-dd日 HH:mm:ss");
          DateTimeFormatter fm2=DateTimeFormatter.ofPattern("yyyy-MM-dd");
          //3.将日期格式化为字符串
          String str1=today.format(fm1);
          String str2=today.format(fm2);
          System.out.println("当前日期（日期+时间）"+str1+"。");
          System.out.println("当前日期"+str2+"。");
          //提取日期中的年、月、日信息
          System.out.println("年"+today.getYear()+"月"+today.getMonth()+"日"+today.getDayOfMonth());
          //根据间隔时间输出日期
          System.out.println("距离下次播种大约还有几个月？（1~12间的整数）");
          Scanner input=new Scanner(System.in);
          LocalDateTime future=today.plusMonths(input.nextLong());
          String str3=future.format(fm2);
          System.out.println("下次播种时间约为"+str3);
          //根据输入时间输出
          System.out.println("请输入计划开始收割日期（格式：yyyy-MM-dd）");
          LocalDate ld=LocalDate.parse(input.next());
          String str4=ld.format(fm2);
          System.out.println("收割开始日期为"+str4+"预祝好收成");
      }
  }
  
  

输出结果如下

1.6 Random类

构造方法

方法	描述
Random()	创建一个随机数生成器
Random(long seed)	使用单个long种子创建一个随机数生成器

Random类定义了很多用于获取随机数的方法，最常用的是nextInt()方法，他返回下一个int类型的伪随机数，以下是两个重载方法

int nextInt();
int nextInt(int n);

前者返回下一个伪随机数，它是此随机数生成器序列中均匀分布的int值；后者返回下一个伪随机数，它是取自此随机数生成器序列的、在0(包括)和指定值n(不包括)之间均匀分布的int值。

随机生成十个10以上大于或等于0的整数并将其显示出来，代码如下

import java.util.Random;

public class Random1 {
    public static void main(String[] args) {
        //创建一个Random对象，即随机数生成器
        Random rand=new Random();
        //随机生成10个随机整数，并显示
        for(int i=0;i<10;i++) {
            int num = rand.nextInt(10);
            System.out.println("第"+(i+1)+"个随机数是：" + num);
        }

    }
}

效果图如下

Random类型还定义了得到long型、boolean型、float型等伪随机数的方法