一、Math
Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数等。Math类的特点：
- Math类是final的
- Math类的构造函数是private的
- Math类中的成员都是static的
静态常量：
- E：自然对数的底数
- PI：圆周率
常用方法：
1. max(a,b): 求两个数的最大值 2. min(a,b): 求两个数的最小值 3. abs(n): 求绝对值 4. pow(a,b): 求a的b次方 /*示例： System.out.println(Math.pow(27,1.0/3))//3.0 */ 5. sqrt(n): 求一个数的平方根 /*示例： System.out.println(Math.sqrt(25))//5.0 */ 6. ceil(n): 向上取整 /*示例： System.out.println(Math.ceil(-3.6));//-3.0 System.out.println(Math.ceil(3.6));//4.0 */ 7. floor(n): 向下取整 /*示例： System.out.println(Math.floor(-6.9));//-7.0 System.out.println(Math.floor(6.9));//6.0 */ 8. random(): 生成[0.0,1.0)之间的随机小数 /*示例： System.out.println(Math.random());//随机小数 */ ##9. round(n):四舍五入(四舍五入的时候不看正负号) /*示例： System.out.println(Math.round(-3.5));//-4.0 */ 10. sin(n): 求正弦值，参数必须是弧度值 /*示例： System.out.println(Math.sin(Math.PI/6));//0.49999999999999994 */ 11. toDegrees(n): 弧度值转角度值 /*示例： System.out.println(Math.toDegrees(Math.PI));//180.0 */ 12. toRadians(n): 角度值转弧度值 /*示例： System.out.println(Math.toRadians(30));//0.5235987755982988 */
二、Random
此类的实例用于生成伪随机数流。
创建对象：
Random r = new Random();常用方法：
1.nextInt() 2.nextInt(n): 生成[0,n-1)范围内的随机数 /*示例： int num4 = r.nextInt(22) + 56;//随机的到[56,77]范围的数 */ 注：如果参数是负数或者0，会发生IllegalArgumentException，非法参数异常 3.nextDouble()
三、Scanner
一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。
创建对象：
Scanner sc = new Scanner(System.in);常用方法：
1.nextInt() 2.nextDouble() 3.next() 4.nextLine() /*示例： Scanner sc = new Scanner(System.in); System.out.println("请输入一个字符串："); String str = sc.nextLine();可以什么都不输入，直接回车； */ 注：next()不能接收空白内容，nextLine()可以接收空白内容 5.nextInt(n)：n表示指定的进制，它表示将输入的内容视为指定进制的值返回对应的十进制数 /*示例： Scanner sc = new Scanner(System.in); System.out.println("请输入一个二进制数："); int i = sc.nextInt(2); 输入：1000 System.out.println(i);//8 */注：如果输入值的类型与方法接收值的类型不一致会发生
InputMismatchException，输入不匹配异常
四、Date
类
Date表示特定的瞬间，精确到毫秒。作用：
- 将日期对象转换成年月日时分秒的值（被Calendar取代）
- 将日期对象格式化成日期字符串、解析日期字符串变为一个日期对象（被DateFormat取代）
创建对象：
1.Date d = new Date();:输出d的值不是地址值，其输出值的格式为：Sat Aug 20 09:53:11 CST 2022 //使用Date的重载构造函数: 2.Date d = new Date(long t);: t表示毫秒值 /*示例： Date d2 = new Date(3600000); System.out.println(d2);//1970.01.01 过1个小时 */常用方法：
1.getTime(): 获取1970.01.01日 0点到运行这句话所间隔的毫秒数
五、DateFormat
DateFormat是日期/时间格式化子类的抽象类我们要使用它的子类
SimpleDateFormat它的功能是：
- 格式化：将日期对象转换成指定格式的字符串
- 解析：将指定格式的字符串转换成日期对象
创建对象：
SimpleDateFormate sdf = new SimpleDateFormate("模式");格式化：
sdf.format(Date d);//使用format方法进行格式化Date d = new Date(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒"); String time = sdf.format(d); System.out.println(time);解析：
sdf.parse(String t);//使用parse方法进行解析String t = "2021-10-18 20:20:30"; SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); Date date = sdf.parse(t); System.out.println(date);//Mon Oct 18 20:20:00 CST 2021练习：计算输入时间与2022/07/17相差多少天 String nowTime = "2022/07/17"; Scanner sc = new Scanner(System.in); SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd"); System.out.println("请输入您的日期:"); String futureTime = sc.next(); Date d1 = sdf.parse(nowTime); Date d2 = sdf.parse(futureTime); long t1 = d1.getTime(); long t2 = d2.getTime(); long day = (t2 - t1)/3600000/24; System.out.println("距您输入的日期还有：" + day + "天");注：如果日期字符串的格式与指定格式不匹配会发生
ParseException解析异常
六、Calendar
Calendar类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法。
Calendar提供了一个类方法getInstance，以获得此类型的一个通用的对象。Calendar的getInstance方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化对象的获取：
Calendar c = Calender.getInstance();常用方法：
1.get(n)//用来获取时间，如年，月，日，一年中的第几天等； /*示例: System.out.println(c.get(Calendar.YEAR));//获取年份 System.out.println(c.get(Calendar.MONTH));//获取月份 注:因为其中的月份是从0开始的，所以其范围是[0，11]，0代表1月，以此类推。 */ 2.set(int field,int value)//修改时间，如修改年份，月份，日等时间 /*示例: c.set(Calendar.MONTH,11); System.out.println(c.get(Calendar.MONTH));//11 c.set(Calendar.MONTH,12); System.out.println(c.get(Calendar.MONTH));//0 */ 3.set(int year,int month,int day,int hour,int minute,int second) /*示例: c.set(1971,9,19,17,0,0);//set(int field,int value)方法的重载形式 System.out.println(c.get(Calendar.YEAR));//1971 */ 4.getTime()获取时间值,获取的时间值的格式为：Tue Oct 19 17:00:00 CST 1971 /*示例: c.set(1971,9,19,17,0,0); Date d = c.getTime(); System.out.println(d);//Tue Oct 19 17:00:00 CST 1971 System.out.println(c.getTime());//Tue Oct 19 17:00:00 CST 1971 */ 5.getTimeInMillis()获取时间的毫秒值 /*示例: c.set(1971,9,19,17,0,0); System.out.println(c.getTimeInMillis());//56710800523 */
练习：计算一个人到目前为止度过了多少天
Calendar c1 = Calendar.getInstance();
c1.set(1998,3,25);//输入出生日期
long l1 = c1.getTimeInMillis();
Calendar c2 = Calendar.getInstance();
long l2 = c2.getTimeInMillis();
long day = (l2 - l1)/3600000/24;
System.out.println(day);
七、String
String类代表字符串。Java 程序中的所有字符串字面值（如"abc"）都作为此类的实例实现。字符串是常量；它们的值在创建之后不能更改。因为 String 对象是不可变的，所以可以共享。
构造函数：
1.String() 2.String(String s) 3.String(char[] chs): 将字符数组中的所有字符拼接形成字符串 /*示例: char[] chs = {'a','b','+','9'}; String s3 = new String(chs);//字符拼接的字符串 System.out.println(s3);//"ab+9" */ *4.String(char[] chs,int offset,int count): [offser,count+offser)范围内的字符拼接形成字符串(从指定下标开始取指定个数组成字符串) /*示例: char[] chs = {'a','b','+','9'}; String s4 = new String(chs,0,2);//字符截取后拼接的字符串 System.out.println(s4);//"ab" */ 5.String(int[] arr,int offset,int count): 根据int数组中的数字，对应ASCII码表字符的截取拼接 /*示例: int[] arr = {97,98,99}; String s5 = new String(arr,1,3);//ASCII码表对应字符的截取拼接 System.out.println(s5);//"bc" */ 6.String(byte[] bs,String charsetName)根据byte数组中的数字结合编码方式拼接形成字符串 /*示例: byte[] bs = {90,91,92}; String s6 = new String(bs1,"utf-8"/*编码方式*/); System.out.println(s6);//"Z[" */ 7.String(byte[] bs)根据byte数组中的数字，对应ASCII码表字符拼接形成字符串 /*示例: byte[] b = {97,98,99,100}; String s7 = new String(b);//依据字节数组中的内容构建字符串 System.out.println(s7);//abcd */ *8.String(byte[] bs,int offset,int length)根据byte数组中的数字，对应ASCII码表字符的截取指定长度拼接 /*示例: byte[] b = {97,98,99,100}; String s8 = new String(b,0,3);从下标为0的位置取三个字符组成字符串 System.out.println(s8);//"abc" */
对象的创建：
String s = new String(); 注：可以使用构造函数的重载创建对象常用方法：
*1.length(): 求字符串的长度 *2.charAt(int i)：根据下标遍历字符串的每一个字符 注：下标超范围会发生StringIndexOutOfBoundsException字符串下标越界 *3.indexOf(xxx): 根据内容返回下标 /*示例 String s2 = new String("abcdeaf1234g"); System.out.println(s2.indexOf("1"));//7 System.out.println(s2.indexOf("23"));//8 System.out.println(s2.indexOf(97));//返回ASCII码表对应字符第一次出现的下标，为：0 System.out.println(s2.indexOf(97,2));//从下标2开始找,为：5 */ *4.lastIndexOf(xxx): 从后往前找的第一个对应字符的下标 /*示例 String s3 = new String("3231234"); System.out.println(s3.lastIndexOf("3"));//5 从后往前找的第一个 System.out.println(s3.lastIndexOf("3",3));//2 从下标3开始往前找 System.out.println(s3.lastIndexOf(51));//5 ASCII码表对应字符从后往前找的第一个 */ *5.equals(String s): 比较两个字符串是否相同 6.equalsIgnoreCase(String s): 比较两个字符串是否相同，不区分大小写字母，一般验证码会使用 7.getBytes(): 将字符串转换为字节数组 /*示例: String s5 = "abc"; byte[] bs = s5.getBytes(); System.out.println(Arrays.toString(bs));[97, 98, 99] */ 8.toCharArray(): 将字符串转换为字符数组 /*示例: String s5 = "千峰教育""; byte[] bs = s5.getBytes(); System.out.println(Arrays.toString(bs));[千, 峰, 教, 育] */ 9.toUpperCase(): 将小写字母全部转换成大写 10.toLowerCase(): 将大写字母全部转换成小写 *11.subString(int beginIndex): 将下标前的字符删除 /*示例: String s6 = "abUppD12345"; System.out.println(s6.substring(5));//"D12345" */ *12.subString(int beginIndex,int endIndex): 截取[2,5)的字符 /*示例: String s6 = "abUppD12345"; System.out.println(s6.substring(2,5));//"Upp" */ 13.startsWith(String s): 判断字符串的第一个字符是不是对应字符 /*示例: String s7 = "abcdefg11234"; System.out.println(s7.startsWith("ab"));//true */ 14.endsWith(String s): 判断字符串的最后一个字符是不是对应字符 /*示例: String s7 = "abcdefg11234"; System.out.println(s7.endsWith("34"));//true */ 15.replace(char oldChar,Char newChar): 将字符串中的所有oldChar替换为newChar /*示例: String s8 = "aachea278a"; System.out.println(s8.replace('a','A'));//"AAcheA278A" */ 16.replace(String s1,String s2): 将字符串中的几个连续字符s1,用s2替换 /*示例: String s8 = "aachea278a"; System.out.println(s8.replace("aach","0"));//0ea278a */ 17.trim(): 去除字符串两边的空格
八、StringBuilder、StringBuffer
StringBuilder、StringBuffer都是可变的字符序列，它们有兼容的API。区别：
StringBuffer：线程安全，保证线程同步，效率较低
StringBuilder：不保证线程同步，不保证线程安全，效率更高
创建对象：
1.StringBuffer(): 无参构造函数，默认容量为16 2.StringBuffer(int capacity): 指定容量构建 3.StringBuffer(String s): 构建指定字符串的对象 /*示例: StringBuilder sb5 = new StringBuilder("abc");//指定字符串 StringBuffer sb6 = new StringBuffer("123"); System.out.println(sb5);//"abc" System.out.println(sb6);//"123" */ 4.StringBuffer(CharSequence s): 可以传入StringBuilder的对象 /*示例: StringBuilder sb5 = new StringBuilder("abc"); StringBuffer sb6 = new StringBuffer("123"); StringBuilder sb7 = new StringBuilder(sb6); StringBuffer sb8 = new StringBuffer(sb5); System.out.println(sb7);//"123" System.out.println(sb8);//"abc" */ --------------------------------------------------------------------------------- 同上！！！ 5.StringBuilder() 6.StringBuilder(int capacity) 7.StringBuilder(String s) 8.StringBuilder(CharSequence s)
常用方法：
1.append(Object o): 拼接作用，本方法返回本类对象可以连续调用此方法 /*示例: StringBuilder sb1 = new StringBuilder("a"); sb1.append(5).append(9.9).append(false).append("098").append('+').append(new char[]{'A','B','C','D'},1,2).append("poiu",0,3); System.out.println(sb1);//"a59.9false098+BCpoi" */ 2.delete(int start,int end): 删除[start,end)下标范围内的字符 3.deleteCharAt(int index): 删除字符串中指定下标的字符 4.replace(int start,int end,String s): 将[start,end)范围内的字符用指定字符s替换 5.reverse(): 字符串倒置 6.insert(int index,Object o):在指定位置插入字符
StringBuilder、StringBuffer 与 String 的转换：
StringBuilder、StringBuffer => String
// 1.调用StringBuilder、StringBuffer的toString()方法 StringBuilder sb1 = new StringBuilder("abc"); String s1 = sb1.toString(); // 2.使用String的构造函数 StringBuffer sb2 = new StringBuffer("qwer"); String s2 = new String(sb2);String => StringBuilder、StringBuffer
// 1.使用StringBuilder、StringBuffer的构造函数 String s3 = "789abc"; StringBuilder sb3 = new StringBuilder(s3);
九、Arrays
此类包含用来操作数组（比如排序和搜索）的各种方法。
特点：
- Arrays的构造函数是私有的
- Arrays中的方法都是静态的
常见方法：
1.toString(Object[] o): 将数组转换成字符串类型 /*示例：该方法的原码 public static String toString(int[] a) { if (a == null) return "null"; int iMax = a.length - 1; if (iMax == -1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } } */ 2.copyOf(Object[] o,int newLen): 拷贝数组，此方法可以自动生成指定长度为newLen的新数组 3.binarySearch(Object[] os,Object o)：使用二分搜索法返回一个值在指定数组中的下标 注：数组必须要满足以下两个条件 1.数组中的元素必须是升序排列的 2.数组中的元素必须唯一 4.fill(Object[] os,Object o): 使用指定的值填充数组中的所有元素 5.equals(Object[] o1,Object[] o2): 比较两个数组是否相同(必须完全相同)
排序方法：
方法一：
sort(数组)如何对对象的属性进行排序：
步骤：
使用指定类实现
Comparable接口，在接口的泛型中写该实现类重写
compareTo方法，在方法中返回要进行排序的属性之差升序：
this.属性 - 参数.属性降序：
参数.属性 - this.属性示例： //创建学生类： public class Student implements Comparable <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; } //重写compareTo方法 @Override public int compareTo(Student o) { return this.getAge() - o.getAge();//排序方式，当前对象在前为升序 } //重写toString方法,用来输出学生数组中学生的信息 @Override public String toString() { return "学生[" + "姓名='" + name + ''' + ", 年龄=" + age + ']'; } } //创建测试类 public class Test { public static void main(String[] args) { Student s1 = new Student("张三",35); Student s2 = new Student("李四",21); Student s3 = new Student("王五",18); Student s4 = new Student("赵六",57); Student s5 = new Student("田七",46); Student[] stus = {s1,s2,s3,s4,s5}; stuFind(stus); System.out.println("---------------------------"); Arrays.sort(stus); stuFind(stus); } //输出学生信息 public static void stuFind(Student[] stus){ for (Student s : stus){ System.out.println(s); } } } 结果： 学生[姓名='张三', 年龄=35] 学生[姓名='李四', 年龄=21] 学生[姓名='王五', 年龄=18] 学生[姓名='赵六', 年龄=57] 学生[姓名='田七', 年龄=46] --------------------------- 学生[姓名='王五', 年龄=18] 学生[姓名='李四', 年龄=21] 学生[姓名='张三', 年龄=35] 学生[姓名='田七', 年龄=46] 学生[姓名='赵六', 年龄=57]方法二：
sort(数组,Comparator)Arrays.sort(emps,new Comparator<Emp>(){ @Override public int compare(Emp o1, Emp o2) { return o1.age - o2.age; } });
示例：
//创建学生类
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;
}
//重写toString方法,用来输出学生数组中学生的信息
@Override
public String toString() {
return "学生[" +
"姓名='" + name + ''' +
", 年龄=" + age +
']';
}
}
//创建实现类
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Student s1 = new Student("张三",35);
Student s2 = new Student("李四",21);
Student s3 = new Student("王五",18);
Student s4 = new Student("赵六",57);
Student s5 = new Student("田七",46);
Student[] stus = {s1,s2,s3,s4,s5};
stuFind(stus);
System.out.println("---------------------------");
System.out.println("请选择您要排序的方式：1.升序 2.降序 ：");
int num = sc.nextInt();
Comparator c = null;//使用多态
if(num == 1){
c = new Mc1();
}else if(num == 2){
c = new Mc2();
}
Arrays.sort(stus,c);
stuFind(stus);
}
//输出学生信息
public static void stuFind(Student[] stus){
for (Student s : stus){
System.out.println(s);
}
}
}
//创建升序的Comparator实现类
class Mc1 implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o1.getAge() - o2.getAge();
}
}
//创建降序的Comparator实现类
class Mc2 implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o2.getAge() - o1.getAge();
}
}
十、Object
类
Object是类层次结构的根类。每个类都使用Object作为超类。常用方法：
1.toString()输出对象时，输出的对象的地址值，因为输出对象时，默认调用
toString()，在本类中没有toString()方法进行重写，所以调用的Object类中的toString()，Object类中的toString()输出的是当前对象的地址可以对Object类中的
toString()进行重写，在输处对象时直接输出对象的属性public String toString(){ return this.name + "----"+ this.age; }2.getClass(): 返回对象的真实类型，形如：class com.qf.test_object.Stu 2.1getClass.getName(): 返回对象的真实类型: com.qf.test_object.Stu3.equals(): Object类中的`equals()`方法用于比较两个对象的地址是否相同Object类中的
equals()方法用于比较两个对象的地址是否相同，如果我们需要比较两个对象的属性是否完全相同，可以重写Object类中的equals()方法@Override public boolean equals(Object o){ if(o == null){ return false; } if(this == o){ return true; } if(!(o instanceof Stu)){ return false; } Stu s = (Stu)o; if(this.age == s.age){ if(this.name != null){ return this.name.equals(s.name); }else{ if(s.name == null){ return true; }else{ return false; } } }else{ return false; } }@Override public boolean equals(Object o) { if (this == o) return true; if (o == null || this.getClass() != o.getClass()) return false; Stu stu = (Stu) o; return age == stu.age && Objects.equals(this.name, stu.name); }
十一、包装类
任何类型的对象都可以进行属性和方法的调用，但是基本类型不能调用属性和方法；为了能让基本类型也可以调用属性和方法，在Java中对这8个基本类型进行封装，封装成了对应的8个引用数据类型，这8个引用数据类型就称为包装类。
基本类型 引用类型（包装类） byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean
包装类对象的创建：
Integer i = new Integer(int n); //示例：Integer i = new Integer(3);//3 Integer j = new Integer(String s); /*示例： Integer j = new Integer("44");//44 Integer a = new Integer('a');//97 */常用的静态方法：
1.toString(int n): 使用类名来调用,需要参数，将基本类型转换为字符串类型 /*示例： System.out.println(Integer.toString(3) + 1);//31 */ 2.toString(int n,int r)：r表示进制，功能是将n转换成r进制的字符串值 /*示例： String s2 = Integer.toString(17,16);// 10 */ 3.compare（int n,int m)：比较n和m的大小，n>m返回1，n==m返回0，n<m返回-1 4.max(int n,int m)：比较两个数的大小，返回较大的值 5.min(int n,int m)：比较两个数的大小，返回较小的值 6.parseInt(String s)使用对象来调用，将字符串转换成数字 /*示例： Integer q = Integer.parseInt("23"); System.out.println(q + 2)//25 */ 7.parseInt(String s,int r)：r表示进制，功能是将指定r进制的s转换成十进制数 /*示例： int q = Integer.parseInt("1000",2);将2进制的‘1000’转换成十进制数 System.out.println(q+1);//9 */ 8.valueOf(int i):传入整数类型的参数 /*示例： Integer i1 = Integer.valueOf(3); System.out.println(i1 + 1);//4 */ 9.valueOf(String s)：将传入的字符串参数转换成整数类型 /*示例： Integer i2 = Integer.valueOf("33"); System.out.println(i2 + 1);//34 */ 10.valueOf(String s,int r)：r表示进制，功能是将指定r进制的s字符串转换成十进制数 /*示例： Integer i3 = Integer.valueOf("10",2); System.out.println(i3 + 1);//3 */ 11.toBinaryString(int n)：将十进制数转换为二进制数 12.toOctalString(int n)：将十进制数转换为八进制数 13.toHexString(int n) ：将十进制数转换十六进制数注：参数是String用于将String转换成整数的方法，参数只能是整数形式的字符串，否则会发生NumberFormatException，数字格式异常
常用的成员方法：
1.toString() 创建对象调用，不需要参数，使用对象的参数,将基本类型转换为字符串 /*示例： Integer i = new Integer(3); System.out.println(i.toString()+2);//32 */ 2.equals(int n): 比较两个值是否相等 3.compareTo(int n): 比较大小，方法调用者的大小大于传入的参数返回1，相等返回0，小于返回-1 4.doubleValue(): 获取对象中的值 /*示例: Integer i = new Integer(127); long l = i.longValue(); System.out.println(l);//127 */ 5.floatValue() 6.longValue() 7.intValue() 8.shortValue() 9.byteValue()静态常量：
1.MAX_VALUE//2147483647 2.MIN_VALUE//-2147483648
装箱和拆箱：
- 装箱：将基本类型转换成对应的包装类
- 拆箱：将包装类转换成对应的基本类型
从JDK1.5开始，自动装拆箱，包装类和它所对应的基本类型可以直接赋值；
从JDK1.9开始，包装类的构造函数变成过期函数
包装类、基本类型和字符串的转换
// 包装类、基本类型 => 字符串 // 1.拼接字符串 int i = 3; String s1 = i + ""; // 2.包装类的成员方法 Integer j = 4; String s2 = j.toString(); // 3.包装类的静态方法 String s3 = Integer.toString(5); // 4.String类中的静态方法 String s4 = String.valueOf(i); // 字符串 => 包装类、基本类型 String s5 = "3"; // 1.包装类的构造函数 Integer n = new Integer(s5); // 2.包装类的静态方法valueOf int m = Integer.valueOf(s5); // 3.包装类的静态方法parseInt Integer q = Integer.parseInt(s5);
十二、System
特点：
- System是final的
- 它不能被实例化
- System中的成员都是静态的
常用方法：
1.System.arrayCopy(a,b,c,d,e): 2.System.currentTimeMillis()//获取毫秒值 3.System.exit(int n)// 结束JVM 注：参数0表示正常结束，非0异常终止 4.gc(): 提醒JVM中的垃圾回收器回收垃圾，不一定会进行回收垃圾，垃圾回收器有自己的判断机制
