What are the differences between references and pointers in C++ and in Java?

For a senior C++ programmer, the best way to explain java, or part of java, is to say:

• All declarations of variables, parameters, attributes, etc. that are of type Object or that inherit from Object are always "pointers".
• Objects never reside in the "stack" or in "global memory" they always reside in the java object heap.
• The reason that the C++ pointer (the "*") in such declarations does not exist in java is that it is always 100% implicit and it is impossible to declare object variables that are not pointers (C++ style without "*") . I mean objects that do not reside in the "heap".
• As all the declarations (variables etc) that inherit from Object are always pointers, and there is no possibility of anything else, they eliminated the "*", it is always implicit.
• "new" is always used to create new instances. New object instances cannot be created without "new". (or use of JNI).
• Objects cannot be "delete", it is the JVM that knows which objects are "alive" and which are not. The garbage collector looks at the "soup" of existing objects and from some "roots" knows to decide which is alive (is accessible) and which is no longer accessible from the "roots".
• Java objects can change their memory address over time. But the programmer never sees what those addresses are (unlike C++), and the JVM always maintains the integrity of the "soup" of java objects on the heap. When you move an address object, all references from clients change properly. This is 100% transparent to the programmer/user.
• Any variable, of type Object or inheriting from Object, can always be assigned null (ALL such declarations are pointers).

A very common source of confusion is thinking that references in Java and C++ are similar because they have the same name. This is indisputably false.

Consider a C++ or Java class called Dog with a constructor that supports a name and getName and setName methods.

In Java this code that uses references is valid:

Perro perroA = new Perro("Gordito");
// Puedes cambiar la referencia contenida en perroA
perroA = new Perro("Gruñon");
Perro perroB;  //  Puedes declarar una variable de tipo referencia
                // sin inicializarla explícitamente.
perroB = new Perro("Comilon"); // Y luego asignarle un objeto 
perroB = perroA; // Ahora perroA y perroB referencian el mismo objeto
perroA.asignaNombre("Fifi"); // Modifica tanto perroA como perroB
System.out.println(perroB.obtenerNombre()); // Imprimie "Fifi"

The same code in C++ using references does not compile and when it compiles (removing the lines marked with !!!) it does different things than in Java :

Perro perroObj1("Gordito");
Perro perroObj2("Comilon");

Perro& perroA = perroObj1; // Correcto
//  No puedes cambiar el objeto al que referencia 
// una variable tipo referencia en C++
perroA = Perro("Gruñon"); // Compila, pero no hace lo mismo que en Java
// perroA sique referenciando al mismo objeto, no a otro como en Java
// Lo que sucede en C++ es que se invoca el operador de asignación.
Perro& perroB; //  !!!Error compilacion. No puedes declarar variables 
               // referencia sin inicializarlas.
perroB = perroObj2; // !!! Demasiado tarde
Perro& perroB = perroObj2; // Correcto
perroB = perroA; // No hace lo mismo que en java
perroA.asignaNombre("Fifi"); // Modificamos perroA pero no perroB
std::cout << perroB.obtenerNombre() << std::endl; // Imprimie "Gruñon", no "Fifi"

The same code in C++ with pointers would be valid and does the same as in java.

Perro* perroA = new Perro("Gordito");
// Puedes cambiar el puntero contenido en perroA
perroA = new Perro("Gruñon"); 
Perro* perroB;  //  Puedes declarar una variable de tipo puntero 
                // sin inicializarla explícitamente.
perroB = new Perro("Comilon"); // Y luego asignarle un puntero a objeto  
perroB = perroA; // Ahora perroA y perroB apuntan al mismo objeto    
perroA->asignaNombre( "Fifi" ); // Modifica tanto perroA como perroB
std::cout << perroB->obtenerNombre() << std::endl; // Imprime "Fifi"

Java references are also very different from C++ references when it comes to parameter passing.

public static void main(String[] args)
{
    Perro unPerro = new Perro("Tim");
    cambiarNombre( unPerro );
}
public static void cambiarNombre(Perro p) {
    p = new Perro("Fifi"); // No modifica unPerro en main
}

C++ references also don't make aDog refer to another object, but unlike in Java, it does change the contents of unPerroen mainas a consequence of how the assignment operator works (assuming a normal implementation of the assignment operator):

int main(void)
{
    Perro unPerro("Tim");
    cambiarNombre( unPerro );
    return 0;
}
void cambiarNombre(Perro& d) {
    d = Perro("Fifi"); // Sí modifica unPerro en main
                       // a través del operador de asignación
}

In the case of arguments passed by pointer in C++ it has the same effects as in Java, since pointers in C++ are also passed by value, just like Java references:

int main(void)
{
    Perro* unPerro = new Perro("Tim");
    cambiarNombre( unPerro );
    return 0;
}
void cambiarNombre(Perro* d) {
    // Como en Java, no tiene efecto sobre la variable unPerro en main
    d = new Perro("Fifi");
}

So far Java references look a lot like C++ pointers and are very different from C++ references.
But there are also important differences between pointers in C++ and references in Java:

• Garbage collection. The C++ pointer examples above would have memory leaks, they require freeing memory with deleteso they don't occur.
• C++ pointers have pointer arithmetic.
• References in Java are strongly typed.
• References in Java are normally implemented by storing their memory addresses, just like in pointers, but this is not required in the Java specification and it would be possible to create a virtual machine in which references are associated with dictionary entries instead of to memory addresses or other indirection mechanisms.

Without going around too much, in Java everything is passed by value. The reason objects seem to be passed by reference is because actually when you pass an object as a parameter you are actually passing the value of the address in memory it points to, this is why you can change the properties of the object by its address, but if you try to re-instantiate, the address will be lost and a new one (from the recent instantiation) will be assigned.

Gato gato = new Gato("Minino");
System.out.println(gato.getNombre()); // Minino
cambiarGato(gato);

public void cambiarGato(Gato gato) { // dirección de gato
    gato.setNombre("Michifu");
    gato = new Gato("Firulais"); // se reasigna una nueva dirección y se pierde la dirección original
}

System.out.println(gato.getNombre()); // Michifu