Object类，Math类，System类

Object类

Object类概述

1. java.lang.Object(类)：类Object是类层次结构的根。 每个类都有Object作为超类。 所有对象（包括数组）都实现了这个类的方法。
   它是Java中所有类(包括数组)的父类(包括JDK中的类，也包括我们自定义的类)
   我们“自定义”的类，如果不继承其他类，就会隐式的继承自Object。
2. 继承Object类，就会继承下一些方法：
   1).toString()：会被所有的类继承，它将对象转换为一个String表示。通常需要我们子类重写
   2).equals()：会被所有的类继承，作用：将本对象，与参数对象进行“比较”——比较所有的成员属性是否完全一致。通常需要子类重写。

Object类的toString方法

作用：可以将“对象”转换为”String表示”方式。

1. 当我们直接打印一个对象时，println()方法内部隐式的会调用我们对象的toString()方法。
   Student stu = new Student();
   System.out.println(stu);//println()方法内部会调用stu的toString()获取一个字符串，然后打印到控制台。
2. 当我们的对象和一个“字符串”进行+连接时，会隐式的调用我们对象的toString()转换为字符串，然后再做字符串连接：
   System.out.println(“学员信息：” + stu);
   注意：如果我们的类不重写toString()，那么调用的就是“父类Object”的toString(),它打印的格式：全类名@地址值，这种格式的打印对于我们来说没有用！！！，所以如果我们想按照我们的要求进行打印，就需要子类重写toString().

代码演示：

1).自定义类：

public class Student {
    private String name;
    private int age;

    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()，可以方便打印
    //alt + insert --> 输入t(关联toString菜单)-->选中toString-->回车-->选中所有的属性-->确定

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2).测试类：

public class Demo02 {
    public static void main(String[] args) {
        Student stu = new Student("张三", 18);

        System.out.println(stu);//println()方法内部会调用stu.toString()，我们的Student没有定义toString()，调用的就是父类Object的
        System.out.println(stu.toString());


        System.out.println("学员信息：" + stu);//也会隐式的先调用stu.toString()转换为String，然后再做字符串连接。
    }
}

Object类equals方法

作用：比较两个对象中所有的属性是否完全相同。

1. 在我们为Student类生成equals()方法时，在生成的代码中，比较字符串字符串的时候使用：Objects.equals(name,student.name)，这样做是为了保证代码的安全
2. java.util.Objects(类)：对“对象”操作的工具类，它里面定义的方法通常都是进行了“安全验证”：
   public static boolean equals(Object o1 , Object o2)
   在对两个对象进行equals()判断时，建议使用Objects的equals()方法。

代码演示：

1).自定义类：

public class Student {
    private String name;
    private int age;
    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()，可以方便打印
    //alt + insert --> 输入t(关联toString菜单)-->选中toString-->回车-->选中所有的属性-->确定
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写equals()
    //alt + insert -->e(关联到equals and HashCode菜单)-->一路回车-->最后确定
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;//1.验证本对象与参数对象是否是同一个对象，是：直接返回true:
        if (o == null || getClass() != o.getClass()) //2.如果参数==nul：返回false，或者当前对象类型与参数对象类型不同，返回：false
            return false;
        Student student = (Student) o;//3.将参数o向下转型，转换为Student类型，目的：就是要访问子类特有成员了。
        return age == student.age &&
                name.equals(student.name);//4.每个属性依次比较
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

2).测试类：

	public class Demo03 {
    public static void main(String[] args) {
        String s1 = new String("Hello");
        String s2 = new String("Hello");

        System.out.println(s1 == s2);//判断是"地址"：false
        System.out.println(s1.equals(s2));//判断是"内容"：true

        Student stu1 = new Student("张三", 18);
        Student stu2 = new Student("张三", 18);

        System.out.println(stu1 == stu2);//判断"地址"：false
        System.out.println(stu1.equals(stu2));//比较的是"内容"：false(如果没有重写equals()，调用的就是父类Object的equals()比较的就是"地址"

        //如果我们想要比较两个Student对象的"内容(所有属性)"是否完全相同，就需要重写equals()--见Student类
        StringBuilder bld1 = new StringBuilder("Hello");
        StringBuilder bld2 = new StringBuilder("Hello");

        System.out.println(bld1.equals(bld2));//false，StringBuilder没有重写equals()

        String t1 = new String("Hello");
        String t2 = new String("Hello");
        System.out.println(t1.equals(t2));//true,String类重写了equals()
    }
}

Math类

java.lang.Math(类)：它内部包含了很多进行数学运算的静态方法。

System类常用静态方法：

1. public static int abs(int a) 获取参数a的绝对值：
2. public static double ceil(double a) 向上取整
3. public static double floor(double a) 向下取整
4. public static double pow(double a, double b) 获取a的b次幂
5. public static long round(double a) 四舍五入取整

public class Demo10 {
    public static void main(String[] args) {
        System.out.println("-5的绝对值：" + Math.abs(-5));//5
        System.out.println("3.2向上取整；" + Math.ceil(3.2));//4.0
        System.out.println("3.8向上取整；" + Math.ceil(3.8));//4.0

        System.out.println("3.2向下取整：" + Math.floor(3.2));//3.0
        System.out.println("3.8向下取整：" + Math.floor(3.8));//3.0
        System.out.println("3.0向下取整：" + Math.floor(3.0));//3.0

        System.out.println("2的4次幂：" + Math.pow(2,4));//16

        System.out.println("3.45四舍五入取整：" + Math.round(3.45));//3
        System.out.println("3.55四舍五入取整：" + Math.round(3.55));//4
    }
}

System类

java.lang.System(类)：它内部包含了一些实用的方法。它不能被实例化。都是静态方法，通过类名直接访问。

常用方法

1). public static void arraycopy(Object src,		//源数组
           						int srcPos,	//源数组中复制的起始位置
           						Object dest,	//目标数组
           						int destPos,	//目标数组的起始位置
           						int length)：	//复制的长度
			作用：复制数组。
2). public static void exit(int status)：结束虚拟机。
		System.exit(0);//参数0表示：状态码。正常退出用：0
3). public static long currentTimeMillis()：获取系统时间的毫秒值。相当于：new Date().getTime();

代码演示：

public class Demo11 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int[] arr2 = new int[arr.length];

        //arraycopy()：将arr数组的所有内容复制到arr2中
        System.arraycopy(arr,       //源数组
                    0,       //源数组的起始位置
                        arr2,       //目标数组
                          0,//目标数组的起始位置
                        arr.length  //复制的数量
                );

        //打印arr2中的元素
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }

        char[] chars = {'a', 'b', ' ', 'c', 'd', 'e'};
        //要求：将后面c,d,e三个字符依次前移一位，最后一位，留"空格字符"
        System.arraycopy(chars, 3, chars, 2, 3);
        //处理最后一个
        chars[chars.length - 1] = ' ';

        //最后打印
        System.out.println(chars);


        //currentTimeMillis()：获取系统时间毫秒值
        StringBuilder bld = new StringBuilder();
        String s = "";
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000000; i++) {
//            bld.append(i);//400多毫秒
            s += i;//很长很长时间
        }
        long end = System.currentTimeMillis();
        System.out.println("用时：" + (end - start) + " 毫秒");
    }
}