Características de Java son:

• The Java Virtual Machine - La Máquina Virtual de Java
• Interoperabilidad de Plataforma (Multiplataforma)
• Garbage Collection - Recolector de basura
• JAVA es Simple, Orientado a Objetos, Seguro, Multi Hilos
• Code Security - Código de Seguridad

La Máquina Virtual de Java

• Java Virtual Machine (JVM)
  Es una máquina imaginaria que se ejecuta por software de emulación en una maquina real.
  Proporciona las especificaciones de la plataforma del hardware sobre la cual se compila todo el código.
  
  
• Bytecode
  Es un lenguaje de maquina especial que puede ser entendido por la maquina virtual de Java.
  Independiente del hardware que posea una computadora, cualquier computadora con un intérprete de Java puede ejecutar el programa Java compilado, no importa que tipo de programa haya sido compilado.

  Interoperabilidad de Plataforma (Multiplataforma)
  "Write Once, Run Anywhere" (Escríbalo una vez ejecútelo en todos lados)
  

  Garbage Collection - Recolector de basura
  Hilo del Recolector de Basura
  Es responsable de liberar toda la memoria que puede ser liberada.
  Esto sucede automáticamente durante el tiempo de vida de un programa Java.
  De esta forma el programador es liberado de la carga de tener que liberar la memoria no utilizada.

  JAVA es Simple, Orientado a Objetos, Distribuido, Interpretado y Compilado a la vez, Robusto, Seguro, Multi Hilos y Dinámico
  Java fue diseñado para hacer más fácil el desarrollo de código sin Bugs. Fácil de leer y escribir.
  Es muy difícil escribir un programa Java que colapse tu sistema.
  Por otra parte, disminuye los errores más comunes de programación, al eliminar cosas como:

  • La aritmética de punteros.
  • Las referencias.
  • Los Registros (struct).
  • La definición de tipos (typedef).
  • Las macros (#define).

  Orientado a Objetos:

  Java fue diseñado como un lenguaje orientado a objeto desde el principio, a diferencia de C++, que fue una extensión del lenguaje C. en Java, cada objeto se agrupa en estructuras encapsuladas con sus datos y los métodos que manipulan esos datos.
  La tendencia del futuro, a la que Java se suma, apunta hacia la programación orientada a objetos, especialmente en entornos cada vez más complejos y basados en red.

  Distribuido:

  Java proporciona una colección de clases para su uso en aplicaciones de red, que permiten abrir sockets, establecer y aceptar conexiones con servidores o clientes remotos, lo que facilita la creación de aplicaciones distribuidas.

  Interpretado y compilado a la vez:

  Java es compilado, ya que su código fuente se trasforma en una suerte de código de maquina (bytecodes) semejante a las instrucciones de assembler.
  Por otra parte, es interpretado, ya que dichos bytecodes se pueden ejecutar directamente sobre cualquier maquina en la cual se haya instalado el interprete.

  Robusto:

  Java fue diseñado para crear sistemas fiables.
  Para ello proporciona muchas comprobaciones en compilación y en tiempo de ejecución.

  Seguro:

  Ya que por naturaleza es distribuido, la seguridad fue una necesidad de vital importancia.
  Implementa barreras de seguridad en el lenguaje y en el sistema de ejecución en tiempo real.

  Multitarea:

  El lenguaje Java soporta sincronización de múltiples hilos de ejecución (multithreading) a nivel de lenguaje, especialmente útiles en la creación de aplicaciones de red distribuidas.
  Así, mientras un hilo se encarga de la comunicación, otro puede interactuar con el usuario, mientras que otro presenta una animación en pantalla, y otro realiza cálculos.

  Dinámico:

  El lenguaje Java y sus sistema de ejecución en tiempo real son dinámicos en la fase de enlazado. Las clases sólo se enlazan a medida que son necesitadas. Se pueden enlazar nuevos módulos de código bajo demanda, procedente de fuentes muy variadas, incluso desde la red.

  Code Security - Código de Seguridad

  • El código de seguridad en Java se logra a través de la implementación del JRE (Entorno del tiempo de Ejecución JAVA).
    
    
  • JRE Ejecuta el código compilado por una JVM y realiza la carga de clases (a través del cargador de clases - class loader), el código de verificación (a través del verificador de bytecodes - bytecode verifier) y finalmente ejecuta el código.
    
    
  • Cargador de clases
    Es responsable de cargar todas las clases necesarias para el programa Java.
    Proporciona seguridad separando los namespace para las clases del sistema de archivos locales de los que se importan de la red.
    Después de cargar todas las clases, la distribución del ejecutable en la memoria es determinada.
    Esto proporciona protección contra el acceso no autorizado a las zonas restringidas del código en la memoria esto se determina durante el tiempo de ejecución.
    
    
  • Verificador de bytecodes
    Comprueba el formato del código y chequea el código en búsqueda de código ilegal que pueda violar los derechos de acceso a los objetos.
    
    
  
  

  Los lenguajes de propósito general,
  son lenguajes que pueden ser usados para varios propósitos, acceso a bases de datos, comunicación entre computadoras, comunicación entre dispositivos, captura de datos, cálculos matemáticos, diseño de imágenes o páginas, crear sistemas operativos, manejadores de bases de datos, compiladores, entre muchas otras cosas.
  En general, puede ser usado para cualquier desarrollo. Para ciertas tareas más comunes, existen librerías para facilitar la programación que permiten la reutilización de código.

  Un namespace,
  en español espacio de nombre, es un término informático que se utiliza en programación, se refiere a una colección de nombres de entidad definidos por el programador, se puede resumir un namespace cómo un conjunto de nombres en el cual todos los nombres son únicos.

  Un recolector de basura (en inglés, garbage collector) es un mecanismo implícito de gestión de memoria implementado en algunos lenguajes de programación de tipo interpretado o semi-interpretado.

  Breve reseña histórica:
  El concepto de recolección de basura fue inventado por John McCarthy en 1959 para evitar la gestión manual de memoria en el lenguaje Lisp.

  Contexto:
  Cualquier programa informático hace uso de una cierta cantidad de memoria de trabajo puesta a su disposición por el sistema operativo. Esta memoria tiene que ser gestionada por el propio programa para:

  • Reservar espacios de memoria para su uso.
  • Liberar espacios de memoria previamente reservados.
  • Compactar espacios de memoria libres y consecutivos entre sí.
  • Llevar cuenta de qué espacios están libres y cuáles no.

  Generalmente, el programador dispone de una biblioteca de código que se encarga de estas tareas.
  No obstante, el propio programador es responsable de utilizar adecuadamente esta biblioteca.
  Esto tiene la ventaja de que se hace un uso eficiente de la memoria, es decir, los espacios de memoria quedan libres cuando ya no son necesarios. No obstante, este mecanismo explícito de gestión de memoria es propenso a errores.
  Por ejemplo, un programador puede olvidar liberar la memoria de manera que, tarde o temprano, no quede memoria disponible, abortando la ejecución del programa.
  Como alternativa es necesaria una gestión implícita de memoria, donde el programador no es consciente de la reserva y liberación de memoria. Esto es obligado en algunos lenguajes de programación donde no se maneja el concepto de memoria.

  Cómo funciona:
  Cuando un lenguaje dispone de recolección de basura, el programador no tiene que invocar a una subrutina para liberar memoria. La reserva de memoria también es más o menos automática sin la intervención del programador.

  Por ejemplo:

  • En los lenguajes orientados a objetos: se reserva memoria cada vez que el programador crea un objeto, pero éste no tiene que saber cuanta memoria se reserva ni cómo se hace esto.
  • En los lenguajes declarativos: cada vez que se construye una expresión se reserva memoria (de una manera inteligente), pero el programador no es consciente de ello.

  Cuando se compila el programa, automáticamente se incluye en éste una subrutina correspondiente al recolector de basura.
  Esta subrutina también es invocada periódicamente sin la intervención del programador.
  El recolector de basura es informado de todas las reservas de memoria que se producen en el programa. Además, el compilador colabora para que sea posible llevar una cuenta de todas las referencias que existen a un determinado espacio de memoria reservado.

  Cuando se invoca el recolector de basura, recorre la lista de espacios reservados observando el contador de referencias de cada espacio. Si un contador ha llegado a cero significa que ese espacio de memoria ya no se usa y, por tanto, puede ser liberado.
  Naturalmente, este proceso consume un cierto tiempo en el que no se hace nada verdaderamente útil para el propósito del programa. Por tanto, no puede ser invocado con demasiada frecuencia.
  En consecuencia, el único inconveniente a este mecanismo es determinar cuándo se tiene que ejecutar el recolector de basura. Existen varios algoritmos para hacerlo, pero el más eficiente es el primero de ellos:

  • Esperar a que no quede memoria libre, y entonces, ejecutar el recolector de basura.
  • Fijar un espacio de ocupación de la memoria libre y ejecutar el recolector de basura cuando se supere dicho espacio.
  • Ejecutar el recolector de basura a intervalos regulares (no siempre es posible).
  • Ejecutar el recolector de basura justo antes de cada reserva de memoria.
  • Permitir al programador que invoque explícitamente al recolector de basura cuando quiera.

  Ventajas y desventajas: Las ventajas y desventajas de este mecanismo de gestión de memoria son las opuestas al mecanismo explícito:

  • El programador no puede cometer errores y queda liberado de la tediosa tarea de gestionar la memoria.
  • La memoria permanece retenida durante más tiempo del estrictamente necesario.
  • El recolector de basura tarda cierto tiempo en hacer su tarea y produce pausas que pueden hacer la técnica incompatible con sistemas de tiempo real.

  Cómo se implementa: Existe la posibilidad de implementar la recolección de basura como una biblioteca de código más, pero por norma general no es así. El propio diseño de ciertos lenguajes de programación hace necesaria la existencia del recolector de basura.
  Para poder implementar estos lenguajes se requieren dos actuaciones:

  • Que el compilador proporcione la información necesaria para el recolector de basura (el contador de referencias).
  • Que el entorno de ejecución o máquina virtual implemente la subrutina del recolector de basura.
  • Ejemplos de lenguajes con recolector de basura: BASIC, C#, Java, JavaScript, Lisp, Perl, PHP, Python, Ruby, Smalltalk.
  PARADIGMA
  Más mueven los ejemplos que las palabras...!!!
  Séneca
  Volver CLASES y OBJETOS
  La verdadera potencia de Java como lenguaje orientado a objetos son: las clases y los objetos.
  
  La construcción de una clase Mí Punto, modeliza un punto en un espacio plano:
  
  class MiPunto{
  int x, y;
  int metodoSuma( int paramX, int paramY ) {
  return ( paramX + paramY );
  }
  
  double distancia(int x, int y) {
  int dx= this.x – pX;
  int dy = this.y – pY;
  return Math.sqrt(dx*dx + dy*dy);
  }
  
  void metodoVacio( ) { }
  void inicia( int paramX, int paramY ) {
  x = paramX;
  y = paramY;
  }
  void inicia2( int x, int y ) {
  x = x; // Ojo, no modificamos la variable de instancia!!!
  this.y = y; // Modificamos la variable de instancia!!!
  }
  MiPunto( int paramX, int paramY ) {
  this.x = paramX; // Este this se puede omitir
  y = paramY; // No hace falta this
  }
  
  MiPunto() {
  inicia(-1,-1); //Por defecto ; this(-1,-1) hace lo mismo
  }
  }
  

  Definición de una clase

  
  El elemento básico de la programación orientada a objetos en Java es la clase. Una clase define la forma y comportamiento de un objeto.
  Para crear una clase sólo se necesita un archivo fuente que contenga la palabra clave reservada class seguida de un identificador legal y un bloque delimitado por dos llaves para el cuerpo de la clase.
  
  class MiPunto { } Un archivo de Java debe tener el mismo nombre que la clase que contiene, y se les suele asignar la extensión ".java".
  Por ejemplo la clase MiPunto se guardaría en un fichero que se llamase MiPunto.java. Hay que tener presente que en Java se diferencia entre mayúsculas y minúsculas; el nombre de la clase y el de archivo fuente han de ser exactamente iguales.
  
  

  Aunque la clase MiPunto es sintácticamente correcta, es lo que se viene a llamar una clase vacía, es decir, una clase que no hace nada. Las clases típicas de Java incluirán variables y métodos de instancia. Los programas en Java completos constarán por lo general de varias clases de Java en distintos archivos fuente.
  
  

  Una clase es una plantilla para un objeto.
  Por lo tanto define la estructura de un objeto y su interfaz funcional, en forma de métodos. Cuando se ejecuta un programa en Java, el sistema utiliza definiciones de clase para crear instancias de las clases, que son los objetos reales.
  Los términos instancia y objeto se utilizan de manera indistinta. La forma general de una definición de clase es:
  
  class Nombre_De_Clase {
  tipo_de_variable nombre_de_atributo1;
  tipo_de_variable nombre_de_atributo2;
  // . . .
  
  tipo_devuelto nombre_de_método1( lista_de_parámetros ) {
  cuerpo_del_método1;
  }
  
  tipo_devuelto nombre_de_método2( lista_de_parámetros ) {
  cuerpo_del_método2;
  }
  // . . .
  }
  
  Los tipos tipo_de_variable y tipo_devuelto, han de ser tipos simples Java o nombres de otras clases ya definidas.
  Tanto Nombre_De_Clase, como los nombre_de_atributo y nombre_de_método, han de ser identificadores Java válidos.
  
  

  Los atributos

  
  Los datos se encapsulan dentro de una clase declarando variables dentro de las llaves de apertura y cierre de la declaración de la clase, variables que se conocen como atributos. Se declaran igual que las variables locales de un método en concreto.
  
  Por ejemplo, este es un programa que declara una clase MiPunto, con dos atributos enteros llamados x e y.
  
  class MiPunto {
  int x, y;
  }
  
  Los atributos se pueden declarar con dos clases de tipos: un tipo simple Java (ya descritos), o el nombre de una clase (será una referencia a objeto,). Cuando se realiza una instancia de una clase (creación de un objeto) se reservará en la memoria un espacio para un conjunto de datos como el que definen los atributos de una clase. A este conjunto de variables se le denomina variables de instancia.
  

  Los métodos
  Los métodos son subrutinas que definen la interfaz de una clase, sus capacidades y comportamiento.
  
  Un método ha de tener por nombre cualquier identificador legal distinto de los ya utilizados por los nombres de la clase en que está definido. Los métodos se declaran al mismo nivel que las variables de instancia dentro de una definición de clase.
  

  En la declaración de los métodos se define el tipo de valor que devuelven y a una lista formal de parámetros de entrada, de sintaxis tipo identificador separadas por comas. La forma general de una declaración de método es:
  
  tipo_devuelto nombre_de_método( lista-formal-de-parámetros ) {
  cuerpo_del_método;
  }
  
  Por ejemplo el siguiente método devuelve la suma de dos enteros:
  
  int metodoSuma( int paramX, int paramY ) {
  return ( paramX + paramY );
  }
  
  En el caso de que no se desee devolver ningún valor se deberá indicar como tipo la palabra reservada void. Así mismo, si no se desean parámetros, la declaración del método debería incluir un par de paréntesis vacíos (sin void):
  
  void metodoVacio( ) { };
  Los métodos son llamados indicando una instancia individual de la clase, que tendrá su propio conjunto único de variables de instancia, por lo que los métodos se pueden referir directamente a ellas.
  El método inicia() para establecer valores a las dos variables de instancia sería el siguiente:
  
  void inicia( int paramX, int paramY ) {
  x = paramX;
  y = paramY;
  }
  
  

  La instanciación de las clases: Los objetos

  Referencias a Objeto e Instancias

  
  Los tipos simples de Java describían el tamaño y los valores de las variables.
  Cada vez que se crea una clase se añade otro tipo de dato que se puede utilizar igual que uno de los tipos simples. Por ello al declarar una nueva variable, se puede utilizar un nombre de clase como tipo. A estas variables se las conoce como referencias a objeto.
  Todas las referencias a objeto son compatibles también con las instancias de subclases de su tipo.
  Del mismo modo que es correcto asignar un byte a una variable declarada como int, se puede declarar que una variable es del tipo MiClase y guardar una referencia a una instancia de este tipo de clase:
  
  MiPunto p;
  
  Esta es una declaración de una variable p que es una referencia a un objeto de la clase MiPunto, de momento con un valor por defecto de null.
  La referencia null es una referencia a un objeto de la clase Object, y se podrá convertir a una referencia a cualquier otro objeto porque todos los objetos son hijos de la clase Object.
  

  Constructores

  
  Las clases pueden implementar un método especial llamado constructor. Un constructor es un método que inicia un objeto inmediatamente después de su creación. De esta forma nos evitamos el tener que iniciar las variables explícitamente para su iniciación.
  
  

  El constructor tiene exactamente el mismo nombre de la clase que lo implementa; no puede haber ningún otro método que comparta su nombre con el de su clase. Una vez definido, se llamará automáticamente al constructor al crear un objeto de esa clase (al utilizar el operador new).
  
  El constructor no devuelve ningún tipo, ni siquiera void. Su misión es iniciar todo estado interno de un objeto (sus atributos), haciendo que el objeto sea utilizable inmediatamente; reservando memoria para sus atributos, iniciando sus valores...
  
  Por ejemplo:
  
  MiPunto( ) {
  inicia( -1, -1 );
  }
  
  Este constructor denominado constructor por defecto, por no tener parámetros, establece el valor -1 a las variables de instancia x e y de los objetos que construya.
  
  El compilador, por defecto, llamará al constructor de la superclase Object() si no se especifican parámetros en el constructor. Este otro constructor, sin embargo, recibe dos parámetros:
  
  MiPunto( int paraX, int paraY ) {
  inicia( paramX, paramY );
  }
  
  La lista de parámetros especificada después del nombre de una clase en una sentencia new se utiliza para pasar parámetros al constructor. Se llama al método constructor justo después de crear la instancia y antes de que new devuelva el control al punto de la llamada. Así, cuando ejecutamos el siguiente programa:
  
  MiPunto p1 = new MiPunto(10, 20);
  System.out.println( "p1.- x = " + p1.x + " y = " + p1.y );
  Se muestra en la pantalla:
  p1.- x = 10 y = 20
  
  Para crear un programa Java que contenga ese código, se debe de crear una clase que contenga un método main().
  El intérprete java se ejecutará el método main de la clase que se le indique como parámetro.
  
  

  El operador new

  El operador new crea una instancia de una clase (objetos) y devuelve una referencia a ese objeto. Por ejemplo:
  
  MiPunto p2 = new MiPunto(2,3);
  
  Este es un ejemplo de la creación de una instancia de MiPunto, que es controlador por la referencia a objeto p2.
  Hay una distinción crítica entre la forma de manipular los tipos simples y las clases en Java: Las referencias a objetos realmente no contienen a los objetos a los que referencian. De esta forma se pueden crear múltiples referencias al mismo objeto, como por ejemplo:
  
  MiPunto p3 = p2;
  
  Aunque tan sólo se creó un objeto MiPunto, hay dos variables (p2 y p3) que lo referencian. Cualquier cambio realizado en el objeto referenciado por p2 afectará al objeto referenciado por p3. La asignación de p2 a p3 no reserva memoria ni modifica el objeto.
  De hecho, las asignaciones posteriores de p2 simplemente desengancharán p2 del objeto, sin afectarlo:
  
  p2 = null; // p3 todavía apunta al objeto creado con new
  
  Aunque se haya asignado null a p2, p3 todavía apunta al objeto creado por el operador new.
  
  Cuando ya no haya ninguna variable que haga referencia a un objeto, Java reclama automáticamente la memoria utilizada por ese objeto, a lo que se denomina recogida de basura (Realizada por el Garbage Collector).
  
  Cuando se realiza una instancia de una clase (mediante new) se reserva en la memoria un espacio para un conjunto de datos como el que definen los atributos de la clase que se indica en la instanciación. A este conjunto de variables se le denomina variables de instancia.
  
  La potencia de las variables de instancia es que se obtiene un conjunto distinto de ellas cada vez que se crea un objeto nuevo. Es importante el comprender que cada objeto tiene su propia copia de las variables de instancia de su clase, por lo que los cambios sobre las variables de instancia de un objeto no tienen efecto sobre las variables de instancia de otro.
  
  El siguiente programa crea dos objetos MiPunto y establece los valores de x e y de cada uno de ellos de manera independiente para mostrar que están realmente separados.
  
  MiPunto p4 = new MiPunto( 10, 20 );
  
  MiPunto p5 = new MiPunto( 42, 99 );
  
  System.out.println("p4.- x = " + p4.x + " y = " + p4.y);
  
  System.out.println("p5.- x = " + p5.x + " y = " + p5.y);
  
  Este es el aspecto de salida cuando lo ejecutamos.
  
  p4.- x = 10 y = 20
  
  p5.- x = 42 y = 99
  

  Acceso al objeto

  El operador punto (.)

  El operador punto (.) se utiliza para acceder a las variables de instancia y los métodos contenidos en un objeto, mediante su referencia a objeto:
  
  referencia_a_objeto.nombre_de_variable_de_instancia referencia_a_objeto.nombre_de_método( lista-de-parámetros ); Hemos creado un ejemplo completo que combina los operadores new y punto para crear un objeto MiPunto, almacenar algunos valores en él e imprimir sus valores finales:
  
  MiPunto p6 = new MiPunto( 10, 20 );
  System.out.println ("p6.- 1. X=" + p6.x + " , Y=" + p6.y);
  p6.inicia( 30, 40 );
  System.out.println ("p6.- 2. X=" + p6.x + " , Y=" + p6.y);
  Cuando se ejecuta este programa, se observa la siguiente salida:
  p6.- 1. X=10 , Y=20
  p6.- 2. X=30 , Y=40
  
  Durante las impresiones (método println()) se accede al valor de las variables mediante p6.x y p6.y, y entre una impresión y otra se llama al método inicia(), cambiando los valores de las variables de instancia.
  
  Este es uno de los aspectos más importantes de la diferencia entre la programación orientada a objetos y la programación estructurada. Cuando se llama al método p6.inicia(), lo primero que se hace en el método es sustituir los nombres de los atributos de la clase por las correspondientes variables de instancia del objeto con que se ha llamado. Así por ejemplo x se convertirá en p6.x.
  
  Si otros objetos llaman a inicia(), incluso si lo hacen de una manera concurrente, no se producen efectos laterales, ya que las variables de instancia sobre las que trabajan son distintas.
  

  La referencia this

  Java incluye un valor de referencia especial llamado this, que se utiliza dentro de cualquier método para referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el método actual. Se puede utilizar this siempre que se requiera una referencia a un objeto del tipo de una clase actual. Si hay dos objetos que utilicen el mismo código, seleccionados a través de otras instancias, cada uno tiene su propio valor único de this.
  
  Un refinamiento habitual es que un constructor llame a otro para construir la instancia correctamente. El siguiente constructor llama al constructor parametrizado MiPunto(x,y) para terminar de iniciar la instancia:
  
  MiPunto() {
  this( -1, -1 ); // Llama al constructor parametrizado
  }
  En Java se permite declarar variables locales, incluyendo parámetros formales de métodos, que se solapen con los nombres de las variables de instancia. No se utilizan x e y como nombres de parámetro para el método inicia, porque ocultarían las variables de instancia x e y reales del ámbito del método. Si lo hubiésemos hecho, entonces x se hubiera referido al parámetro formal, ocultando la variable de instancia x:
  
  void inicia2( int x, int y ) {
  x = x; // Ojo, no modificamos la variable de instancia!!!
  this.y = y; // Modificamos la variable de instancia!!!
  }
  

  La destrucción del objeto

  La destrucción de los objetos

  Cuando un objeto no va a ser utilizado, el espacio de memoria de dinámica que utiliza ha de ser liberado, así como los recursos que poseía, permitiendo al programa disponer de todos los recursos posibles. A esta acción se la da el nombre de destrucción del objeto.
  
  En Java la destrucción se puede realizar de forma automática o de forma personalizada, en función de las características del objeto.
  

  La destrucción por defecto: Recogida de basura.

  El intérprete de Java posee un sistema de recogida de basura, que por lo general permite que no nos preocupemos de liberar la memoria asignada explícitamente.
  
  El recolector de basura será el encargado de liberar una zona de memoria dinámica que había sido reservada mediante el operador new, cuando el objeto ya no va a ser utilizado más durante el programa (por ejemplo, sale del ámbito de utilización, o no es referenciado nuevamente).
  
  El sistema de recogida de basura se ejecuta periódicamente, buscando objetos que ya no estén referenciados.
  

  La destrucción personalizada: finalize

  A veces una clase mantiene un recurso que no es de Java como un descriptor de archivo o un tipo de letra del sistema de ventanas. En este caso sería acertado el utilizar la finalización explícita, para asegurar que dicho recurso se libera. Esto se hace mediante la destrucción personalizada, un sistema similar a los destructores de C++.
  
  Para especificar una destrucción personalizada se añade un método a la clase con el nombre finalize:
  class ClaseFinalizada{
  ClaseFinalizada() { // Constructor
  // Reserva del recurso no Java o recurso compartido
  }
  
  protected void finalize() {
  // Liberación del recurso no Java o recurso compartido
  }
  }
  
  El intérprete de Java llama al método finalize(), si existe cuando vaya a reclamar el espacio de ese objeto, mediante la recogida de basura. Debe observarse que el método finalize() es de tipo protected void y por lo tanto deberá de sobreescribirse con este mismo tipo.

  Te espero en:
  wilucha@gmail.com

  Esta page está en:
  www.wilocarpio.com.ar

  04/11/2004