Java int not an object

Is int[] an object? [duplicate]

They are value types, not reference types. Object class in its hierarchy.

Is int[] an object? [duplicate]

Had a look, and I can’t seem to find a question that is the same as this. My question is about int[] in Java.

When you create an int[] , you use this syntax:

The methods that are part of int[] also make me think it’s an Object , but it doesn’t follow the Java naming convention for classes, which is what’s confusing me. It is also an array of a primitive type, which can be used like a primitive.

Is an int[] (or any primitive array I guess) an object, or a primitive?

An array in Java is a subclass of Object , therefore it’s an object type — even if it contains primitive types. You can check this:

int[] x = new int[5]; if (x instanceof Object) System.out.println("It's an Object!"); 

All arrays in Java are considered objects. You can see this in the Java Language Specification, Ch. 10:

In the Java programming language, arrays are objects (§4.3.1), are dynamically created, and may be assigned to variables of type Object (§4.3.2). All methods of class Object may be invoked on an array.

The type int[] is a subclass of Object that has all the method from Object . Although syntactically it looks different from other object types (e.g. the name has a primitive type listed in it and there’s no class definition), the Java language does consider them objects.

«An array is a container object that holds a fixed number of values of a single type.».This is how array is defined in oracle tutorials.So not only primitive array but also object array is a Object itself.

int[] x = new int[5]; Object a=(Object)x; int[] y= (int[])a; 

Inheritance — Is int an object in Java?, From «Primitive Data Types»: «Primitive types are special data types built into the language; they are not objects created from a class.» That, in turn, means that no, int doesn’t inherit from java.lang.Object in any way because only «objects created from a class» do that. Consider: int x = 5; In order for the thing … Usage examplejava.lang.Number y = new java.lang.Integer(5);Feedback

Integers are not objects in Java, just because they are not instances of a class?

There are already some similar questions (e.g. Why data type in java are not object?) but I still not clear.

This is the definition of objects from oracle’s document:

An object is a software bundle of related state and behavior.

I think nnn has the type int , and the state my value is 3 , although has no behavior. Why it’s not an object?

Then look at the following iii which is an object:

Integer iii = new Integer(3); 

I found some other explanations which says «objects are instances of some class in Java». (Sorry I can’t find where I read it)

So the value nnn is not object in Java, the most important reason is it’s not an instance of some class?

So that the definition of object in Java should be: An object is a software bundle of related state and behavior, and in Java, it should be an instance of some class. Right?

Thanks for answering my question. I found I need to make this question clear since I found many people didn’t notify my explanation in comments, when people commented «it’s not an object because it has no behavior».

We know Object has some built-in methods, like toString , equals , etc. So when I define a class, say:

class User extends Object < // empty body >

The instance of User will have these methods(behaviors) too. But what if Object hasn’t provide all these methods? In this case, new User() here won’t have any methods(behaviors), then we should not consider it’s an object?

Sorry guys, I’m really puzzled now 🙁

From Java Language Specification. Chapter 4. Types, Values, and Variables.:

4.1. The Kinds of Types and Values

There are two kinds of types in the Java programming language: Primitive Types (§4.2) and reference types (§4.3). There are, correspondingly, two kinds of data values that can be stored in variables, passed as arguments, returned by methods, and operated on: primitive values (§4.2) and reference values (§4.3).

4.2. Primitive Types and Values

A primitive type is predefined by the Java programming language and named by its reserved keyword (§3.9):

PrimitiveType :

NumericType
boolean

NumericType :

IntegralType
FloatingPointType

IntegralType :
byte short int long char

FloatingPointType :
float double

4.3. Reference Types and Values

There are four kinds of Reference types: class types (§8.1), interface types (§9.1), type variables (§4.4), and array types (§10.1).

4.3.1. Objects

An object is a class instance or an array .
The reference values (often just references) are pointers to these objects, and a special null reference, which refers to no object.

So, an object is basically a variable which is not a primitive type. The primitive types are: byte, short, int, long, char, float, double and boolean. You should not confuse these primitive types with their class wrappers: Byte, Short, Integer, Long, Character, Float, Double and Boolean, respectively.

In case Object class doesn’t define any method at all, then creating a class with no methods won’t have any behavior at all, but in Java, by the definition of object, or a better term: reference value , is a variable that refers to an instance of a class or an array, which is basically any non-primitive type. Note that a reference value may not need any behavior at all , the behavior is defined in the class , and a reference value may use it or not.

The example you showed is a Reference type vs a primitive type. There are a few others, such as char vs. Character and Long vs long

The class variations of these primitives contain methods, fields and your other standard class-components. The primitives on the other hand are JUST the value. For example, if I wanted the string representation of a number.

3 has no methods. its a value. However, the class Integer has a toString method which prints its value. By creating an instance of Integer with the value 3 ( new Integer(3) ) you create a class and fill one of its fields.

This has its own uses, as does typing an argument or variable with int . This simply informs the interpreter that the value is of a certain type.

An object is like a snapshot of a class. So it can vary with time. In other words, it can vary in state and can behave differently with different state. An object can hold other objects too. In your example, nnn has a state but it shows no behavior

The logic behind is quite simple for Java. Object can be called instance of class that is derived from java.lang.Object class in its hierarchy.

In case of the primitives like char int or long the inheritance does not take place.

The consequence of that is that on any java object you are able to invoke method toString(). The key behind that is that you tell an object to perform some action. You can not tell a primitive to do something.

But however the concept of object is not defined by any language. This is more a paradigm aspect.

Difference between an Integer and int in Java with, In Java, int is a primitive data type while Integer is a Wrapper class. int, being a primitive data type has got less flexibility. We can only store the binary value of an integer in it. Since Integer is a wrapper class for int data type, it gives us more flexibility in storing, converting and manipulating an int data.; Integer is a …

How is int implemented in Java?

According to the docs on Integer class:

The Integer class wraps a value of the primitive type int in an object. An object of type Integer contains a single field whose type is int.

By default, the int Data type is a 32-bit signed two’s complement integer, which has a minimum value of -2^31 and a maximum value of 2^31-1 .

also, according to this Answer:

In Java, every variable has a type declared in the source code. There are two kinds of types: Reference types and primitive types. Reference types are references to objects. Primitive types directly contain values.

So, my question is : How is the int primitive type implemented in Java? Integer being a class can imagine creating its object. However again Integer class uses int . In what way is int implemented to java so that we are allowed to use it and allowed to perform all its arithmetic operations. An insight onto this would be much helpful.

I tried many existing answers and articles, however did not find an answer to my question, that include:

• Primitive Data types
• Class Integer
• Java: Primitive Data types
• Can an int be null in Java?
• Primitive data type

If any part of my question is unclear/incorrect, kindly let me know in the comments section.

int and other primitive types are implemented directly by the Java compiler and the JVM. They are not classes. They are value types, not reference types.

The compiler emits byte codes like iload, iadd, and istore, with no method dispatch involved.

Integer is pretty much an ordinary class. Its instances are allocated on the heap. Each instance contains an int value.

Java Int Keyword, The int contains minimum value of -2 31 and a maximum value of 2 31 -1. From Java 8, we can use int as an unsigned 32-bit integer, which has a minimum value of 0 and a maximum value of 2 32 -1. Its default value is 0. Its default size is 4 byte. It is generally used as a default data type for integral values.

Comparing Integer objects vs int

I fixed an endless loop by changing Integer to int in the following:

What is the proper reason for this? I figured Integer would compare no problem.

Because when you make != comparing on the object it compares the references. And the references between two objects in general case are different.

When you compare ints it always compares primitives, lets say not references( there are no objects ), but the values.

So, if you want to work with Integer you must use equals() on them.

Additionally, if your values are between 0 and 255 the comparison between Integer works fine, because of caching.

You can read here: http://download.oracle.com/javase/tutorial/java/data/numberclasses.html

Integer is an Object , and objects are compared with .equals(..)

Only primitives are compared with ==

That’s the rule, apart from some exceptional cases, where == can be used for comparing objects. But even then it is not advisable.

The problem is that Integer is a class and therefore even comparison is done like for any other class — using the .equals() method. If you compare it using ==, you compare the references which are always different for two distinct instances. The primitive type int is not a class but a Java built-in type and the comparison is thus handled specially by the compiler and works as expected.

You can use Integer.intValue() to get the int value for comparison, if you truly need to use Integer at all.

Object Definition in Java, In object-oriented programming terminology, an object is a member of Java class. It is also known as instance of the class. Note that objects are created at run time. In simple words, object is a real word entity. For example, dog, car, pen, desk, etc. Each object shares the following two characteristics: Identity: Object identity is a …

Источник