Sobre JAVA

No se el nivel que tienes en programación, voy a suponer que es muy bajo, disculpa si no es así y te doy explicaciones demasiado obvias.
En java los parámetros siempre se pasan por referencia, es decir, el objeto es exactamente el mismo incluso físicamente.
Cuando se crea un objeto (StringBuffer palabra = new
StringBuffer("Java");), java guarda una parte de la memoria física para lamacenarlo.
Cuando pasas el objeto al método (probador. MiMetodo( palabra );), java realmente esta pasando la dirección de memoria donde están almacenados los datos.
En resumen, los datos son exactamente los mismos, la única diferencia es que durante el programa principal, la dirección de la memoria donde esta se llama "palabra" y durante el método de la clase se llama "strBuf". Pero recuerda, son los mismos datos en la misma dirección de memoria.
Espero haberte ayudado, si quieres ampliar la información sobre este u otros temas cuenta conmigo.

Es muy fácil, la clase Probador, simplemente es una entidad con un método, que es miMetodo, que tiene como único parámetro un StringBuffer.
Luego, para usar esta clase, es necesario tener una clase de tipo Probador, y para utilizar el método, tener un StringBuffer. Para ello se crea la variable palabra, que es de tipo StringBuffer.
Digamos que la relación entre palabra y StringBuffer, es que la primera es una variablae del tipo StringBuffer. Si sigue sin quedarte claro, vuelve a consultarme.

Hola de nuevo, he leído tu respuesta hasta aprendérmela y no sé si he cogido la idea. Te explico brevemente mis conclusiones, .(Creo que sigo liado)voy punto por punto para verlo más claro, algunas obvias pero que me ayudan:
*********SOBRE LA CLASE*************
1.- Tengo una clase que es "Probador" y un objeto que es "probador"
2.- Esa clase "Probador" tiene un método que es "miMetodo".
3.- Esa clase tiene un objeto de tipo StringBuffer que es "palabra"
*********SOBRE EL METODO*********
4.- "miMetodo" esta dentro de la clase "Probador"
5.- "miMetodo" tiene un parámetro, que es un objeto de StringBuffer. Este objeto se llama "strBuf".
Vaya, no puedo sacar más conclusiones y me falta lo esencial.
a.- ¿Tanto la clase como el método tienen dos objetos distintos de tipo StringBuffer?
b.-¿Que papel juega ese objeto "strBuf")
Bua, cuantas más vueltas le doy menos lo veo. ¿Algunos de los puntos es incorrecto?
Lo siento si te aburro, pero confío en que una segunda explicación me saque de dudas.
Muchísimas gracias.
Un saludo

Antes de nada, decirte que entiendo tus dudas si estás comenzando, te recomendaría el libro "Cómo programar en Java" de Deitel&Deitel, editado por PrenticeHall (creo), que es un gran libro para entender esas pequeñas cosas de la programación orientada a objetos que no se suelen explicar... Bien, dicho esto, el tema es que en una clase tú defines unos métodos y unas propiedades; los métodos reciben una serie de parámetros (que pueden ser objetos o tipos de datos básicos (int, String, long, char...)) o no. Para poder utilizar un método (a no ser que sea un método static), tienes que invocarlo a través de un objeto de esa clase (en tu ejemplo ese objeto sería probador, que tú defines como Probador probador, como si dijeras "creo un objeto llamado probador" (que podría tener cualquier otro nombre) que pertenece a la clase Probador) y luego lo inicializo (indispensable si no quieres que se generen errores) haciendo probador=new Probador();. Después creas un objeto de tipo StringBuffer que contiene la palabra "Java". A todos los efectos (por ahora), un StringBuffer es como un String... con unas pocas diferencias pero lo es. Utilizas el objeto llamado probador para invocar al método miMetodo pasándole por parámetro ese objeto StringBuffer pero que se sustituya el carácter que está en la posición 0 (la J) por una Y, quedando la palabra Yava. Después imprimes por pantalla la palabra resultante. La afirmación que tú haces, desgraciadamente, es falsa. Es decir, no se renombra ni sucede nada de lo que dices. Internamente, eso sí, se crea una copia de "palabra", se modifica en ese método y se actualiza el contenido de ese objeto. En ningún momento hay conversiones de objetos ni de nombres, lo único que sucede es que en tu método tienes que definir el tipo de datos que vas a recibir (si te van a pasar int, String, u otro tipo de objetos...), y se les asigna un nombre arbitrario para su uso dentro del método. Ese nombre es independiente del nombre del objeto que le hayas pasado por parámetro, es simplemente para utilizarlo dentro del método, no es visible fuera de ese método. Espero no haberme liado yo también y haberte ayudado en lo posible, si no te he ayudado o no te queda algo claro, no dudes en volver a preguntar.

Bien; creo que lo he entendido; te lo explico brevemente con mis palabras para ver si estoy en lo cierto:
"Hay que definir el tipo de datos que el método va a recibir, por lo tanto, dentro del paréntesis se pone el tipo de datos ( int, char,...) y se le asigna un nombre, ( en nuestro caso "strBuf", pero podía haber sido cualquier otro.
En definitiva, el parenetsis indica con que tipo de datos va a "trabajar" el método.
Bien, si esto es correcto, dímelo por favor.
Muchísimas gracias

Sí, efectivamente es exactamente lo que tú has dicho, en el paréntesis indicamos el tipo de datos que va a recibir como parámetros el método, al igual que delante del nombre del método indicamos el tipo de parámetro (aquí sólo se permite un tipo), que va a devolver el método. Veo que lo tienes muy claro, así que me alegro mucho. Si tienes alguna otra duda no te cortes y pregunta, que muchas veces nos quedamos atascados con dudas que alguien nos puede solucionar...