- 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.