吊打面试官(九)--Java语言Object类一文全掌握

导读

在Java中，Object类用于所有类的基类，是在Java代码中使用最多的类。本文从基础使用，使用问题，使用场景，底层原理等方面全面解析该类的各个方面，帮助您通过面试取得高薪。

使用Object类的场景

作为通用类型

可以代表任意类型，例如在集合框架中，像 ArrayList 、 HashMap 等集合类可以存储 Object 类型的对象，ArrayList<Object> list = new ArrayList<>(); ，这样可以存储任意类型的对象。

示例代码：

```java
import java.util.ArrayList;
import java.util.List;

// 定义一个包含不同类型数据的类结构
class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

class Car {
    private String model;
    public Car(String model) {
        this.model = model;
    }
    public String getModel() {
        return model;
    }
}

public class ObjectAsGeneralTypeExample {
    public static void main(String[] args) {
        List<Object> objects = new ArrayList<>();
        objects.add(new Person("John"));
        objects.add(new Car("Toyota Camry"));

        for (Object obj : objects) {
            if (obj instanceof Person) {
                Person person = (Person) obj;
                System.out.println("Person: " + person.getName());
            } else if (obj instanceof Car) {
                Car car = (Car) obj;
                System.out.println("Car: " + car.getModel());
            }
        }
    }
}

这里通过 instanceof 关键字在进行类型转换之前先判断对象的类型，避免了 ClassCastException 。

多态实现

当编写方法需要接受多种类型的参数时，可以将参数类型定义为 Object 。例如一个方法 public void printObject(Object obj) ，它可以接收任何对象并打印相关信息。

示例代码：

```java
interface Shape {
    double getArea();
}

class Circle implements Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    private double length;
    private double width;
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    @Override
    public double getArea() {
        return length * width;
    }
}

public class PolymorphismWithObjectExample {
    public static void printArea(Shape shape) {
        System.out.println("Area: " + shape.getArea());
    }

    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);
        printArea(circle);
        printArea(rectangle);
    }
}
```

对象克隆

如果要实现对象的克隆功能，需要实现 Cloneable 接口并且重写 clone 方法，而 clone 方法的返回类型是 Object 。

示例代码：

```java
class Employee implements Cloneable {
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }
}

public class CloneExampleDetail {
    public static void main(String[] args) throws CloneNotSupportedException {
        Employee original = new Employee("Alice", 5000);
        Employee cloned = (Employee) original.clone();
        System.out.println("Original: " + original.getName() + ", " + original.getSalary());
        System.out.println("Cloned: " + cloned.getName() + ", " + cloned.getSalary());
    }
}
```

使用Object类需要注意的风险

1. 类型转换风险 - 这个示例展示了不恰当的类型转换会导致运行时异常。在实际开发中，如果要存储多种类型对象并且需要进行特定类型的操作，应该先进行类型检查，例如使用`instanceof`关键字。

示例代码：

```java
import java.util.ArrayList;

public class TypeCastingRiskDetail {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        list.add(new Integer(10));
        Object obj = list.get(0);
        if (obj instanceof String) {
            String str = (String) obj;
        } else {
            System.out.println("Object is not a String, cannot cast.");
        }
    }
}
```

这里通过 instanceof 进行了类型检查，避免了不恰当的类型转换。

2. equals和hashCode方法 如果不重写`hashCode`方法，当把`MyObject`对象放入基于哈希的集合（如`HashMap`、`HashSet`）时可能会出现问题。因为这些集合依赖于对象的`hashCode`值来进行快速查找和比较。

示例代码：

```java
import java.util.HashSet;
import java.util.Set;

class Student {
    private int id;
    public Student(int id) {
        this.id = id;
    }

    @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;
    }

    // 注释掉hashCode方法重写会导致问题
    // @Override
    // public int hashCode() {
    //     return Integer.hashCode(id);
    // }
}

public class EqualsHashCodeProblem {
    public static void main(String[] args) {
        Set<Student> studentSet = new HashSet<>();
        Student s1 = new Student(1);
        Student s2 = new Student(1);
        studentSet.add(s1);
        studentSet.add(s2);
        System.out.println(studentSet.size()); // 如果不重写hashCode，这里结果可能不符合预期
    }
}
```

这个示例展示了在集合中使用自定义对象时，不重写 hashCode 方法可能导致的问题。

3. 空指针异常 - 在很多复杂的业务逻辑中，对象的来源可能比较复杂，很容易出现未初始化或者被意外置为`null`的情况。所以在调用对象方法之前，一定要进行空值判断，可以使用`if (obj!= null)`这样的条件语句。

示例代码：

```java
class Config {
    private String value;
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }
}

public class NullPointerExceptionDetail {
    public static void main(String[] args) {
        Config config = null;
        try {
            System.out.println(config.getValue());
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException: " + e.getMessage());
        }
    }
}
```

这里通过 try - catch 块捕获了可能出现的 NullPointerException ，在实际应用中这是一种处理空指针异常的方式。

4. 内存泄漏 - 在实际的长时间运行的应用程序（如服务器端程序）中，内存泄漏问题可能会逐渐消耗系统资源，导致程序性能下降甚至崩溃。要避免这种情况，需要注意对象的生命周期管理，及时释放不再使用的对象引用。

这里通过在一定条件下清理 vector 中的引用，避免了内存泄漏的无限增长情况。

示例代码：

```java
import java.util.Vector;

class MemoryLeakObject {
    private byte[] largeData = new byte[1024 * 1024]; // 1MB数据
}

public class MemoryLeakExampleDetail {
    private static Vector<MemoryLeakObject> vector = new Vector<>();

    public static void main(String[] args) {
        while (true) {
            MemoryLeakObject obj = new MemoryLeakObject();
            vector.add(obj);
            // 模拟程序运行一段时间后清理部分引用
            if (vector.size() > 100) {
                vector.clear(); // 及时清理引用，避免内存泄漏
            }
        }
    }
}
```

Object类的底层原理

对象头信息：

Mark Word

Mark Word用于存储对象自身的运行时数据，如哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。在不同的JVM实现和不同的情况下，Mark Word存储的具体内容有所不同。Mark Word的设计使其能够在很小的空间内存储尽可能多的数据，并且会根据对象的状态动态变化。这种设计提高了内存使用效率，并且使得JVM能够快速获取对象的元数据。

Class Pointer

Class Pointer指向对象所属的类的元数据，用于标识对象的类型。在JVM中，每个类都有对应的元数据，称为类的类元数据（Class Metadata）。这个指针存储在对象的对象头中，用来指向对象的类型（即类的定义）。Class Pointer的存在使得JVM能够确定对象的类型，从而可以访问到该类的所有方法、字段以及类级别的元数据。这对于动态分派和类型检查至关重要。

对象头对`Object`类方法的影响

Object 类的方法hashCode() 和 equals() ，都依赖于对象头中的信息。

例如， hashCode() 方法返回的对象哈希码存储在对象头的Mark Word中，而 equals() 方法则依赖于对象的类型信息（通过Class Pointer确定）以及对象的字段值。

正确实现 hashCode() 和 equals() 方法对于使用哈希表等集合类至关重要。这些方法依赖于对象头中的信息，因此必须确保它们的实现既正确又高效。

结语

以上内容就是关于Object类使用中所能想到的相关内容，如有遗漏或错误，欢迎留言指正。