1. API概述
Java中的API可以理解为一本编程字典或者工具包，它包含了许多预定义的类、接口和方法，可以帮助我们更方便地开发Java程序
想象一下，当你要做一个饭菜的时候，你需要食谱和厨具。食谱告诉你需要哪些食材和步骤，而厨具则提供了切菜、炒菜等功能。在这个例子中，食谱就当于API，而厨具就相当于Java的API
Java的API提供了各种各样的类和方法，例如用于处理字符串、日期、文件、网络通信等等。通过使用这些类和方法，我们可以更轻松地实现我们想要的功能，而不需要从头开始编写所有的代码
当我们需要使用API时，只需要按照API提供的文档或者说明，调用相应的类和方法即可。这样，我们可以节省大量的时间和精力，同时也能够利用已经被验证过的代码，提高程序的可靠性和效率
总之，API是Java开发中非常重要的一部分，它为我们提供了许多常用功能的实现，使得我们能够更加高效地开发Java程序
2. API帮助文档
API帮助文档是对API的详细说明和使用指南。它提供了有关API中所有类、接口、方法和属性的详细描述，包括它们的功能、参数、返回值和使用示例等
API帮助文档通常由API提供者编写和维护，以便开发人员能够更好地理解和使用API。它可以作为开发人员的参考手册，帮助他们了解API的功能和用法，并在开发过程中查找需要的信息
所以API帮助文档提供的API所有类、接口、方法这些不需要去死记，它是字典，是工具
作为开发人员，会使用文档，会使用里面类的方法即可，如果忘记了就去找嘛
或者说当我们遇到问题或需要使用某个功能时，可以通过查阅API文档来找到合适的类和方法，并了解它们
的用法，这样就够了。
千万不要去死记！！！
想要获取API帮助文档可以从这个WX公众号
API中的类有很多，以下只是举例常用的
3. Math类
在API帮助文档下，Math类有以下介绍：
- 类名为 Math
- Math类属于 Java.lang 包下，因此在使用的时候不需要进行导包
- Math类继承 Java.lang.Object类（顶级父类，类的祖宗）
- 被 public 修饰，可被任何类调用
- 被 final 修饰，不能被继承
Math 类包含执行基本数字运算的方法，我们可以使用Math类完成基本的数学运算
以下是一些常用的Math类成员的示例：
Math的常见方法：
public static int abs(int a) // 返回参数的绝对值
public static double ceil(double a) // 返回大于或等于参数的最小整数
public static double floor(double a) // 返回小于或等于参数的最大整数
public static int round(float a) // 按照四舍五入返回最接近参数的int类型的值
public static int max(int a,int b) // 获取两个int值中的较大值
public static int min(int a,int b) // 获取两个int值中的较小值
public static double pow (double a,double b) // 计算a的b次幂的值
public static double random() // 返回一个[0.0,1.0)的随机值可以在IDEA中查看Math类的描述：
- ctrl+N键、点击类、所有未知、输入Math、选择第1个
具体代码实现：
public class MathDemo01 {
public static void main(String[] args) {
// public static int abs(int a) 返回参数的绝对值
System.out.println("-2的绝对值为：" + Math.abs(-2));
System.out.println("2的绝对值为：" + Math.abs(2));
// public static double ceil(double a) 返回大于或等于参数的最小整数
System.out.println("大于或等于23.45的最小整数位：" + Math.ceil(23.45));
System.out.println("大于或等于-23.45的最小整数位：" + Math.ceil(-23.45));
// public static double floor(double a) 返回小于或等于参数的最大整数
System.out.println("小于或等于23.45的最大整数位：" + Math.floor(23.45));
System.out.println("小于或等于-23.45的最大整数位：" + Math.floor(-23.45));
// public static int round(float a) 按照四舍五入返回最接近参数的int
System.out.println("23.45四舍五入的结果为：" + Math.round(23.45));
System.out.println("23.55四舍五入的结果为：" + Math.round(23.55));
// public static int max(int a,int b) 返回两个int值中的较大值
System.out.println("23和45的最大值为: " + Math.max(23, 45));
// public static int min(int a,int b) 返回两个int值中的较小值
System.out.println("12和34的最小值为: " + Math.min(12 , 34));
// public static double pow (double a,double b)返回a的b次幂的值
System.out.println("2的3次幂计算结果为: " + Math.pow(2,3));
// public static double random()返回值为double的正值，[0.0,1.0)
System.out.println("获取到的0-1之间的随机数为: " + Math.random());
}
}结果输出：
-2的绝对值为：2
2的绝对值为：2
大于或等于23.45的最小整数位：24.0
大于或等于-23.45的最小整数位：-23.0
小于或等于23.45的最大整数位：23.0
小于或等于-23.45的最大整数位：-24.0
23.45四舍五入的结果为：23
23.55四舍五入的结果为：24
23和45的最大值为: 45
12和34的最小值为: 12
2的3次幂计算结果为: 8.0
获取到的0-1之间的随机数为: 0.73224841317459584. System类
在API帮助文档下，System类有以下介绍
- 类名为 System
- System类属于 Java.lang 包下，因此在使用的时候不需要进行导包
- System类继承 Java.lang.Object类（顶级父类，类的祖宗）
- 被 public 修饰，可被任何类调用
- 被 final 修饰，不能被继承
System包含了系统操作的一些常用的方法。比如获取当前时间所对应的毫秒值，再比如终止当前JVM等等
具体代码实现：
public static long currentTimeMillis()
// 获取当前时间所对应的毫秒值（当前时间为0时区所对应的时间即就是英国格林尼治天文台旧址所在位置）
public static void exit(int status)
// 终止当前正在运行的Java虚拟机，0表示正常退出，非零表示异常退出
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
// 进行数值元素copy- 演示currentTimeMillis方法
public class SystemDemo01 {
public static void main(String[] args) {
// 获取当前时间所对应的毫秒值
long millis = System.currentTimeMillis();
// 输出结果
System.out.println("当前时间所对应的毫秒值为：" + millis);
}
}运行程序进行测试，控制台的输出结果如下：
当前时间所对应的毫秒值为：1576050298343currentTimeMillis方法获取到当前时间的毫秒值的意义：我们常常来需要统计某一段代码的执行时间。此时我们就可以在执行这段代码之前获取一次时间，在执行完毕以后再次获取一次系统时间，然后计算两个时间的差值，
这个差值就是这段代码执行完毕以后所需要的时间，示例如下：
public class CodeExecutionTime {
public static void main(String[] args) {
// 获取开始时间
long startTime = System.currentTimeMillis();
// 执行需要计算执行时间的代码段
for (int i = 0; i < 10000000; i++) {
// 一些需要计算执行时间的操作
int result = i * 2; // 乘法运算
double squareRoot = Math.sqrt(i); // 平方根计算
String str = "Number: " + i; // 字符串拼接
//System.out.println(str); // 打印输出
}
// 获取结束时间
long endTime = System.currentTimeMillis();
// 计算执行时间
long executionTime = endTime - startTime;
// 打印执行时间
System.out.println("代码执行时间为：" + executionTime + "毫秒");
}
}结果输出：
代码执行时间为：222毫秒- 演示exit方法
public class SystemDemo01 {
public static void main(String[] args) {
// 输出
System.out.println("程序开始执行了.....");
// 终止JVM
System.exit(0);
// 输出
System.out.println("程序终止了..........");
}
}输出结果：
程序开始执行了.....- 演示arraycopy方法
// src: 源数组
// srcPos： 源数值的开始位置
// dest： 目标数组
// destPos： 目标数组开始位置
// length: 要复制的元素个数
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length); 代码如下所示：
public class SystemDemo01 {
public static void main(String[] args) {
// 定义源数组
int[] srcArray = {23 , 45 , 67 , 89 , 14 , 56 } ;
// 定义目标数组
int[] desArray = new int[10] ;
// 进行数组元素的copy: 把srcArray数组中从0索引开始的3个元素，从desArray数组中的1索引开始复制过去
System.arraycopy(srcArray , 0 , desArray , 1 , 3);
// 遍历目标数组
for(int x = 0 ; x < desArray.length ; x++) {
if(x != desArray.length - 1) {
System.out.print(desArray[x] + ", ");
}else {
System.out.println(desArray[x]);
}
}
}
}输出结果：
0, 23, 45, 67, 0, 0, 0, 0, 0, 05. Runtime类
在API帮助文档下，Runtime类有以下介绍
- 类名为 Runtime
- Runtime类属于 Java.lang 包下，因此在使用的时候不需要进行导包
- System类继承 Java.lang.Object类（顶级父类，类的祖宗）
- 被 public 修饰，可被任何类调用
Runtime表示Java中运行时对象，可以获取到程序运行时设计到的一些信息
具体代码实现：
public static Runtime getRuntime() //当前系统的运行环境对象
public void exit(int status) //停止虚拟机
public int availableProcessors() //获得CPU的线程数
public long maxMemory() //JVM能从系统中获取总内存大小（单位byte）
public long totalMemory() //JVM已经从系统中获取总内存大小（单位byte）
public long freeMemory() //JVM剩余内存大小（单位byte）
public Process exec(String command) //运行cmd命令public class RunTimeDemo1 {
public static void main(String[] args) throws IOException {
/*
public static Runtime getRuntime() 当前系统的运行环境对象
public void exit(int status) 停止虚拟机
public int availableProcessors() 获得CPU的线程数
public long maxMemory() JVM能从系统中获取总内存大小(单位byte)
public long totalMemory() JVM已经从系统中获取总内存大小(单位byte)
public long freeMemory() JVM剩余内存大小(单位byte)
public Process exec(string command) 运行cmd命令
*/
//1.获取Runtime的对象
//Runtime r1 =Runtime.getRuntime();
//2.exit 停止虚拟机
//Runtime.getRuntime().exit(0);
//System.out.println("看看我执行了吗?");
//3.获得CPU的线程数
System.out.println(Runtime.getRuntime().availableProcessors());//8
//4.总内存大小,单位byte字节
System.out.println(Runtime.getRuntime().maxMemory() / 1024 / 1024);//4064
//5.已经获取的总内存大小,单位byte字节
System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);//254
//6.剩余内存大小
System.out.println(Runtime.getRuntime().freeMemory() / 1024 / 1024);//251
//7.运行cmd命令
//shutdown :关机
//加上参数才能执行
//-s :默认在1分钟之后关机
//-s -t 指定时间 : 指定关机时间
//-a :取消关机操作
//-r: 关机并重启
Runtime.getRuntime().exec("shutdown -s -t 3600");
}
}
6. Object类
在API帮助文档下，Object类有以下介绍
- 类名为 Object
- Runtime类属于 Java.lang 包下，因此在使用的时候不需要进行导包
- Object类是顶级父类，类的祖宗，不继承于谁
- 被 public 修饰，可被任何类调用
所有的类都继承自object类。object类是类层次结构的根，它是所有类的超类
无论是自定义的类还是Java内置的类，都直接或间接地继承自object类
具体代码实现：
public String toString() //返回该对象的字符串表示形式(可以看做是对象的内存地址值)
public boolean equals(Object obj) //比较两个对象地址值是否相等；true表示相同，false表示不相同- toString方法
创建一个学生类，提供两个成员变量（name ， age）；并且提供对应的无参构造方法和有参构造方法以及get/set方法
创建一个测试类（ObjectDemo01），在测试类的main方法中去创建学生对象，然后调用该对象的toString方法获取该对象的字符串表现形式，并将结果进行输出
Student类：
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}测试类：
public class ObjectDemo01 {
public static void main(String[] args) {
Student student = new Student("张三", 18);
System.out.println(student.toString());
}
}输出结果：
Student{name='张三', age=18}- equals方法
在测试类的main方法中，创建两个学生对象，然后比较两个对象是否相同
Student类：
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null || getClass() != obj.getClass()) {
return false;
}
Student student = (Student) obj;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}测试类：
public class ObjectDemo02 {
public static void main(String[] args) {
Student student1 = new Student("张三", 18);
Student student2 = new Student("张三", 18);
System.out.println(student1.equals(student2)); // 输出true
}
}输出结果：
true7. 包装类
Java是面向对象的语言，但Java不能把基本的数据类型（byte、short...）作为对象处理
可有时候可能需要把基本数据类型的数据作为对象使用
Java就提供了一系列包装类，把基本数据类型的值包装为引用数据类型的对象
| 基本数据类型 | 对应包装类 |
| byte | Byte |
| char | Character |
| int | Integer |
| short | Short |
| long | Long |
| double | Double |
| boolean | Boolean |
