What is the difference between a pointer and a reference variable in Java?

Question

My Java book explains that to use objects, we can assign them to reference variables. How is that different from a pointer to an object? Does Java have pointers?

T

Answer 1

In terms of Java syntax - it's true, that Java doesn't have pointers, but to clarify situation - Java Runtime has pointers. Every time GC occurs, there is a big chance, that your object stored in the heap will physically change it's memory address. This is achievable only by using what is really called Pointer. As you come from C++ world - you know reference restrictions. But it doesn't mean that JVM doesn't use references =).

For further information take a look at Ordinary Object Pointer

So, as you have brief understanding of core JVM memory management, you can consider Java Reference term as Pointer at runtime.

No, there is no pass by reference at all. Only pass by value, since the real Java method argument is a copy of Java Reference, therefore - another Pointer.

So, in syntax usage way - Java Reference is closer to C++ Reference, but in real Runtime world it's close to Pointer.

P.s. for more clarification it's better to read more articles about Ordinary Object Pointer or take a loot at oop.hpp.

Answer 2

If we think of references or pointers as a kind of means to access or handle the object in memory, they are much the same. However, they are different in terms of implementation. Following are the differences:

1. Pointers support pointer arithmetic and this makes them a kind of unsafe. Because they provide the programmer with an access level that is much more than needed. However, references provide an handle to the object through a much more abstract hided implementation.

2. Pointers are less strongly typed and references are more strongly typed. By this I mean the code is much simple in case of references and slightly less formal in case of pointers. You need to make use of reinterpret_cast kind of things to use pointers casts and on the other hand, references support easy casts of the kind of primitive kind of casts in "C".

3. Pointers are unsafe and references are safe. If you have an option between the two select references. In languages like C#, you have this freedom.

4. Pointers exists in C/C++ and references exist in Java. Do not confuse references in C/C++ with references in Java. References in C/C++ is a kind of synonym used for the rvalue of a pointer in C/C++.

Answer 3

As Java does not support pointers. It may appear that references are special kind of pointers. But we must note the key difference: with a pointer, we can point any address (which is actually a number slot in a memory). So, it is quite possible that with a pointer, we can point an invalid address also and then we may face surprises issues during runtime. But reference types will always point to valid addresses or they will point to null.

Answer 4

A reference is sort of like a pointer that you can't do arithmetic on... although it's more opaque. While the underlying bits may be an address in virtual memory, they don't have to be. They're just a way of getting to an object (or representing the null value). So while they're not exactly the same, if you're used to thinking of a pointer as "a way of identifying an object or navigating to it" (in some sense) then yes, those thoughts apply to references too.

Java doesn't have pointers as such (unlike, say, C# which has references and pointers - the latter being used in "unsafe" code).

Answer 5

Cat x = new Cat();

This line creates a Cat object in memory and stores a reference to it in x.

x now contains a reference to the Cat object, but if you were to do:

x = x + 1;

This would not give the next memory address like in C, but would give a compiler error. Java doesn't allow control to the reference or memory location.

Answer 6

A reference is a pointer that you can't normally see the value of (i.e., the memory address). The only operations allowed are to set it (from another reference) and to reference through it to the referred-to object. It can be set from a reference-valued expression, such as the new operator, or from another reference (which is syntactically a simple reference-valued expression).