METODO

R/un método tiene las siguiente sintaxis:
tipo-retorno nombre-método
       ( tipo-parámetro nombre, ... )
{ instrucciones }
Si el procedimiento no retorna nada se coloca void. En las instrucciones las variables que se accesen que no sean parámetros o variables locales del procedimiento deben ser variables de instancia del objeto.

Una variable de tipo objeto es una referencia (puntero) a un objeto:

A a1= new A();
A a2= new A();
A a3= a2;
a1.Set(1,2);
a2.Set(5,6);
a3.Set(8,9);
a1.Print(); // 1 2
a2.Print(); // 8 9
a3.Print(); // 8 9

En este caso las variables a2 y a3 referencian el mismo objeto, mientras que a1 y a2 referencian objetos distintos.

Una referencia puede ser pasada como argumento y puede ser retornada por un método.

class A {
  ...
  void CopyFrom(A from) { x= from.x; y= from.y }
  A MakeCopy()
  {
    A acopy= new A();
    acopy.Set(x, y);
    return acopy;
  }
}

A a1= new A();
a1.Set(1,2);
A a2= new A();
a2.CopyFrom(a1);
a2.IncX();
a2.Print(); // 2 2
a1.Print(); // 1 2
A a3=a1.MakeCopy();
a3.Print(); // 1 2

Dentro de un método, el identificador this contiene una referencia al objeto con que se invocó este método.

class A {
  ...
  void CopyTo(A to)
  { to.CopyFrom(this); }
}

En Java no existe enlace directo entre identificador y objeto como en C o Pascal:

En C o C++
  A a;   // a es el objeto
  A *pa; // pa es una referencia al objeto
En Pascal
  var a: A;  // a es el record
      a: A^; // a es una referencia al objeto

Las variables se pueden inicializar con la referencia nula:

A a;
a= null;
a.x= 0;    // error, a es la ref. nula

Un objeto puede referenciar otros objetos:

class Eslabon {
  Eslabon next;
  A a;
  void Encadenar(Eslabon anext) { next= anext; }
}
...
for(Eslabon e= prim; e!=null; e= e.next)
  e.a.Print();

Los arreglos y strings son objetos predefinidos.

String s= null;
s.substring(1,2); // error
int[] a= null;
a[0]=0;           // error

Se pueden crear arreglos de referencias a objetos. No se pueden crear arreglos de objetos.

A[] aArr= new A[10];
aArr[0].x=1; // error, aArr[0] es nulo
for (int i=0; i<aArr.length; i++)
  aArr[i]= new A();

Ningún objeto se destruye explícitamente: No hay free ni delete

A a= new A();
a= new A();   

El objeto que se creó primero ya no es alcanzable y por lo tanto el recolector de basura recuperará el espacio que ocupa.