Tratamiento de objetos en Java

#2 precisamente como en Java pasas las cosas por referencia, hacer que el puntero en matriz[3][4] sea null no peta nada. Sólo estás poniendo a null el puntero a objeto. No puedes destruir el objeto derreferenciándolo. De hecho, (a no ser que me equivoque) no puedes joder ningún objeto en Java si no es derreferenciándolo de todos los punteros a objeto posibles y que el recolector de basura se encargue de destruirlo.

Otra cosa es que realice operaciones sobre el objeto (cambios en sus atributos.) Estas se realizarían en el objeto y todas sus referencias apuntarían al objeto modificado (y ahí si hay que clonarlo para tener dos copias, pero pasan a ser dos referencias distintas.) Por la descripción del problema no parece que vaya a ser el caso en ningún momento.

Si se va con esto a StackOverflow el 90% de las respuestas le pedirán que se lea un libro de Java antes de preguntar.

#1 simplemente aprende Java. Google "manual java" o lo que sea, y a empollar.

Por cierto, es triste, pero no eres el único que conozco en situaciones parecidas en DAI. Si supiéras como ha llegado más de uno a la carrera...

#3 Si supieras cómo sale más de uno de la carrera xD

#7 Créeme lo sé xD Son profesores de ESO/Bachiller que reciben un cursillo del módulo que les toca impartir y pista.

Estáis diciendo que en Java se pasa todo por referencia, cuando Java pasa todos los argumentos por valor. Otra cosa es que para objetos, no tipos simples, pase punteros, pero no es referencia.

public void f(Object d) {
    d = null;
}

Object o = new...
f(o);
// Si se pasara por referencia o aquí sería null

#10 En C++ el paso por referencia no es pasar un puntero, es indicarle que es un argumento por referencia.

El código que he puesto, haciendo un símil, sería:

void f(int*& puntero) {
    puntero = NULL;
}

int* puntero = new int; // Tiene una direccion
f(puntero);
// Aquí puntero es NULL (además de provocar un memory leak puesto que no hemos liberado)

El típico ejercicio para enseñar el paso de parámetros por valor o referencia es el swap:

void swap(int& a, int& b) {
    int c = a;
    a = b;
    b = c;
}

int a = 1, b = 2;
swap(a, b);
// a == 2 y b == 1

Es muy útil para crear estructuras de datos pues que hacer cosas como estas son válidas (y correctas, claro), evitando tener que trabajar con elementos estando situado en sus padres, o cosas por el estilo:

void insertar(Nodo*& n, int x) {
    if (n == NULL) {
        n = new Nodo(x);
    }
    else /* lo que sea*/
}

Decir que C no tiene parámetros por referencia, aunque se simulan con un <tipo>* y las llamadas pasarle la dirección con &var

#12 *& si que existe, es pasar un puntero por referencia.

"Cuando se llama a la función, se hace un push a la pila con la dirección del puntero, y en caso de modificar el valor del puntero dentro de la función, sólo cambia la variable local. "

Tu mismo acabas de definir el paso por referencia. Java no hace eso nunca, hace una copia del valor de la variable. En el caso de ser un tipo básico habremos copiado el entero, char o lo que sea, en otro caso hemos copiado una dirección de memoria, pero no has pasado la dirección de la variable, si no su contenido.

No me lo invento, puedes buscarlo en Google xD

#12 http://ideone.com/OtGsK Aquí tienes un ejemplo de *&

Su potencial se ve con estructuras más complejas

#14 Tu mismo has definido el paso de una variable por referncia.

Si yo tengo esto:

variable x;

En la práctica el paso por referencia es hacer esto, como tu bien dices:
f(&x);

Si yo trabajo sobre "x" afecto al valor original contenido por "x" (esté en la pila o en el heap).

Eso lo ves muy claro con el tipo int, porque es un tipo básico:
int x = 10;
f(x); // f hace x = 0;
x vale 0

Sin embargo con un puntero debe de pasar lo mismo, tienes que pasar la dirección <b>al</b> puntero:
int* x = new int
f1(*x); // f1 hace x = 10;
// Aquí *x == 10
f2(x); // f2 hace detele x; x =NULL
// Aquí x == NULL

#16 Esto en Java no se puede hacer puesto que pasa todos los parámetros por valor:
Object o = new Object(); // Esto en C++ sería como Object* o = new Object
f(o); // Se copia el contenido de O al bloque de activación de la llamada de la función (y esto es la definición de paso de parámetro por valor). No se está poniendo la dirección de la variable O (definición de paso de parámetro por referencia), por lo que si haces un "o = NULL" dentro de la función fuera no pasa nada.

Edit: Me había dejado la última parte haciendo la referencia a Java ya que se me ha colgado el PC cuando estaba editando xD

#7 puedes hacer perfectamente matriz[1][2] = matriz[3][4]; matriz[3][4] = null; y no le pasaría nada a matriz[1][2]. Hacer un new cada vez que reasignas es una perdida de memoria increíble.

En java, pese a que trabajas directamente con objetos, todo son Referencias excepto los tipos primitivos que guardan sus valores en la propia referencia.

Si le pasas un objeto a un método y modificas el estado del objeto dentro del método, fuera de ésta también estará cambiado.

Para poder reconocer qué tienes en cada objeto de la matriz puedes usar la palabra reservada "instanceof".

Ejemplo

boolean isMonkey(Object o){
    return o instanceof Monkey;
}

Por cierto, lo que dice #2 de no usar el clone es una soberana soplapollez. Es normal que los clone no funcionen si no haces que tus clases implementen la interfaz Clonable porque usan el clone de la clase padre Object aunque tus clases no la hereden explícitamente.

#26 Lo que pasa es que cuando pasas un objeto que no es basico pasa una copia de la direccion del objeto
Vamos, lo que viene a ser paso por referencia.

#28 que coño hablas.

Java a las funciones envía la dirección de memoria del objeto, en caso de tipos primitivos el valor está implicito en su valor del 'puntero'.

No se en qué centro has estudiado pero eso es un paso por referencia.

Otra cosa es que en C puedas pasar punteros a referencias de objetos, que si apuntas a otro sitio, si que varía, pero pork el contenido del puntero del parámetro es en sí la referencia a otra variable.

PD: Te recomiendo la lectura del libro SCJP 6 página 191