数组是否真为同质结构？Object数组存多类型的原理探究

Great question—this is a common point of confusion with Java's type system, so let's break it down clearly.

First, let's restate the core rule: Java arrays are homogeneous because they only hold elements of a single declared type (or types compatible with it, for reference arrays). Let's walk through each example to see how this plays out.

Let's Analyze Your Code Snippets #

First, here's your code for reference:

public class Test { 
    public static void main(String[] args) { 
        // Ex 1 
        int [] intArr = new int[5]; 
        intArr[0] = 1; 
        intArr[1] = 2; 
        // Ex 2 
        int [] intArr2 = new int[5]; 
        intArr2[0] = 1; 
        intArr2[1] = "ss"; // This won't compile!
        // Ex 3 
        Object [] objArr = new Object[5]; 
        objArr[0] = 1; // Autoboxed to Integer (a subclass of Object)
        objArr[1] = "ss"; // String is a subclass of Object
        objArr[3] = new Object(); 
    } 
}

Example 1: int[] intArr #

This is a straightforward primitive array. The array is declared to hold int values, so every element must be an int. Your assignments work perfectly here—this is the textbook example of a homogeneous array.

Example 2: int[] intArr2 #

This code will fail to compile! You're trying to assign a String ("ss") to an array that's explicitly typed to hold ints. Java's compiler enforces the homogeneous rule strictly for primitive arrays—no mixing types allowed. This is Java's type safety at work, ensuring the array stays true to its declared type.

Example 3: Object[] objArr #

This is the tricky one, but it still follows the homogeneous rule. Here's why:

• The array is declared as Object[], which means every element in this array must be an instance of Object (or any subclass of Object).
• In Java, every reference type (like String, Integer, custom classes) inherits directly or indirectly from Object. Even primitive values like 1 get autoboxed to their wrapper type (Integer) when stored in an Object array.
• So when you store 1, "ss", and a raw Object in this array, every element is still an Object from the compiler's perspective. The array is homogeneous because all elements are compatible with the declared type (Object). The "different types" you see are just subclasses of Object, which are allowed because of Java's inheritance rules.

The Core Principle #

Java is a statically typed language, so every array's type is fixed at compile time. The key takeaways are:

• For primitive arrays: Elements must be the exact declared primitive type—no exceptions. The compiler will block any incompatible assignments.
• For reference arrays: Elements can be the declared type or any of its subtypes. This gives the illusion of storing mixed types, but under the hood, the array only holds references compatible with its declared type.
• This rule is part of Java's type safety guarantees—it prevents you from accidentally putting the wrong type of data into an array, which would cause runtime errors.

内容的提问来源于stack exchange，提问作者Sandun Perera