Java基础快速入门: API常用类之Math,System,Object,Objects

本文纲要

1. API基本使用：什么是API及文档
2. Math类：数学计算工具类
3. System类：系统相关工具类
4. Object类：所有类的父类
   toString()方法
   equals()方法
   相关面试题
5. Objects类：对象帮助类

API基本使用

API（Application Programming Interface，应用程序编程接口）是Java已经为我们写好的一些方法。通过使用这些方法，我们不需要关心底层实现，直接调用即可，从而大幅提高开发效率。

如何查阅API文档

Java官方提供了API文档（通常是CHM格式）。
在索引输入框中输入要查找的类名，即可看到该类的所有信息，包括：

• 所在的包
• 继承结构
• 实现的接口
• 类的描述
• 构造方法
• 成员方法及其参数、返回值、含义

以Random类为例，在文档中可以找到它的构造方法和nextInt()方法的详细说明

Math类

Math类包含一些基本数学运算的方法，所有成员都是静态的，直接用类名.方法名调用，不需要创建对象。

原因：Math类的构造方法被private修饰，无法在外部实例化。

项目结构：

com.wb.demo1 
    └── MathDemo.java 

常用方法

• public static int abs(int a)：返回参数的绝对值
• public static double ceil(double a)：向上取整
• public static double floor(double a)：向下取整
• public static int round(float a)：四舍五入
• 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)之间的随机数

代码示例

// MathDemo.java 
package com.wb.demo1;
 
public class MathDemo {
    public static void main(String[] args) {
        // abs：返回绝对值 
        int abs = Math.abs(-10);
        System.out.println(abs); // 10 
 
        // ceil：向上取整 
        double ceil = Math.ceil(10.1);
        System.out.println(ceil); // 11.0 
 
        // floor：向下取整 
        double floor = Math.floor(10.9);
        System.out.println(floor); // 10.0 
 
        // round：四舍五入 
        long round1 = Math.round(10.1);
        System.out.println(round1); // 10 
        long round2 = Math.round(1.9);
        System.out.println(round2); // 2 
 
        // max：取两个数中的较大值 
        int max = Math.max(10, 20);
        System.out.println(max); // 20 
 
        // min：取两个数中的较小值 
        int min = Math.min(10, 20);
        System.out.println(min); // 10 
 
        // pow：a的b次幂 
        double pow = Math.pow(2, 3);
        System.out.println(pow); // 8.0 
 
        // random：生成[0.0, 1.0)之间的随机数 
        for (int i = 0; i < 10; i++) {
            double random = Math.random();
            System.out.println(random);
        }
    }
}

记忆技巧：ceil单词中的l像向上翘，是向上取整；floor单词中的l像向下垂，是向下取整。

System类

System类是系统相关的工具类，同样不能被实例化（构造方法私有），所有方法都是静态的，直接用类名调用。

项目结构：

com.wb.demo1 
    └── SystemDemo.java 

常用方法

• public static void exit(int status)：终止当前运行的Java虚拟机。参数0表示正常终止，非零表示异常终止。
• public static long currentTimeMillis()：返回当前时间（毫秒值）。通常用于计算代码段执行时间。
• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：数组拷贝。
  • src：源数组
  • srcPos：源数组起始索引
  • dest：目标数组
  • destPos：目标数组起始索引
  • length：拷贝的元素个数

代码示例

// SystemDemo.java 
package com.wb.demo1;
 
public class SystemDemo {
    public static void main(String[] args) {
        // exit：终止虚拟机 
        System.out.println(111);
        System.exit(0); // 此方法执行后，JVM就停止了 
        System.out.println(222); // 不会执行 
 
        // currentTimeMillis：获取当前时间毫秒值，常用于统计代码运行时间 
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("循环耗时：" + (end - start) + "毫秒");
 
        // arraycopy：数组拷贝 
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = new int[10];
 
        // 将arr1的所有元素拷贝到arr2的0索引处 
        System.arraycopy(arr1, 0, arr2, 0, arr1.length);
        // 将arr1的最后两个元素（索引3,4），拷贝到arr2的最后两个索引（索引8,9）
        System.arraycopy(arr1, 3, arr2, 8, 2);
 
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

Object类

Object类是所有类的父类。每一个类都直接或间接地继承自Object。如果自定义类没有明确写出继承关系，JVM会默认让其继承Object。
正因为顶层父类Object只有无参构造，所以子类构造方法默认访问父类的无参构造。

toString()方法

直接打印一个对象，实际会调用该对象的toString()方法。
在Object类中，toString()默认返回：包名.类名@地址值。这个地址值对开发者来说通常没有意义，因此经常重写toString()，返回对象属性信息。

调用链如下：

项目结构：

com.wb.demo1 
    ├── Demo.java 
    └── Student.java 

代码示例：

// Student.java 
package com.wb.demo1;
 
public class Student /extends Object/ {
    private String name;
    private int age;
 
    public Student() {}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // getter / setter 略 
 
    @Override 
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// Demo.java 
package com.wb.demo1;
 
public class Demo {
    public static void main(String[] args) {
        Student s = new Student("张三", 23);
        // 直接打印对象，默认调用toString()；重写后输出属性值 
        System.out.println(s);  // Student{name='张三', age=23}
        System.out.println(s.toString()); // 同上 
    }
}

equals()方法

equals()用于比较两个对象是否“相等”。

• Object类中的equals()底层使用==比较地址值。
• 要比较对象的属性值是否相等，需要在子类中重写equals()。

项目结构：

com.wb.demo2 
    ├── Demo.java 
    └── Student.java 

代码示例：

// Student.java（重写了equals）
package com.wb.demo2;
 
public class Student {
    private String name;
    private int age;
    // 构造方法、getter/setter 略 
 
    @Override 
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
 
    @Override 
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
 
// Demo.java 
package com.wb.demo2;
 
public class Demo {
    public static void main(String[] args) {
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("zhangsan", 23);
 
        System.out.println(s1 == s2);         // false (比较地址)
        System.out.println(s1.equals(s2));    // true  (重写后比较属性)
    }
}

面试题：String与StringBuilder的equals比较

String s1 = "abc";
StringBuilder sb = new StringBuilder("abc");
 
// s1.equals(sb) → false 
// 因为调用的是String类的equals()，它要求参数也是String类型，
// 否则直接返回false，不比较属性值。
 
// sb.equals(s1) → false 
// StringBuilder类没有重写equals()，因此调用的是Object类的equals()，
// 底层使用==比较地址值，两个对象地址肯定不同，所以返回false。

项目结构：

com.wb.demo3 
    └── InterviewTest.java 

代码示例：

package com.wb.demo3;
 
public class InterviewTest {
    public static void main(String[] args) {
        String s1 = "abc";
        StringBuilder sb = new StringBuilder("abc");
 
        System.out.println(s1.equals(sb));  // false 
        System.out.println(sb.equals(s1));  // false 
    }
}

Objects类

Objects是JDK 1.7出现的对象帮助类，所有方法都是静态的，用来方便地操作对象，特别是避免空指针异常。

项目结构：

com.wb.demo4 
    ├── MyObjectsDemo.java 
    └── Student.java 

常用方法

• public static String toString(Object o)：返回对象的字符串表示形式（调用对象自身的toString()）。
• public static String toString(Object o, String nullDefault)：返回对象的字符串表示形式；如果对象为null，则返回第二个参数作为默认值。
• public static boolean isNull(Object obj)：判断对象是否为空，为空返回true。
• public static boolean nonNull(Object obj)：判断对象是否不为空，不为空返回true。

代码示例

// MyObjectsDemo.java 
package com.wb.demo4;
 
import java.util.Objects;
 
public class MyObjectsDemo {
    public static void main(String[] args) {
        // toString(对象)：底层调用对象的toString()
        Student s1 = new Student("小罗同学", 50);
        String result1 = Objects.toString(s1);
        System.out.println(result1);  // Student{name='小罗同学', age=50}
 
        // toString(对象, 默认字符串)：对象为null时返回默认值 
        Student s2 = null;
        String result2 = Objects.toString(s2, "默认值");
        System.out.println(result2);  // 默认值 
 
        // isNull：判断是否为空 
        boolean isNull1 = Objects.isNull(s1);  // false 
        boolean isNull2 = Objects.isNull(null);// true 
        System.out.println(isNull1);
        System.out.println(isNull2);
 
        // nonNull：判断是否不为空 
        boolean nonNull1 = Objects.nonNull(s1);   // true 
        boolean nonNull2 = Objects.nonNull(null); // false 
        System.out.println(nonNull1);
        System.out.println(nonNull2);
    }
}
 
// Student.java 
package com.wb.demo4;
 
public class Student {
    private String name;
    private int age;
    // 构造方法、getter/setter 略 
 
    @Override 
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

总结

通过以上几个类的学习，可以看到Java通过提供丰富的API，大大简化了我们的编码工作。掌握常用类的静态方法，并理解Object作为所有类父类的设计思想，是Java入门的重要一步。

后续还会遇到更多工具类，它们的共性都是：构造私有、方法静态、功能明确。