吊打面试官(九)--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 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 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类使用中所能想到的相关内容，如有遗漏或错误，欢迎留言指正。