Clases e interfaces internas static

Se conocen también con el nombre de clases anidadas {nested class es). Las clases e interfaces internas static sólo pueden ser creadas dentro de otra clase al máximo nivel. es decir directamente en el bloque de definición de la clase contenedora y 110 en un bloque más interno. Es posible definir clases e interfaces internas static dentro de una interface contenedora. 

Este tipo de clases internas se definen utilizando la palabra static. Todas las interfaces internas son implícitamente static. E11 cierta forma, las clases internas static se comportan como clases normales en un package. Para utilizar su nombre desde fuera de la clase contenedora hay que precederlo por el nombre de la clase contenedora y el operador punto (.) 

Este tipo de relación entre clases se puede utilizar para agrupar varías clases dentro de una clase más general. Lo mismo puede decirse de las interfaces internas. Las clases internas static pueden ver y utilizar los miembros static de la clase contenedora. No se necesitan objetos de la clase contenedora para crear objetos de la dase interna static. 

Los métodos de la clase interna static 110 pueden acceder dilectamente a los objetos de la clase contenedora, caso de que los haya: deben disponer de una referencia a dichos objetos, como cualquier otra clase. La sentencia import puede utilizarse para importar una dase interna static. en la misma forma que si se tratara de importar una clase de un package (con el punto (.)). Por ejemplo, si la interface Linkable es interna a la clase List, para implementar dicha interface hay que escribir,

... implements List.Linkable

y para importarla hay que usar,

import List.*; // o bien
import List.Linkable;

Otras características importantes son las siguientes: 

1. Pueden definirse clases e interfaces internas dentro de interface y clases contenedoras, con las cuatro combinaciones posibles. 

2. Puede haber varios niveles. esto es una clase interna static puede ser clase contenedora de otra clase interna static. y así sucesivamente. 

3. Las clases e interfaces internas static pertenecen al package de la clase contenedora. 

4. Pueden utilizarse los calificadores final, public. prívate y protected. Esta es una forma más de controlar el acceso a ciertas clases. A continuación se presenta un ejemplo de clase interna static:

// fichero ClasesIntStatic.java

class A {

int i=l;              // variable miembro de objeto

static int is=-l; // variable miembro de clase
public A(int i) {this.i=i;} // constructor

// a los métodos de la clase contenedora hay que pasarles referencias
//          a los objetos de la clase interna static

public void printA(Bs unBs) {

System, out.println("i=^,,+i+^,, unBs. j="+unBs . j) ;

> 

// definición de una clase interna static
static class Bs {
int j=2;

public Bs(int j) {this.j=j;} // constructor

// los métodos de la clase interna static no pueden acceder a la i
//         pues es una variable de objeto. Si pueden acceder a is

public void printBs() {

System.out.println(" j=" + j + " is=" + is) ;

> 

} // fin clase Bs

} // fin clase contenedora A

class ClasesIntStatic {

public static void main(String [] arg) {

A al = new A(ll), a2 = new A(12);

println("al.i=" + al.i + " a2.i=" + a2.i);

// dos formas de crear objetos de la clase interna static

A.Bs bl = new A.Bs(-lO); // necesario poner A.Bs

A.Bs b2 = al.new Bs(-ll); // b2 es independiente de al

// referencia directa a los objetos bl y b2

println("bl.j =" + bl.j + " b2.j=" + b2.j);

// los métodos de la clase interna acceden directamente a las variables
//         de la clase contenedora sólo si son static

bl.printBs(); // escribe: j=-10 is=-l
b2.printBs(); // escribe: j=-20 is=-l

// a los métodos de la clase contenedora hay que pasarles referencias
//         a los objetos de la clase interna, pera que puedan identificarlos

al.printA(bl); // escribe: i=ll unBs.j=-10
al.printA(b2); // escribe: i=ll unBs.j=-ll

} // fin de main()

public static void println(String str) {System.out.println(str);}
} // fin clase ClasesIntStatic

Utilización de interfaces

Una clase interna es una clase definida dentro de otra clase, llamada clase contenedora, en alguna variante de la siguiente forma general:.

class ClaseContenedora {

class Claselnternja {
}

}

Las clases internas fueron introducidas en la versión Java 1.1. Además de su utilidad en sí. las clases internas se utilizan mucho en el nuevo modelo de eventos que se introdujo en dicha versión de Java. Hay cuatro tipos de clases internas: 

1. Clases internas static. 

2. Clases internas miembro.

3. Clases internas locales. 

4. Clases anónimas. 

En lo sucesivo se utilizará la terminología clase contenedora o clase global para hacer referencia a la clase que contiene a la clase interna. 

Hay que señalar que la JVM (Java Virtual Machine) no sabe nada de la existencia de clases internas. Por ello, el compilador convierte estas clases en clases globales. contenidas en ficheros *.class cuyo nombre es ClaseContenedoraSClaselnterna.class. Esta conversión inserta variables ocultas, métodos y argumentos en los constructores. De todas formas, lo que más afecta al programador de todo esto es lo referente al nombre de los ficheros que aparecen en el directorio donde se realiza la compilación, que pueden resultar sorprendentes si no se conoce su origen.

Utilización de interfaces

Las constantes definidas en una interface se pueden utilizar en cualquier clase (aunque no implemente la interface) precediéndolas del nombre de la interface. como por ejemplo (suponiendo que PI hubiera sido definida en Dibujable):

area = 2.0*Dibujable.PI*r;

Sin embargo, en las clases que implementan la interface las constantes se pueden utilizar directamente, como si fueran constantes de la clase. A veces se crean interfaces para agrupar constantes simbólicas relacionadas (en este sentido pueden en parte suplir las variables enuin de C/C++). 

De cara al polimorfismo, el nombre de una interface se puede utilizar como un nuevo tipo de referencia. En este sentido, el nombre de una interface puede ser utilizado en lugar del nombre de cualquier clase que la implemente. aunque su uso estará restringido a los métodos de la interface. Un objeto de ese tipo puede también ser utilizado como valor de retomo o como argumento de un método.

Herencia en interfaces

Entre las interfaces existe una jerarquía (independiente de la de las clases) que permite herencia simple y múltiple. Cuando una interface deriva de otra, incluye todas sus constantes y declaraciones de métodos. Una interface puede derivar de varias interfaces. 

Para la herencia de interfaces se utiliza asimismo la palabra extends. seguida por el nombre de las interfaces de las que deriva, separadas por comas. 

Una interface puede ocultar una constante definida en una super-interface definiendo otra constante con el mismo nombre. De la misma forma puede ocultar, re-declarándolo de nuevo, la declaración de un método heredado de una super-interface.

Las interfaces 110 deberían ser modificadas más que en caso de extrema necesidad. Si se modifican, por ejemplo añadiendo alguna nueva declaración de un método, las clases que hayan implementado dicha interface dejarán de funcionar, a menos que implementen el nuevo método.

Definición de interfaces

Una interface se define de un modo muy similar a las clases. A modo de ejemplo se reproduce aquí la definición de la interface Dibujable dada en el Apartado

// fichero Dibujable.java

import java.awt.Graphics;

public interface Dibujable {

public void setPosicion(double x, double y);
public void dibujar(Graphics dw) ;

}

Cada interface public debe ser definida en un fichero *.java con el mismo nombre de la interface. Los nombres de las interfaces suelen comenzar también con mayúscula. Las interfaces no admiten más que los modificadores de acceso public y package. Si la interface no es public no será accesible desde fuera del package (tendrá la accesibilidad por defecto, que es package). Los métodos declarados en una interface son siempre public y abstract. de modo implícito.

INTERFACES

Concepto de interface 

Una interface es un conjunto de declaraciones de métodos (sin definición). También puede definir constantes, que son implícitamente public. static y final, y deben siempre inicializarse en la declaración. Estos métodos definen un tipo de conducta. Todas las clases que implementan una determinada interface están obligadas a proporcionar una definición de los métodos de la interface. y en ese sentido adquieren una conducta o modo de funcionamiento. 

Una clase puede implementar una o varias interfaces. Para indicar que una clase implementa una o más interfaces se ponen los nombres de las interfaces. separados por comas, detrás de la palabra implements, que a su vez va siempre a la derecha del nombre de la clase o del nombre de la super-clase en el caso de herencia. Por ejemplo.

public class CirculoGrafico extends Circulo

implements Dibujable, Cloneable {

}

¿Qué diferencia hay entre una interface y una clase abstract? Ambas tienen en común que pueden contener varias declaraciones de métodos (la clase abstract puede además definirlos). A pesar de esta semejanza, que hace que en algunas ocasiones se pueda sustituir una por otra, existen también algunas diferencias importantes: 

1. Una clase no puede heredar de dos clases abstract. pero sí puede heredar de una clase abstract e implementar una interface. o bien implementar dos o más interfaces. 
2. Una clase 110 puede heredar métodos -definidos- de una interface. aunque sí constantes. 
3. Las interfaces permiten mucha más flexibilidad para conseguir que dos clases tengan el mismo comportamiento, inpendientemente de su situación en la jerarquía de clases de Java. 
4. Las interfaces permiten "publicar" el comportamiento de una clase desvelando un mínimo de información. 
5. Las interfaces tienen una jerarquía propia, independiente y más flexible que la de las clases, ya que tienen permitida la herencia múltiple. 
6. De cara al polimorfismo (recordar el Apartado 1.3.8, a partir de la página 15). las referencias de un tipo interface se pueden utilizar de modo similar a las clases abstract.

CLASES Y MÉTODOS FINALES

Recuérdese que las variables declaradas como final 110 pueden cambiar su valor una vez que han sido inicializadas. En este apartado se van a presentar otros dos usos de la palabra final. Una clase declarada final 110 puede tener clases derivadas. Esto se puede hacer por motivos de seguridad y también por motivos de eficiencia, porque cuando el compilador sabe que los métodos 110 van a ser redefinidos puede hacer optimizaciones adicionales. Análogamente, un método declarado como final 110 puede ser redefinido por una clase que derive de su propia clase.

Constructores en clases derivadas

Ya se comentó que un constructor de una clase puede llamar por medio de la palabra this a otro constructor previamente definido en la misma clase. En este contexto, la palabra this sólo puede aparecer en la primera sentencia de un constructor. 

De forma análoga el constructor de una clase derivada puede llamar al constructor de su super-clase por medio de la palabra super(). seguida entre paréntesis de los argumentos apropiados para uno de los constructores de la super-clase. De esta forma, un constructor sólo tiene que inicializar directamente las variables no heredadas. 

La llamada al constructor de la super-clase debe ser la primera sentencia del constructor4, excepto si se llama a otro constructor de la misma clase con this(). Si el programador 110 la incluye. Java incluye automáticamente una llamada al constructor por defecto de la super-clase. super(). Esta llamada en cadena a los constructores de las super-clases llega hasta el origen de la jerarquía de clases, esto es al constructor de Object. 

Como ya se ha dicho, si el programador 110 prepara un constructor por defecto, el compilador crea uno. inicializando las variables de los tipos primitivos a sus valores por defecto, y los Stríngs y demás referencias a objetos a nuil. Antes, incluirá una llamada al constructor de la super-clase.

En el proceso de finalización o de liberación de reclusos (diferentes de la memoria reservada con nen\ de la que se encarga el garbage collector), es importante llamar a los finalizadores de las distintas clases, normalmente en orden inverso al de llamada de los constructores. Esto hace que el finalizador de la sub-clase deba realizar todas sus tareas primero y luego llamar al finalizador de la super-clase en la forma super.finalize(). Los métodos finalize() deben ser al menos protected. ya que el método finalize() de Object lo es, y 110 está permitido reducir los permisos de acceso en la herencia.

Clases y métodos abstractos

Una clase abstracta (abstract) es una clase de la que 110 se pueden crear objetos. Su utilidad es permitir que otras clases deriven de ella, proporcionándoles un marco o modelo que deben seguir y algunos métodos de utilidad general. Las clases abstractas se declaran anteponiéndoles la palabra abstract, como por ejemplo.

public abstract class Geometria { ... }

Una clase abstract puede tener métodos declarados como abstract. en cuyo caso 110 se da definición del método. Si una clase tiene algún método abstract es obligatorio que la clase sea abstract. E11 cualquier sub-clase este método deberá bien ser redefinido. bien volver a declararse como abstract (el método y la sub-clase). 

Una clase abstract puede tener métodos que 110 son abstract. Aunque 110 se puedan crear objetos de esta clase, sus sub-clases heredarán el método completamente a punto para ser utilizado. Como los métodos static no pueden ser redefinidos, un método abstract 110 puede ser static.

Redefinición de métodos heredados

Una clase puede redefinir (volver a definir) cualquiera de los métodos heredados de su super-clase que 110 sean final. El nuevo método sustituye al heredado para todos los efectos en la clase que lo ha redefinido. Las métodos de la super-clase que han sido redefinidos pueden ser todavía accedidos por medio de la palabra super desde los métodos de la clase derivada, aunque con este sistema sólo se puede subir un nivel en la jerarquía de clases. Los métodos redefinidos pueden ampliar los derechos de acceso de la super-clase (por ejemplo ser public. en vez de protected o package). pero nunca restringirlos. 

Los métodos de clase o static 110 pueden ser redefinidos en las clases derivadas.

La clase Object

Como ya se ha dicho, la clase Object es la raíz de toda la jerarquía de clases de Java. Todas las clases de Java derivan de Object. La clase Object tiene métodos interesantes para cualquier objeto que son heredados por cualquier clase. Entre ellos se pueden citar los siguientes:

1. Métodos que pueden ser redefinidos por el programador: 

clone () Crea un objeto a partir de otro objeto de la misma clase. El método original heredado de Object lanza una CloneNotSupportedException. Si se desea poder clonar una clase hay que implementar la interface Cloneable y redefinir el método 

clone (). Este método debe hacer una copia miembro a miembro del objeto original. No debería llamar al operador new ni a los constructores. 

equals() Indica si dos objetos son o no iguales. Devuelve trae si son iguales, tanto si son referencias al mismo objeto como si son objetos distintos con iguales valores de las variables miembro. 

toString() Devuelve un String que contiene una representación del objeto como cadena de caracteres, por ejemplo para imprimirlo o exportarlo. finalizeQ Este método ya se ha visto al hablar de los finalizadores.

2. Métodos que 110 pueden ser redefinidos (son métodos final):
getClass () Devuelve un objeto de la clase Class. al cual se le pueden aplicar métodos para determinar el nombre de la clase, su super-clase, las interfaces iniplementadas, etc. Se puede crear un objeto de la misma clase que otro sin saber de qué clase es.
notify (), notifyAllQ y wait() Son métodos relacionados con las threads

HERENCIA

Concepto de herencia 

Se puede construir una clase a partir de otra mediante el mecanismo de la herencia. Para indicar que una clase deriva de otra se utiliza la palabra extends, como por ejemplo: 

class CirculoGrafico extends Circulo {...} 

Cuando una clase deriva de otra, hereda todas sus variables y métodos. Estas funciones y variables miembro pueden ser redefinidas (overridden) en la clase derivada, que puede también definir o añadir nuevas variables y métodos. En cierta forma es como si la sub-clase (la clase derivada) "contuviera" un objeto de la super-clase: en realidad lo "amplia" con nuevas variables y métodos. 

Java permite múltiples niveles de herencia, pero 110 permite que una clase derive de varias (no es posible la herencia múltiple). Se pueden crear tantas clases derivadas de una misma clase como se quiera. 

Todas las clases de Java creadas por el programador tienen una super-clase. Cuando 110 se indica explícitamente una super-clase con la palabra extends. la clase deriva de java.lang.Object. que es la clase raíz de toda la jerarquía de clases de Java. Como consecuencia, todas las clases tienen algunos métodos que han heredado de Object.
La composición (el que una clase contenga un objeto de otra clase como variable miembro) se diferencia de la herencia en que incorpora los datos del objeto miembro, pero no sus métodos o interface (si dicha variable miembro se hace prívate).

Cómo fimciouau los packages

Con la sentencia import packname; se puede evitar tener que utilizar nombres muy largos, al mismo tiempo que se evitan los conflictos entre nombres. Si a pesar de todo hay conflicto entre nombres de clases. Java da un error y obliga a utilizar los nombres de las clases cualificados con el nombre del package. El importar un package no hace que se carguen todas las clases del package: sólo se cargarán las clases public que se vayan a utilizar. 

Al importar un package no se importan los sub-packages. Estos deben ser importados explícitamente, pues en realidad son packages distintos. Por ejemplo, al importar java.awt no se importa java.awt.event. Es posible guardar en jerarquías de directorios diferentes los ficheros *.class y *.java. con objeto por ejemplo de no mostrar la situación del código fuente. Los packages hacen referencia a los ficheros compilados *.class. 

En un programa de Java, una clase puede ser referida con su nombre completo (el nombre del package más el de la clase, separados por un punto). También se pueden referir con el nombre completo las variables y los métodos de las clases. Esto se puede hacer siempre de modo opcional, pero es incómodo y hace más difícil el reutilizar el código y portarlo a otras máquinas. 

La sentencia import permite abreviar los nombres de las clases, variables y métodos, evitando el tener que escribir continuamente el nombre del package importado. Se importan por defecto el package javaJang y el package actual o por defecto (las clases del directorio actual). Existen dos formas de utilizar import: para una clase y para todo un package:

import es.ceit.jgjalón.infor2.ordenar.QuickSort.class;

import es.ceit.jgjalon.infor2.ordenar.*;

que deberían estar en el directorio:

classpath\es\ceit\jgjalon\infor2\ordenar

PACKAGES

Qué es un package 

Un package es una agrupación de clases. En la API de Java 1.1 había 22 packages: en Java 1.2 hay 59 packages. lo que da una idea del "crecimiento'' experimentado por el lenguaje. Además, el usuario puede crear sus propios packages. 

Para que una clase pase a formar paite de un package llamado pkgName. hay que introducir en ella la sentencia:

package pkgName;

que debe ser la primera sentencia del fichero sin contar comentarios y líneas en blanco. Los nombres de los packages se suelen escribir con minúsculas, para distinguirlos de las clases, que empiezan por mayúscula. El nombre de irn package puede constar de varios nombres unidos por puntos (los propios packages de Java siguen esta norma, como por ejemplo java.awt.event). 

Todas las clases que forman parte de un package deben estar en el mismo directorio. Los nombres compuestos de los packages están relacionados con la jerarquía de directorios en que se guardan las clases. Es recomendable que los nombres de las clases de Java sean únicos en Internet. Es el nombre del package lo que permite obtener esta característica. 

Una forma de conseguirlo es incluir el nombre del dominio (quitando quizás el país), como por ejemplo en el package siguiente:

es.ceit.jgj alón.infor2.ordenar

Las clases de un package se almacenan en un directorio con el mismo nombre largo (path) que el package. Por ejemplo, la clase. es.ceit.j gj alón.infor2.ordenar.QuickSort.class debería estar en el directorio,

CLASS?ATH\es\ceit\jgjalon\infor2\ordenar\QuickSort.class

donde CLASSPATH es una variable de entorno del PC que establece la posición absoluta de los directorios en los que hay clases de Java (clases del sistema o de usuario), en este caso la posición del directorio es en los discos locales del ordenador. Los packages se utilizan con las finalidades siguientes: 

1. Para agrupar clases relacionadas. 
2. Para evitar conflictos de nombres (se recuerda que el dominio de nombres de Java es la Internet). En caso de conflicto de nombres entre clases importadas, el compilador obliga a cualificar en el código los nombres de dichas clases con el nombre del package. 
3. Para ayudar en el control de la accesibilidad de clases y miembros.

Finalizadores

Los finalizadores son métodos que vienen a completar la labor del garbage collector. Un finalizador es un método que se llama automáticamente cuando se va a destruir un objeto (antes de que la memoria sea liberada de modo automático por el sistema). Se utilizan para ciertas operaciones de terminación distintas de liberar memoria (por ejemplo: cenar ficheros, cerrar conexiones de red. liberar memoria reservada por funciones nativas, etc.). 

Hay que tener en cuenta que el garbage collector sólo libera la memoria reservada con new. Si por ejemplo se ha reservado memoria con funciones nativas en C (por ejemplo, utilizando la función mallocQ), esta memoria hay que liberarla explícitamente utilizando el método finalizeQ. Un finalizador es un método de objeto (no static). sin valor de retomo (void). sin argumentos y que siempre se llama finalizeQ. Los finalizadores se llaman de modo automático siempre que hayan sido definidos por el programador de la clase. Para realizar su tarea correctamente, un finalizador debería terminar siempre llamando al finalizador de su super-clase. 

Tampoco se puede saber el momento preciso en que los finalizadores van a ser llamados. En muchas ocasiones será conveniente que el programador realice esas operaciones de finalización de modo explícito mediante otros métodos que él mismo llame. 

El método System.runFinalizationf) "sugiere*' a la JVM que ejecute los finalizadores de los objetos pendientes (que han perdido la referencia). Parece ser que para que este método se ejecute, en Java 1.1 hay que llamar primero a gc() y luego a runFin alizationf).

Destrucción de objetos (liberación de memoria)

En Java no hay destructores como en C++. El sistema se ocupa automáticamente de liberar la memoria de los objetos que ya han perdido la referencia. esto es. objetos que ya no tienen ningún nombre que permita acceder a ellos, por ejemplo por haber llegado al final del bloque en el que habían sido definidos, porque a la referencia se le ha asignado el valor nuil o porque a la referencia se le ha asignado la dirección de otro objeto. A esta característica de Java se le llama garbage collection (recogida de basura). En Java es normal que varias variables de tipo referencia apunten al mismo objeto. Java lleva internamente un contador de cuántas referencias hay sobre cada objeto. El objeto podrá ser borrado cuando el número de referencias sea cero. Como ya se ha dicho, una forma de hacer que un objeto quede sin referencia es cambiar ésta a nuil, haciendo por ejemplo:

ObjetoRef = nuil;

En Java no se sabe exactamente cuándo se va a activar el garbage collector. Si no falta memoria es posible que no se llegue a activar en ningún momento. No es pues conveniente confiar en él para la realización de otras tareas más críticas. Se puede llamar explícitamente al garbage collector con el método System.gc(). aunque esto es considerado por el sistema sólo como una "sugerencia" a la JVM.

Resumen del proceso de creación de un objeto

El proceso de creación de objetos de una clase es el siguiente: 

1. Al crear el primer objeto de la clase o al utilizar el primer método o variable static se localiza la clase y se carga en memoria. 
2. Se ejecutan los inicializadores static (sólo una vez). 
3. Cada vez que se quiere crear un nuevo objew. 

• se comienza reservando la memoria necesaria 
• se da valor por defecto a las variables miembro de los tipos primitivos 
• se ejecutan los inicializadores de objeto 
• se ejecutan los constructores

MÉTODOS (FUNCIONES MIEMBRO) - V

Inicializadores 

Por motivos que se verán más adelante. Java todavía dispone de una tercera línea de actuación para evitar que haya variables sin inicializar correctamente. Son los inicializadores. que pueden ser static (para la clase) o de objeto. 3.5.6.1 Inicializadores static Un inicializador static es un algo parecido a un método (un bloque {...} de código, sin nombre y sin argumentos, precedido por la palabra static) que se llama automáticamente al crear la clase (al utilizarla por primera vez). 

También se diferencia del constructor en que no es llamado para cada objeto, sino una sola vez para toda la clase. Los tipos primitivos pueden inicializarse directamente con asignaciones en la clase o en el constructor, pero para inicializar objetos o elementos más complicados es bueno utilizar un inicializador (un bloque de código {...}). ya que permite gestionar excepciones3 con try...catch. Los inicializadores static se crean dentro de la clase, como métodos sin nombre, sin argumentos y sin valor de retomo, con tan sólo la palabra static y el código entre llaves {...}. 

En una clase pueden definirse varios inicializadores static. que se llamarán en el orden en que han sido definidos. 

Los inicializadores static se pueden utilizar para dar valor a las variables static. Además se suelen utilizar para llamar a métodos nativos, esto es. a métodos escritos por ejemplo en C/C++ (llamando a los métodos System.load() o System.loadLibrary(). que leen las librerías nativas). Por ejemplo:

static{

System.loadLibrary("MyNativeLibrary");

}

Inicializadores de objeto

A partir de Java 1.1 existen también inicializadores de objeto, que no llevan la palabra static. Se utilizan para las clases anónimas, que por no tener nombre no pueden tener constructor. En este caso, los inicializadores de objeto se llaman cada vez que se crea un objeto de la clase anónima.

MÉTODOS (FUNCIONES MIEMBRO) - IV

Constructores 

Un punto clave de la Programación Orientada Objetos es el evitar información incorrecta por no haber sido correctamente inicializadas las variables. Java no permite que haya variables miembro que no estén inicializadas2. Ya se ha dicho que Java inicializa siempre con valores por defecto las variables miembro de clases y objetos. 

El segundo paso en la inicialización conecta de objetos es el uso de constructores. Un constructor es un método que se llama automáticamente cada vez que se crea un objeto de una clase. La principal misión del constructor es reservar memoria e inicializar las variables miembro de la clase. 

Los constructores no tienen valor de retomo (ni siquiera void) y su nombre es el mismo que el de la clase. Su argumento implícito es el objeto que se está creando. De ordinario una clase tiene varios constructores. que se diferencian por el tipo y número de sus argumentos (son un ejemplo típico de métodos sobrecargados). Se llama constructor por defecto al constructor que no tiene argumentos. 

El programador debe proporcionar en el código valores iniciales adecuados para todas las variables miembro. Un constructor de una clase puede llamar a otro constructor previamente definido en la misma clase por medio de la palabra this. 

En este contexto, la palabra this sólo puede aparecer en la primera sentencia de un constructor. El constructor de una sub-clase puede llamar al constructor de su super-clase por medio de la palabra super. seguida de los argumentos apropiados entre paréntesis. De esta forma, un constructor sólo tiene que inicializar por sí mismo las variables no heredadas. 

 Al igual que los demás métodos de una clase, los constructores pueden tener también los modificadores de acceso public. prívate, protected y package. Si un constructor es prívate. ninguna otra clase puede crear un objeto de esa clase. En este caso, puede haber métodos public y static (factory methods) que llamen al constructor y devuelvan un objeto de esa clase. Dentro de una clase, los constructores sólo pueden ser llamados por otros constructores o por métodos static. No pueden ser llamados por los métodos de objeto de la clase.

MÉTODOS (FUNCIONES MIEMBRO) - III

Métodos de clase (static) 

Análogamente, puede también haber métodos que no actúen sobre objetos concretos a través del operador punto. A estos métodos se les llama métodos de clase o static. Los métodos de clase pueden recibir objetos de su clase como argumentos explícitos, pero no tienen argumento implícito ni pueden utilizar la referencia this. Un ejemplo típico de métodos static son los métodos matemáticos de la clase java.lang.Math (sinQ. cos(). exp(). pow(). etc.). De ordinario el argumento de estos métodos será de un tipo primitivo y se le pasará como argumento explícito. Estos métodos no tienen sentido como métodos de objeto. 

Los métodos y variables de clase se crean anteponiendo la palabra static. Para llamarlos se suele utilizar el nombre de la clase, en vez del nombre de un objeto de la clase (por ejemplo, Math.sin(ang). para calcular el seno de un ángulo). Los métodos y las variables de clase son lo más parecido que Java tiene a las funciones y variables globales de C/C++ o Visual Basic.

MÉTODOS (FUNCIONES MIEMBRO) - II

Métodos sobrecargados (overloaded) 

Al igual que C++. Java permite métodos sobrecargados (overloaded). es decir, métodos distintos que tienen el mismo nombre, pero que se diferencian por el número y/o tipo de los argumentos. El ejemplo de la clase Circulo del Apartado 3.2 presenta dos casos de métodos sobrecargados: los cuatro constructores y los dos métodos llamados elMayorf). A la hora de llamar a un método sobrecargado. Java sigue unas reglas para determinar el método concreto que debe llamar: 

1. Si existe el método cuyos argumentos se ajustan exactamente al tipo de los argumentos de la llamada (argumentos acftiales). se llama ese método. 
2. Si no existe un método que se ajuste exactamente, se intenta promover los argumentos actuales al tipo inmediatamente superior (por ejemplo char a int. int a /ong.float a double, etc.) y se llama el método correspondiente. 
3. Si sólo existen métodos con argumentos de un tipo más restringido (por ejemplo, int en vez de long). el programador debe hacer un cast explícito en la llamada, responsabilizándose de esta manera de lo que pueda ocurrir. 
4. El valor de retomo no influye en la elección del método sobrecargado. En realidad es imposible saber desde el propio método lo que se va a hacer con él. No es posible crear dos métodos sobrecargados, es decir con el mismo nombre, que sólo difieran en el valor de retomo. 

Diferente de la sobrecarga de métodos es la redefinición. Una clase puede redefinir (override) un método heredado de una superclase. Redefinir un método es dar una nueva definición. En este caso el método debe tener exactamente los mismos argumentos en tipo y número que el método redefinido. Este tema se verá de nuevo al hablar de la herencia.

MÉTODOS (FUNCIONES MIEMBRO) - I

Métodos de objeto 

Los métodos son funciones definidas dentro de una clase. Salvo los métodos static o de clase, se aplican siempre a un objeto de la clase por medio del operador punto (.). Dicho objeto es su argumento implícito. Los métodos pueden además tener otros argumentos explícitos que van entre paréntesis, a continuación del nombre del método. La primera línea de la definición de un método se llama declaración o header: el código comprendido entre las llaves {...} es el cuerpo o body del método. Considérese el siguiente método tomado de la clase Circulo:

public Circulo elMayor(Circulo c)  { // header y comienzo del método

if (this.r>=c.r)         // body

return this;             // body

else                     // body

return c;                // body

}                      // final del método

El header consta del cualificador de acceso {public. en este caso), del tipo del valor de retomo {Circulo en este ejemplo, void si no tiene), del nombre de la función y de una lista de argumentos explícitos entre paréntesis, separados por comas. Si no hay argumentos explícitos se dejan los paréntesis vacíos. Los métodos tienen visibilidad directa de las variables miembro del objeto que es su argumento implícito. es decir, pueden acceder a ellas sin cualificarlas con un nombre de objeto y el operador punto (.). De todas formas, también se puede acceder a ellas mediante la referencia this, de modo discrecional (como en el ejemplo anterior con this.r) o si alguna variable local o argumento las oculta. 

El valor de retorno puede ser mi valor de un tipo primitivo o una referencia. En cualquier caso no puede haber más que un único valor de retomo (que puede ser un objeto o un array). Se puede devolver también una referencia a un objeto por medio de un nombre de interface. El objeto devuelto debe pertenecer a una clase que implemente esa interface. Se puede devolver como valor de retomo un objeto de la misma clase que el método o de una sub-clase. pero nunca de una super-clase.

Los métodos pueden definir variables locales. Su visibilidad llega desde la definición al final del bloque en el que han sido definidas. No hace falta inicializar las variables locales en el punto en que se definen, pero el compilador no permite utilizarlas sin haberles dado un valor. 

A diferencia de las variables miembro, las variables locales no se inicializan por defecto. Si en el header del método se incluye la palabra native (Ej: public native void miMetodo ();) no hay que incluir el código o implementación del método. Este código deberá estar en una librería dinámica (Dynamic Link Library o DLL). Estas librerías son ficheros de funciones compiladas normalmente en lenguajes distintos de Java (C. C++. Fortran, etc.). Es la forma de poder utilizar conjuntamente funciones realizadas en otros lenguajes desde código escrito en Java. Este tema queda fuera del caracter fundamentalmente introductorio de este manual. Un método también puede declararse como synchronized (Ej: public synchronized double miMetodoSynch () {...}). Estos métodos tienen la particularidad de que sobre un objeto no pueden ejecutarse simultáneamente dos métodos que estén sincronizados

VARIABLES FINALES

Una variable de un tipo primitivo declarada como final no puede cambiar su valor a lo largo de la ejecución del programa.

Puede ser considerada como una constante. y equivale a la palabra const de C/C++. Java permite separar la definición de la inicialización de una variable final. La inicialización puede hacerse más tarde, en tiempo de ejecución, llamando a métodos o en función de otros datos. La variable final así definida es constante (no puede cambiar), pero no tiene por qué tener el mismo valor en todas las ejecuciones del programa, pues depende de cómo haya sido inicializada. 

Además de las variables miembro, también las variables locales y los propios argumentos de un método pueden ser declarados final. Declarar como final un objeto miembro de una clase hace constante la referencia, pero no el propio objeto, que puede ser modificado a través de otra referencia. En Java no es posible hacer que un objeto sea constante.

Variables miembro de clase (static)

Una clase puede tener variables propias de la clase y no de cada objeto. A estas variables se les llama variables de clase o variables static. Las variables static se suelen utilizar para definir constantes comunes para todos los objetos de la clase (por ejemplo PI en la clase Circulo) o variables que sólo tienen sentido para toda la clase (por ejemplo, un contador de objetos creados como numCirculos en la clase Circulo). 

Las variables de clase son lo más parecido que Java tiene a las variables globales de C/C++. Las variables de clase se crean anteponiendo la palabra static a su declaración. Para llamarlas se suele utilizar el nombre de la clase (no es imprescindible, pues se puede utilizar también el nombre de cualquier objeto), porque de esta forma su sentido queda más claro. Por ejemplo, Circulo.numCirculos es una variable de clase que cuenta el número de círculos creados. Si no se les da valor en la declaración, las variables miembro static se inicializan con los valores por defecto para los tipos primitivos (false para boolean. el carácter nulo para char y cero para los tipos numéricos), y con nuil si es una referencia. 

Las variables miembro static se crean en el momento en que pueden ser necesarias: cuando se va a crear el primer objeto de la clase, en cuanto se llama a un método static o en cuanto se utiliza una variable static de dicha clase. Lo importante es que las variables miembro static se inicializan siempre antes que cualquier objeto de la clase.

VARIABLES MIEMBRO - II

Las variables miembro del argumento implícito se acceden directamente o precedidas por la palabra this y el operador punto. Las variables miembro pueden ir precedidas en su declaración por uno de los modificadores de acceso: public. prívate, protected y package (que es el valor por defecto y puede omitirse). Junto con los modificadores de acceso de la clase {public y package). determinan qué clases y métodos van a tener permiso para utilizar la clase y sus métodos y variables miembro. 

En el Apartado 3.11, en la página 60. se especifican con detalle las consecuencias de estos modificadores de acceso. Existen otros dos modificadores (no de acceso) para las variables miembro: 

1. transient: indica que esta variable miembro no forma paite de la persistencia (capacidad de los objetos de mantener su valor cuando termina la ejecución de un programa) de un objeto y por tanto no debe ser señalizada (convertida en flujo de caracteres para poder ser almacenada en disco o en una base de datos) con el resto del objeto. 
2. rolatile: indica que esta variable puede ser utilizada por distintas threads sincronizadas (ver Apartado 6.3. en la página 131) y que el compilador no debe realizar optimizaciones con esta variable. 

Al nivel de estos apuntes, los modificadores transient y rolatile no serán utilizados.

VARIABLES MIEMBRO - I

A diferencia de la programación algorítmica clásica, que estaba centrada en las funciones, la programación orientada a objetos está centrada en los datos. Una clase está constituida por unos datos y unos métodos que operan sobre esos datos. 3.3.1 Variables miembro de objeto Cada objeto, es decir cada ejemplar concreto de la clase, tiene su propia copia de las variables miembro. Las variables miembro de una clase (también llamadas campos) pueden ser de tipos primitivos (boolecm. int, long, double, ...) o referencias a objetos de otra clase (composición). 

Un aspecto muy importante del conecto funcionamiento de los programas es que 110 haya datos sin inicializar. Por eso las variables miembro de tipos primitivos se inicializan siempre de modo automático, incluso antes de llamar al constructor (false para boolecm, el carácter nulo para citar y cero para los tipos numéricos). De todas formas, lo más adecuado es inicializarlas también en el constructor. Las variables miembro pueden también inicializarse explícitamente en la declaración, como las variables locales, por medio de constantes o llamadas a métodos (esta inicialización no está permitida en C++). Por ejemplo,

long nDatos = 100;

Las variables miembro se inicializan en el mismo orden en que aparecen en el código de la clase. Esto es importante porque unas variables pueden apoyarse en otras previamente definidas. Cada objeto que se crea de una clase tiene su propia copia de las variables miembro. Por ejemplo, cada objeto de la clase Circulo tiene sus propias coordenadas del centro .y e y, y su propio valor del radio r.
 Los métodos de objeto se aplican a un objeto concreto poniendo el nombre del objeto y luego el nombre del método, separados por un punto. A este objeto se le llama argumento implícito. Por ejemplo, para calcular el área de un objeto de la clase Circulo llamado el se escribirá: cl.areaQ;.

EJEMPLO DE DEFINICIÓN DE UNA CLASE

A continuación se reproduce como ejemplo la clase Circulo, explicada en el Apartado 1.3.4. 

// fichero Circulo.java

public class Circulo extends Geometria {
static int numCirculos = 0/

public static final double PI=3.14159265358979323846;
public double x, y, r;

public Circulo(double x, double y, double r) {
this.x=x; this.y=y; this.r=r;
numCirculos++;

}

public Circulo(double r) { this(0.0, 0.0, r) ; }
public Circulo(Circulo c) { this(c.x, c.y, c.r); }
public Circulo() { this(0.0, 0.0, 1.0); }

public double perimetroO { return 2.0 * PI * r; }
public double areaO { return PI * r * r; }

// método de objeto para comparar circuios
public Circulo elMayor(Circulo c) {

if (this.r>=c.r) return this; else return c;

}

// método de clase para comparar circuios
public static Circulo elMayor(Circulo c, Circulo d) {
if (c.r>=d.r) return c; else return d;

}

} // fin de la clase Circulo

En este ejemplo se ve cómo se definen las variables miembro y los métodos (cuyos nombres se han resaltado en negrita) dentro de la clase. Dichas variables y métodos pueden ser de objeto o de clase (static). Se puede ver también cómo el nombre del fichero coincide con el de la clase public con la extensión *.java.

Concepto de Interface

Una interface es un conjunto de declaraciones de funciones. Si tina clase implementa (implements) una interface. debe definir todas las funciones especificadas por la interface. Las interfaces pueden definir también variables finales (constantes). 

Una clase puede implementar más de una interface. representando una alternativa a la herencia múltiple. En algunos aspectos los nombres de las interfaces pueden utilizarse en lugar de las clases. 

Por ejemplo, las interfaces sirven para definir referencias a cualquier objeto de cualquiera de las clases que implementan esa interface. 

Con ese nombre o referencia, sin embargo, sólo se pueden utilizar los métodos de la interface. Éste es un aspecto importante del polimorfismo. 

Una interface puede derivar de otra o incluso de varias interfaces. en cuyo caso incorpora las declaraciones de todos los métodos de las interfaces de las que deriva (a diferencia de las clases, las interfaces de Java sí tienen herencia múltiple).

CONCEPTOS BÁSICOS

Concepto de Clase 

Una clase es una agrupación de datos (variables o campos) y de funciones (métodos) que operan sobre esos datos. La definición de una clase se realiza en la siguiente forma:

[public] class Classname {

// definición de| variables y métodos

}

donde la palabra public es opcional: si 110 se pone, la clase tiene la visibilidad por defecto, esto es. sólo es visible para las demás clases delpackage. Todos los métodos y variables deben ser definidos dentro del bloque {...} de la clase. U11 objeto (en inglés, instance) es un ejemplar concreto de una clase. Las clases son como tipos de variables, mientras que los objetos son como variables concretas de un tipo determinado.

Classname unObjeto;

Classname otroObjeto;

CONCEPTOS BÁSICOS - características importantes

A continuación se enumeran algunas características importantes de las clases: 

1. Todas las variables y funciones de Java deben pertenecer a una clase. No hay variables y funciones globales.
2. Si una clase deriva de otra {extencls). hereda todas sus variables y métodos. 
3. Java tiene una jerarquía de clases estándar de la que pueden derivar las clases que crean los usuarios. 
4. Una clase sólo puede heredar de una única clase (en Java no hay herencia múltiple). Si al definir una clase 110 se especifica de qué clase deriva, por defecto la clase deriva de Object. La clase Object es la base de toda la jerarquía de clases de Java. 
5. E11 un fichero se pueden definir varias clases, pero en un fichero 110 puede haber más que una clase public. Este fichero se debe llamar como la clase public que contiene con extensión *.java. Con algunas excepciones, lo habitual es escribir una sola clase por fichero. 
6. Si una clase contenida en un fichero 110 es public. 110 es necesario que el fichero se llame como la clase.
7. Los métodos de una clase pueden referirse de modo global al objeto de esa clase al que se aplican por medio de la referencia this. 
8. Las clases se pueden agrupar en packages. introduciendo una línea al comienzo del fichero {package packageName;). Esta agrupación en packages está relacionada con la jerarquía de directorios y ficheros en la que se guardan las clases.

CLASES EN JAVA

Las clases son el centro de la Programación Orientada a Objetos (OOP - Object Oriented Programming). Algunos de los conceptos más importantes de la POO son los siguientes: 

1. Encapsulación. Las clases pueden ser declaradas como públicas (public) y como package (accesibles sólo para otras clases del package). Las variables miembro y los métodos pueden ser public. prívate. protected y package. De esta forma se puede controlar el acceso y evitar un uso inadecuado. 
2. Herencia. Una clase puede derivar de otra (extends), y en ese caso hereda todas sus variables y métodos. Una clase derivada puede añadir nuevas variables y métodos y/o redefinir las variables y métodos heredados. 
3. Polimorfismo. Los objetos de distintas clases pertenecientes a una misma jerarquía o que implementan una misma interface pueden tratarse de una forma general e individualizada, al mismo tiempo. Esto, como se ha visto en el ejemplo del Capítulo 1. facilita la programación y el mantenimiento del código. 

En este Capítulo se presentan las clases y las interfaces tal como están implementadas en el lenguaje Java.