不就是Java吗之Object类

3.1 Object的介绍

Object是Java默认提供的一个类，默认会继承Object父类(所有类的父类)。即所有类的对象都可以使用Object的引用进行接收。

class Money {
    public double money = 19.9;

}
class Person  {
    public int id = 1234;
    public Money m = new Money();

}

public class TestDemo1 {
    public static void main(String[] args) {
        Object o1 = new Person();//父类引用 引用 子类对象
        
        Object o2 = new Money();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Object里面还有一系列方法

3.2 equals方法

在Java中，== 进行比较时：

1. 如果==左右两侧是基本类型变量，比较的是变量中值是否相同
2. 如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
3. 如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认是按照地址比较的

举个栗子吧：

class Student {
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

}
public class TestDemo1 {
    public static void main(String[] args) {
        Student student1 = new Student("张三",20);

        Student student2 = new Student("张三",20);

        System.out.println(student1.equals(student2));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

打印出来的结果是false

正常来说不是打印的true吗，因为student1与student2一模一样啊，都叫张三，都是20岁。

这是因为我们student1与student2都是new出来的对象，new出来的就是新的，而equals比较的是两个对象的地址，这明显不同，所以打印false。我们可以通过调试来看到两个对象的地址

因为我们没有重写equals方法，才导致比较没有达到我们的预期，我们可以重写一下equals方法

右键->Generate->equals() and hashcode()->一路next

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age && Objects.equals(name, student.name);
}
1
2
3
4
5
6
7

我们来分析一下编译器为我们生成的重写的equals方法

那么在更改完之后，我们再次运行，可以看到结果为true了

所以我们要记得：比较对象中内容是否相同的时候，一定要重写equals方法。

3.3 hashcode方法

hashcode()就是计算具体的对象在内存中存在的地址(不是真实的地址，是通过一系列的变换生成的地址，也是独一无二的)

我们也可以重写hashcode方法

@Override
public int hashCode() {
    return Objects.hash(name, age);
}
1
2
3
4

3.4 接收引用数据类型

因为Object是所有类的父类，所以它可以接收所有数据类型，包括：类、数组、接口。

public class TestDemo2 {
    public static void main(String[] args) {
        //Object接收数组对象->向上转型
        Object o1 = new int[]{1,2,3};

        Object o2 = new Double[]{1.2,3.2};

        //向下转型->需要强转
        int[] data = (int[])o1;
        for (int i:data) {
            System.out.println(i+" ");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

interface Ishape {
    public void func();
}

class Test implements Ishape {
    @Override
    public void func() {
        System.out.println("重写");
    }
}
public class TestDemo3 {
    public static void main(String[] args) {
        Ishape ishape = new Test();//接口不能直接实例化，但是它可以实例化Test
        
        Object o = ishape;//向上转型：接口给object
        //o.func();//err:只能拿到object自己的方法
        
        Ishape ishape1 = (Ishape)o;
        ishape1.func();//向下转型可以访问func
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21