Why are Java primitive types' modifiers public, abstract, and final?

Question

In the process of doing some reflection on Java types, I came across an oddity that I do not understand.

Inspecting int for its modifiers returns public, abstract, and final. I understand public and final, but the presence of abstract on a primitive type is non-obvious to me. Why is this the case?

Edit: I am not reflecting on Integer but on int:

import java.lang.reflect.Modifier;  public class IntegerReflection {     public static void main(final String[] args) {         System.out.println(String.format("int.class == Integer.class -> %b", int.class == Integer.class));         System.out.println(String.format("int.class modifiers: %s", Modifier.toString(int.class.getModifiers())));         System.out.println(String.format("Integer.class modifiers: %s", Modifier.toString(Integer.class.getModifiers())));     } } 

The output when run:

int.class == Integer.class -> false int.class modifiers: public abstract final Integer.class modifiers: public final 

Answer 1

According to the JLS 8.1.1.1 - Abstract Classes:

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

By definition, there can be no instances of int.class. You can't compile this kind of code:

int a = new int(); 

There are no constructors for int. There are no objects created. int.class does not even extend Object. If you run the following line of code, you will get null as the result.

System.out.println(int.class.getSuperclass()); 

So because you can never have a true instance of the int.class, it is by definition abstract. Also, according to the Integer API, the Integer.TYPE field (which holds int.class) is a class which only represents the primitive type.

This is proven by the following code:

int a = 4; System.out.println(int.class.isInstance(a)); 

This returns false.

As such, int.class is likely just used in the system for representation purposes, as said in the Integer API. The fact that there is also a void.class type but no null.class type makes me think that this is used primarily with Reflection. This is just conjecture, though.

---

If anyone is interested, the int.class essentially contains nothing that the reflection package recognizes and is likely just a dummy class. If you run the following code, you will see that it has no constructors, no fields, and no methods.

Method[] intMethods = int.class.getMethods();  if(intMethods.length == 0) {     System.out.println("No methods."); } else {     for(Method method : intMethods) {         System.out.println(method.getName());     } }  Constructor[] intConstructors = int.class.getConstructors();  if(intConstructors.length == 0) {     System.out.println("No constructors."); } else {     for(Constructor constructor: intConstructors) {         System.out.println(constructor.getName());     } }  Field[] intFields = int.class.getFields();  if(intFields.length == 0) {     System.out.println("No fields."); } else {     for(Field field: intFields) {         System.out.println(field.getName());     } }