一文带你搞懂Java中Object类和抽象类

1. Object类

在Java中，所有的类都继承自Object类。Object类是Java的基类，提供了一些通用的方法，如equals()、hashCode()、toString()等。

equals()

equals()方法用来判断两个对象是否相等。Object类的equals()方法实现的是比较两个对象的引用是否相等。如果要比较内容是否相等，需要在子类中重写该方法。

例如，有如下代码：

public class Person{
    private String name;
    private int age;
    //...
}

Person person1 = new Person("Tom", 18);
Person person2 = new Person("Tom", 18);

System.out.println(person1 == person2); //false
System.out.println(person1.equals(person2)); //false

虽然person1和person2的属性值相同，但它们是两个不同的对象，因此equals()方法返回false。如果重写equals()方法，可以实现比较两个对象的内容是否相等。

hashCode()

hashCode()方法用来获取对象的哈希值，也就是一个用来标识对象的整数。如果两个对象的equals()方法返回true，在这两个对象中的其中一个对象上调用hashCode()方法必须返回相同的整数。而如果两个对象的equals()方法返回false，则hashCode()方法可以返回相同的整数，也可以返回不同的整数。

toString()

toString()方法返回表示对象的字符串。默认实现返回对象的类名、一个'@'符号和该对象的哈希码的无符号十六进制表示形式。

2. 抽象类

抽象类是用abstract关键字声明的类。抽象类不能被实例化，只能被子类继承，并且子类必须实现抽象类中定义的所有抽象方法。抽象方法是指没有实现的方法，只有方法的声明，子类必须实现抽象方法才能被实例化。

例如，有如下代码：

public abstract class Shape{
    public abstract double getArea();
    public abstract double getPerimeter();
}

public class Circle extends Shape{
    private double radius;

    public Circle(double radius){
        this.radius = radius;
    }

    public double getArea(){
        return Math.PI * radius * radius;
    }

    public double getPerimeter(){
        return 2 * Math.PI * radius;
    }
}

Shape抽象类定义了两个抽象方法，getArea()和getPerimeter()，这两个方法在子类中必须被实现才能被实例化。Circle类是Shape抽象类的一个子类，实现了Shape类中定义的两个抽象方法，并定义了自己的属性和方法。

示例说明

示例1：equals()方法

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

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

    @Override
    public boolean equals(Object obj){
        if(this == obj){
            return true;
        }
        if(obj == null || getClass() != obj.getClass()){
            return false;
        }
        Student student = (Student) obj;
        return id == student.id && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode(){
        return Objects.hash(id, name);
    }
}

Student student1 = new Student(1, "Tom");
Student student2 = new Student(1, "Tom");

System.out.println(student1 == student2); //false
System.out.println(student1.equals(student2)); //true

在Student类中重写equals()和hashCode()方法，使得比较两个Student对象的内容是否相等。

示例2：抽象类

public abstract class Animal{
    private String name;

    public Animal(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    public abstract void sound();
}

public class Cat extends Animal{
    public Cat(String name){
        super(name);
    }

    @Override
    public void sound(){
        System.out.println("喵喵喵");
    }
}

public class Dog extends Animal{
    public Dog(String name){
        super(name);
    }

    @Override
    public void sound(){
        System.out.println("汪汪汪");
    }
}

Animal cat = new Cat("小花");
Animal dog = new Dog("小黑");

System.out.println(cat.getName()); //小花
cat.sound(); //喵喵喵
System.out.println(dog.getName()); //小黑
dog.sound(); //汪汪汪

Animal抽象类定义了一个抽象方法sound()，在子类中必须被实现。Cat和Dog类分别是Animal类的子类，实现了sound()方法并定义了自己的属性和方法。在主程序中实例化Cat和Dog对象，调用它们的方法。由于Animal类是抽象类，无法被实例化。