El Lenguaje Java

Objetos y Clases

Un objeto en Java cumple las funciones que realiza un record en Pascal o una estructura en C. En Java las variables sólo pueden contener referencias a objetos, es decir punteros a objetos.
Todos los objetos se crean con new:
```
A a1= new A();
```
A es el tipo del objeto creado. También se dice que A es la clase del objeto o que el objeto es una instancia de la clase A. La variable a1 también es de tipo A, o análogamente a1 es de la clase A, porque a1 debe contener siempre referencias a objetos que pertenecen a la clase A.
Un objeto posee variables de instancia o campos que se pueden consultar o asignar. Los campos que posee un objeto se definen al momento de declarar la clase a la cual pertenece:
```
class A { int x, y; }
A a= new A();
a.x= 1;
a.y= 2;
System.out.println(a.x+" "+a.y); // 1 2
```

Un objeto también puede poseer métodos. Un método es un procedimiento cuya invocación siempre va asociada a un objeto. Los métodos se definen en la declaración de la clase:

class A {
  int x, y; // variables de instancia
  // Métodos
  void Set(int vx, int vy) { x= vx; y= vy; }
  void Incx() { x++; }
  void Print() { System.out.println(x+" "+y); }
}
A a= new A();
a.Set(10, 20);
a.Print();      // 10 20
a.Incx();
a.Print(); // 11 20
Incx(); // error, falta indicar el objeto
A a2= new A();
a2.Set(5, 6);
a2.Print();     // 5 6
a.Print();      // 11 20

La definición de 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.