isAbstract() 修饰符返回不正确的结果 - 为什么？

Question

To my understanding the following code should print False as output

However, when I ran this code it is printing True as output.

From Java docs:

Return true if the integer argument includes the abstract modifier, false otherwise.

public class Test{
    public static void main(String[] args) {
        System.out.println(Modifier.isAbstract(byte[].class.getModifiers())); 
    }
}

Can some one help me understand this behavior ?

Answer 1

The Javadoc of int java.lang.Class.getModifiers() specifies what should be returned for some of the modifiers for array types (for example, the final modifier is required to be true and the interface modifier is required to be false ). On the other hand, it doesn't specify what the abstract or static modifiers should be for array types, which means the decision to return true or false is not documented in the JDK. Therefore any implementation can choose to return either true or false .

int java.lang.Class.getModifiers()

Returns the Java language modifiers for this class or interface, encoded in an integer. The modifiers consist of the Java Virtual Machine's constants for public, protected, private, final, static, abstract and interface; they should be decoded using the methods of class Modifier.

If the underlying class is an array class, then its public, private and protected modifiers are the same as those of its component type . If this Class represents a primitive type or void, its public modifier is always true, and its protected and private modifiers are always false. If this object represents an array class , a primitive type or void, then its final modifier is always true and its interface modifier is always false . The values of its other modifiers are not determined by this specification.

The modifier encodings are defined in The Java Virtual Machine Specification, table 4.1.

Answer 2

A hint to this behavior may be found in the JLS, 10.8. Class Objects for Arrays :

Every array has an associated Class object, shared with all other arrays with the same component type.

Although an array type is not a class, the Class object of every array acts as if: [snipped]

Under this reasoning, an array isn't a "real" class, so it definitely isn't a concrete class. The same logic would apply to int.class being considered abstract.

Answer 3

The definition of abstract says:

An abstract class is a class that is incomplete, or to be considered incomplete.

If there were a pure array like [] then it would be indeed incomplete since no component type is provided.

This would violate the specification of 15.10.1. Array Creation Expressions :

It is a compile-time error if the ClassOrInterfaceType does not denote a reifiable type.

It does not just denote a reifiable type but no type at all. Thus it would be inpossible to create instances of [] - just like for abstract classes.

Since there is no pure array [] this is only kind of speculation. Moreover the modifiers were returned for byte[] . It remains the specification shown by Eran .

Answer 4

My explantation would be, that arrays are considered abstract because the are instantiated by the JVM itself.

There just exists no concrete class for any array type.

An array has a contract defined by the JLS :

1. Index Accessability
2. Implementation for Cloneable and Serializable

But nobody except the Language itself can fulfill those, because we can't really declare an implementation ourself.

Answer 5

From My understanding the java language specification for getModifier() is:

If the underlying class is an array class, then its public, private and protected modifiers are the same as those of its component type. If this Class represents a primitive type or void, its public modifier is always true, and its protected and private modifiers are always false

Now, The values of its other modifiers are not determined by this specification eg ABSTRACT .

From JVMS Table 4.1-A:

ACC_ABSTRACT 0x0400 Declared abstract; must not be instantiated.