A continuacion se muestra un ejemplo que deja clara la idea de dos objetos iguales en el
sentido de que poseen el mismo valor para sus atributos y de dos referencias que apuntan al
mismo objeto.

	class Ejemplo
	 {
	public static void main( String args[] ) {
		Esfera miesfera1 = new Esfera();
		Esfera miesfera2;
		Esfera miesfera3 = new Esfera();
		miesfera1.radio = 1.0;
		miesfera2 = miesfera1;
		miesfera3.radio = 1.0;
		System.out.println("Las referencias miesfera1 y miesfera2 " +
		(miesfera1==miesfera2?"si":"no")+" apuntan al mismo objeto");
		System.out.println("Las referencias miesfera3 y miesfera1 " +
		(miesfera3==miesfera1?"si":"no")+" apuntan al mismo objeto");
	       }
	}

La salida del programa anterior es la siguiente:

Las referencias miesfera1 y miesfera2 si apuntan al mismo objeto
Las referencias miesfera3 y miesfera1 no apuntan al mismo objeto

donde se muestra que las referencias miesfera1 y miesfera2 apuntan al mismo objeto
mientras que las referencias miesfera3 y miesfera1 apuntan a objetos distintos, aunque
estos tengan el mismo valor para su atributo.

******************************************************************************************************
Destruccion de objetos

Dado que la memoria que utilizan los objetos es dinamica, cabe suponer que sera necesario
algun mecanismo para poder recuperar ese espacio de memoria cuando ya no sea necesario, es
decir, algo parecido al operador delete de C++, por ejemplo. Sin embargo, la liberacion de
memoria en Java es automatica. Java posee un mecanismo denominado Garbage Collection
mediante el cual, y de forma periodica, localiza objetos que no tengan ninguna referencia que
les apunte para liberar la memoria que estan utilizando. Un objeto sin referencia es, seguro,
un objeto que no se utilizara mas dado que no existe forma alguna de tener acceso a el. De esta
manera, la liberacion de memoria asignada a un objeto se puede forzar simplemente quitando
todas las referencias al mismo, por ejemplo, asignando el valor null a dichas referencias.

************************************************************************************************************
Metodos

Como se ha mencionado anteriormente, un metodo es un “trozo” de codigo que se encapsula
de manera independiente del resto del codigo. Desde este punto de vista, coincide
con el concepto de funcion, procedimiento o subrutina de otros lenguajes. Esto es asi dado
que puede recibir unos parametros o argumentos, y puede devolver un valor como resultado.
Sin embargo, al contrario que en los lenguajes no orientados a objetos, los metodos no son
completamente independientes, pertenecen siempre a una clase y solo tienen sentido dentro
de la misma dado que tienen como cometido acceder a sus atributos.
La estructura de un metodo es la siguiente:

	tipo_de_dato nombre_de_metodo ( lista_de_argumentos ) {
		// Cuerpo del metodo
	}


donde tipo_de_dato especifica, bien un tipo de dato simple, bien un tipo de dato definido
por el usuario o bien nada, en cuyo caso se utiliza la palabra reservada void. Despues,
figura un identificador valido para el nombre del metodo y, entre parentesis, una lista de
argumentos separados por comas que puede estar vacia. Los argumentos se componen de un
nombre precedido de su tipo de dato. Aunque existan varios argumentos con el mismo tipo
de dato, cada uno ha de llevar especificado su tipo. El cuerpo del metodo es un bloque de
codigo englobado entre llaves aun cuando est´e constituido por una sola instrucci´on.
El ejemplo siguiente muestra la clase Esfera a la que se ha incorporado el m´etodo area.

	class Esfera {
		double radio;
		double area( ) {
		    return 4.0 * 3.14159 * radio * radio;
		}
	}


Cabe mencionar que, desde el punto de vista del diseño orientado a objetos, es mas
apropiado incluir un metodo como este dentro de la clase que averiguar el area del objeto
desde fuera de la misma tal y como se ha hecho en ejemplos anteriores. En general y como
estrategia de diseno orientado a objetos, se pretende dotar al objeto de toda aquella funcionalidad
que pueda llevar a cabo, es decir, encapsular en la clase que define su tipo de dato
todo lo que le atañe en cuanto a atributos y comportamiento.

Los metodos pueden verse de alguna manera como “solicitudes de servicio” que se realizan
sobre el objeto sobre el que es llamado el metodo desde fuera del mismo. El c´odigo siguiente
seria la version correcta del ejemplo de la pagina 52. En lugar de realizar calculos externos
sobre atributos de un objeto (calculo del area en el ejemplo), desde el punto de vista de la
programacion orientada a objetos resulta mas adecuado solicitar que el objeto realice por
si mismo dichos calculos en el metodo area y ofrezca el resultado tal como muestra el codigo
siguiente:

class Ejemplo {
   public static void main( String args[] ) {
   Esfera miesfera1 = new Esfera();
   Esfera miesfera2 = new Esfera();
   miesfera1.radio = 1.0;
   miesfera2.radio = 2.0;
   System.out.println(" ´Area de la esfera 1: " + miesfera1.area() );
   double a = miesfera2.area();
   System.out.println(" ´Area de la esfera 2: " + a );
   }
}


ofreciendo como resultado la misma salida que en el caso anterior.