(c)BIT - Ud.3 Curso Java: unidades didacticas

	Curso JAVA Unidad 3: "Clases, objetos, herencia y polimorfismo"
	www.bit.es - Calendario de cursos - Solicitud de información

Curso Java
Curso Analista Programador entorno Java

Objetivos de la Unidad:

Conocer las nociones de objeto y clase
Conocer el mecanismo de sobrecarga
Orientación a objetos y papel del constructor
Asimilar los mecanismos de la herencia y el polimorfismo
Conocer el concepto de interface
Conocer el funcionamiento de los ámbitos y paquetes
Inner classes

Nota: El material que viene a continuación debe servir de repaso o referencia para quien conozca C++ y programación orientada a objetos y entenderlo podría servir como objetivo para quien no tenga estos conocimientos.

Clases

Una clase es la definición de un objeto
Una vez definida la clase podremos crear tantos objetos como queramos de esta clase
Un objeto ocupa un lugar en memoria. Una clase no ocupa nada ya que es una definición que utiliza el compilador para crear los objetos.
Las clases contienen miembros los cuales pueden ser atributos (datos) o métodos (funciones)

public class Circulo
{
// atributos (o también variable miembro)

    int x;
    int y;
    int r;

    // métodos

    public double area()
    {
        return Math.PI * Math.pow(r, 2);
    }
}

En la siguiente linea de codigo se declara una referncia de nombre "c" a un objeto de la clase Circulo, se crea un objeto de clase Circulo y se asigna a dicha referencia:

Circulo c = new Circulo;

Dentro de las clases cada miembro pertenece a un ámbito concreto en función de la accesibilidad que queramos darle desde fuera de la clase a cada miembro.

Tipos

Definición de tipo abstracto de datos (TAD): "Un tipo de datos es un conjunto de valores sobre los cuales podemos aplicar un conjunto dado de operaciones las cuales cumplirán ciertas propiedades":
Los tipos en Java se definen mediante clases.
A menudo se utiliza indistintamente "tal objeto es de tal clase" y "tal objeto es de tal tipo".
La noción de tipo es más amplia que la de clase. Un mismo tipo puede implementarse con clases construidas distintamente por dentro (algoritmos más o menos eficientes).
Desde fuera, el programador usuario de la clase no debe verse afectado por la implementación específica. De ahí el término abstracto (caja negra)

Ámbitos

Las palabras reservadas para los ámbitos son: public, private y protected.
Si public se aplica a una clases significa que la clase es visible fuera del paquete.(desde cualquier método de cuaquier clase el compilador es capaz de conocer el tipo)
Sólo puede haber una clase public dentro de un .java.
public, private y protected se pueden aplicar a los miembros de una clase:
public significa que es accesible desde cualquier sitio (paquete).
private significa que es accesible sólo desde la propia clase.
protected significa que es accesible desde el paquete y además por las subclases sea en el paquete que sea.
private protected significa que es accesible desde las subclases sea en el paquete que sea.
Si no se especifica nada se dice que el ámbito es "friendly" lo que significa que hay accesibilidad desde dentro del paquete.
Se puede dar un acceso selectivo también a los constructores, retringiendo los posibles modos de construcción de los objetos según los distintos ámbitos.

Sobrecarga de métodos

Pueden haber varios métodos con el mismo nombre.
Regla práctica: El nombre completo de un método se compone de:

<Nom. clase>.<Nom. método>@<Tipo parámetro 1>@<Tipo parámetro 2>...

El nombre completo de area es:

Circulo.area@void

Por lo tanto podría coexistir perfectamente con un método que recibiera un int como parámetro (desde el punto de vista Java son métodos distintos)

Circulo.area@int

Orientación a objetos

Si se trabajara de manera mostrada en el punto anterior, en un paso posterior del programa habría que inicializar los atributos (variables miembro) del objeto.
Precisamente este asunto es una de las novedades metodológicas de la programación orientada a objetos: La separación entre declaración e inicialización de variables ha supuesto desde siempre una causa de errores fundamantalmente debido al olvido en las inicializaciones.
Ahora se pretende que se pueda garantizar en lo posible que si un objeto existe, éste tiene sus variables miembro con valores consistentes. La operación de "construcción de un objeto" incluye declaración e inicialización.
Para ello se utilizan unos métodos denominados constructores que tienen esta función: Ser un paso obligado en la creación de los objetos.
Al ser un método en él se deberá escribir el código necesario para asegurar la validez de los datos de inicialización y todas las comprobaciones pertinentes.
Los constructores son métodos que tienen el mismo nombre que la clase.
Pueden haber varios constructores ya que pueden sobrecargarse. Y no solamente pueden, sino que es muy deseable (La sobrecarga de métodos está disponible en los lenguajes orientados a objetos precisamente para permitir la sobrecarga de constructores)
Se tendrán tantos constructores como vías quieran contemplarse de inicialiar los objetos.
Desde dentro de un método se puede obtener una referencia al objeto específico sobre el que se está ejecutando dicho método mediante la palabra reservadathis.
this puede servir para discernir a qué nivel nos estamos refiriendo. Suponganos que un método recibe un parámetro int x y que la clase tiene una variable miembro int x. ¿Cómo hacemos referencia a esta variable miembro? La respuesta esthis.x

Ejemplos de constructores

Por ejemplo, para la clase Circulo podría ser conveniente definir dos constructores: Uno para crear un círculo a partir de dos coordenadas x e y para el centro y del radio.
El segundo constructor serviría para crear un Circulo a partir de otro Circulo (Concepto de constructor copia).
Veamos ambos casos:

public Circulo(int x, int y, int r)
{
    this.x = x;
    this.y = y;
    this.r = r;
}

public Circulo(Circulo c)
{
    this.x = c.x;
    this.y = c.y;
    this.r = c.r;
}

Herencia

Una clase puede definirse a partir de otra. Será una subclase.
Una subclase es una clase más especializada que la clase base.
Una subclase se denomina clase derivada de una clase base.
Una clase base puede tener varias clases derivadas y así sucesivamente. Se produce una estructura de árbol que se denomina Jerarquía de Clases.
La subclasificación es un modo de estructurar los conocimientos.
Sobre este tema es una muy buena referencia el libro "Análisis y Diseño orientado a objetos" de Grady Booch (Ed. Addison Wesley Iberoamericana)
Desde el punto de vista de la programación la herencia es interesante para reutilizar el código existente.

Motivaciones y prestaciones de la herencia

Podemos crear una clase derivada a partir de una clase de la cual no tengamos su código fuente sino el .class compilado. Se utiliza la palabra reservada extends para indicarla (ver ejemplo).
Para ello deben darse la circunstancia de que tengamos una documentación mínima de sus miembros públicos (cómo usarlos: nombres de métodos, parámetros y sus significados).
Sólo conociendo una parte del comportamiento de una clase puede interesarnos derivar otra más especializada y aprovecharnos de utilizar aquellos aspectos que nos interesan y/o personalizar/añadir los que convengan.
La subclase dispone de todos los miembros de la clase base más los propios de ella misma. Se dice que hereda los miembros de la clase base.
Cuando se dicen que los constructores no se heredan significa que la clase derivada no dispone de un método con el nombre de la clase base (el constructor de la clase base)
Ello no significa que no se pueda aprovechar el constructor de la clase base, especialmente cuando no se tiene el código fuente ni se sabe quién lo ha desarrollado.
Para resolver este aspecto se dispone de un método denominado super hace referencia a un costructor de la clase base.
Por tanto, si la primera instrucción de un costructor de clase derivada invoca a super() en función de los tipos de los parámetros pasados llama al costructor correspondiente y construye la parte de clase base del objeto. El resto del cosntructor se encargará de inicializar los atributos específicos de la clase derivada.

Aspectos prácticos de la herencia

¿Qué ocurre si una clase derivada tiene miembros con el mismo nombre que otros miembros de la clase base? La definición más local tapa a la más global. Es decir, el miembro de la clase derivada tapa al de la clase base con el mismo nombre.
Si el miembro es un método se produce lo que se denomina sobreescritura de método.
Ejemplo:

        ObjGraf
        |
        +----- Rectangulo
        +----- Circulo

La jerarquía de clases de Java (estándar) puede consultarse en http://www.chez.com/classes.
La clase ObjGraf corresponde a un objeto gráfico genérico del cual todavía no se sabe su forma específica.
Rectangulo es una subclase de ObjGraf. Por tanto un objeto de la clase Rectangulo también pertenece a la clase ObjGraf.
Al programar esto se traduce en que no habrá problemas de conversión de tipo al asignar un objeto de la clase Rectangulo a una variable de la clase ObjGraf, puesto que son de la misma clase.
No ocurre así al revés. En principio no se puede asignar un objeto de la clase ObjGraf a una variable de la clase Rectangulo, puesto que habrá atributos que quedarán indefinidos pudiéndose romper la consistencia de datos interna del objeto.
Sólo se podrá hacer si el programador fuerza una conversión explícita (casting).
A diferencia que en C++ en Java no hay destructores. Java tiene un sistema propio de eliminación de memoria desreferenciada denominado Garbage Collector que se describirá más adelante.

Polimorfismo

Cuando se llama a un método el código generado por el compilador consulta una tabla oculta de punteros a funciones que dispone cada clase. La dirección de la función llamada no se asigna en tiempo de compilación como ocurre con el linkaje estático del C sino que se obtiene la dirección de la función llamada justo en el momento antes de ejecutarse.
El polimorfismo consiste en poder definir métodos con la misma signatura en diferentes niveles de la jerarquía de clases y que durante la ejecución el programa sepa discernir a qué método llamar en cada caso.
Por ejemplo, de los objetos gráficos se debe poder clacular su área. Para ello se definirá un método area() en cada clase mecionada: ObjGraf, Rectangulo y Circulo.
Es claro que el código de la rutina area() de un Rectangulo y un Circulo es distinto.
Sin embargo tanto uno como el otro dispondrán de un método con el mismo nombre y signatura: area().
Supongamos que tenemos un array de referencias a objetos ObjGraf (que en realidad cada uno de ellos será Rectangulo y/o Circulo).
El polimorfismo nos permite recorrer el array y llamar para cada objeto el método area() y que en cada caso el programa generado por el compilador sepa llamar en cada caso al area que le corresponda, sea el de Rectangulo o el de Circulo.

Clases abstractas

Hay clases (como la ObjGraf) que no pueden crear objetos (a los objetos también se les denomina instancias de una clase).
No es imaginable un objeto que sólo sea ObjGraf.
Entonces, ¿Para qué sirve en este caso la clase ObjGraf? La respuesta es para agrupar a las subclases y poder tratar a todos los objetos de subclases como objetos de una misma clase.
En definitiva se trata de explotar el polimorfismo.
En Java se puede manifestar este hecho mediante el modificador abstract en la definición de una clase.

Ejemplo completo de polimorfismo

// Ejemplo de herencia y polimorfismo en Java
public class Aplicacion
{
public static void main(String args[])
{
// Podemos crear un array de ObjGrafs (en este caso de dos elementos):
ObjGraf z[] = new ObjGraf[2];

z[0] = new Rectangulo(1, 5, 3, 4);
z[1] = new Circulo(1, 5, 10);

// Recorrido del array e impresión de la area para cada uno de ellos
for (int i = 0; i < z.length; i++)
{
double sup = z[i].area();
System.out.println("Area de z[" + i + "]: " + sup);
}

}
}

//
//
// ObjGraf.java
//
//
// ObjGraf representa al Rectangulo, al Circulo y al resto en general.
// Se hace responsable de las características comunes atodos ellos como la x y la y,
// tanto en lo referente a los atributos como a los métodos.
// Desde un método de otra clase se puede acceder a la x y la y mediante los métodos
// set y get correspondientes, los cuales son públicos.
// El acceso directo a x a y desde sus clases hijas (Rectangulo y Circulo) no está
// permitido por private. Para abrir la posibilidad de acceso a las clases hijas pero
// no al resto de las clases existe el nivel protected.

public abstract class ObjGraf
{
private int x; // coordenada x del centro
private int y; // coordenada y del centro

// metodo abstracto area
abstract public double area();

// Constructor por defecto: El que da los valores por defecto
// Es condición obligatoria para que la clase defina un "Java Bean"
public ObjGraf()
{
setX(0);
setY(0);
}

public ObjGraf(int xInicial, int yInicial)
{
setX(xInicial);
setY(yInicial);
}

// set y get de la x
public void setX(int valor)
{
x = valor;
}

public int getX()
{
return x;
}

// set y get de la y
public void setY(int valor)
{
y = valor;
}

public int getY()
{
return y;
}
}

//
//
// Rectangulo.java
//
//

public class Rectangulo extends ObjGraf
{
// datos de la clase o atributos
private int b; // base
private int h; // altura

// Constructor por defecto: El que da los valores por defecto
// Es condición obligatoria para que la clase defina un "Java Bean"
public Rectangulo()
{
// la ausencia de una llamada a super() implica implícitamente que ésta se realiza.
setBase(10);
setAltura(5);
}

// Los constructores son en general public}
public Rectangulo(int xInicial, int yInicial, int baseInicial, int alturaInicial)
{
// este constructor inicializa los atributos validando

super(xInicial, yInicial);
setBase(baseInicial);
setAltura(alturaInicial);
}

// método área
public double area()
{
return getBase() * getAltura();
}

// set y get de la altura
public void setAltura(int valor)
{
if (valor > 0)
{
h = valor;
}
else
{
h = 0;
}
}

public int getAltura()
{
return h;
}

// set y get de la base
public void setBase(int valor)
{
if (valor > 0)
{
b = valor;
}
else
{
b = 0;
}
}

public int getBase()
{
return b;
}

}

//
//
// Circulo.java
//
//

public class Circulo extends ObjGraf
{
// datos de la clase o atributos
private int r; // radio

// Constructor por defecto: El que da los valores por defecto
// Es condición obligatoria para que la clase defina un "Java Bean"
public Circulo()
{
// la ausencia de una llamada a super() implica implícitamente que ésta se realiza.
setRadio(10);
}

// Los constructores son en general public
public Circulo(int xInicial, int yInicial, int radioInicial)
{
// este constructor inicializa los atributos validando

super(xInicial, yInicial);
setRadio(radioInicial);
}

// método área
public double area()
{
return 3.1416 * getRadio() * getRadio();
}

// set y get de la altura
public void setRadio(int valor)
{
if (valor > 0)
{
r = valor;
}
else
{
r = 0;
}
}

public int getRadio()
{
return r;
}
}

Interfaces: Cuando lo que se heredan son compromisos

Java dispone de dos mecanismos de herencia
El descrito en el punto anterior corresponde a la herencia pesada, que es la misma del C++.
Java no permite herencia múltiple conextends. Es decir, una clase derivada no puede tener más de una clase base.
El segundo mecanismo es el que permiten los interfaces.
Un interface es muy parecido a una clase sólo que sólo puede tener signaturas (declaraciones) de métodos (sin código), tódos de ámbito público. Además las variables sólo pueden ser constantes, es decir final (en C serían #define o en C++ variables const oenum)
La herencia desde interfaces se expresa con la palabra implements en lugar de extends.
Con interfaces sí puede haber herencia múltiple.
La finalidad de los interfaces es posibilitar el polimorfismo.
Los interfaces pueden actuar como tipos, permitiendo castings y referencias a objetos tipo interface.
Los interfaces son como contratos. Al implementar una clase el interface "I" además de ser de su propia clase también podrá ser considerado del tipo "I" (la noción de tipo engloba el de clase e interface).
Con la herencia clásica (extends) se hereda comportamiento, es decir código con lo que se obtiene un ahorro de trabajo.
Con las interfaces se heredan compromisos para poder ser del tipo "I".
Con la herencia normal se heredan bienes, con los interfaces se heredan deudas
En C++ como no hay interfaces se utilizan clases abstractas para hacer lo mismo, pero todo queda más confuso. En Java se ha querido diferenciarlos por claridad.
Ejemplo ilustrativo del uso de interfaces:
- Supongamos un entorno de diseño gráfico al estilo "flowchart" que nosotros adquirimos.
- Dicho entorno es abierto y posibilita que nuestros objetos puedan integrarse y formar parte de su librería de tipos de objetos gráficos.
- Para ello nos suministran unos interfaces diciendonos que: "Si quieres que tus objetos sean manipulables por nuestro programa debes hacer que tus clases tienen que implementar tales interfaces además de dónde deriven o qué implementen".
- Por ejemplo: rota(double grados), zoom(double factorEscala), etc.
- Con ello ¿qué se logra? Se logra que no sea posible descuidarse alguno de los métodos exigidos.
- Por ejemplo, si a través del menú de dicho entorno hay una opción de rotar(x grados) lo que nos están diciendo es que el entorno llamará al método rota(x grados). Si nuestro objeto pertenece a una clase que no implementa este método el programa fallará en tiempo de ejecución.
- Con los interfaces estamos de entrada obligados a que estos métodos existan y de este modo la aparición del error se adelanta al tiempo de compilación.
- Si se implementa un interface y nos olvidamos de algún método, el programa ni se compilará.
- Otra cosa es que luego el objeto rote bien o mal, pero ésto quedará claramente acotado en cómo se haya implementado el método.
- Resumiendo, las interfaces proveen de un sistema de prevención de errores y de acotación de responsabilidades en la construcción de software.

Paquetes

Los paquetes amplían y refuerzan las características de definición de ámbitos que hemos visto anteriormente.
Cuando se crea una clase sin especificar a qué paquete pertenece, pasa a formar parte de un paquete unnamed default package.
Para especificar en qué paquete queremos ubicar la clase que estamos creando hay que incluir una sentencia package al principio del .java:

package ejemplos.polimorfismo;

// aquí vendría al código de la clase Rectangulo del ejemplo
// anterior:

public class Rectangulo
{ ...

La estructura de paquetes deberá repetirse en forma de estructura de directorios con los mismos nombres (Case sensitive) en la máquina en que se tenga que ejecutar el programa.
Se ensayarán como directorios raíz uno de los indicados en CLASSPATH (lista separada con ; )
Ejemplo de CLASSPATH: ".;c:\cursojava;c:\java\classes"
CLASSPATH se define (en la máquina en que se tenga que ejecutar el programa) de manera diferente dependiendo de la herramienta de desarrollo/intérprete de Java. Puede ser una variable de entorno, un parámetro de configuración del entorno de desarrollo o un parámetro del intérprete.
Para el ejemplo anterior la estructura de directorios sería la siguiente dependiendo del sistema operativo:

UNIX: cursojava/ejemplos/polimorfismo Windows: cursojava\ejemplos\polimorfismo

Mac: cursojava:ejemplos:polimorfismo

El directorio polimorfismo del punto anterior podría ser un fichero .zip con ficheros e incluso estructura de subdirectorios)
En definitiva, un paquete se asocia con el último subdirectorio dentro del cual sólo hay ficheros .class, por lo tanto, un conjunto de clases están en el mismo paquete si están en el mismo directorio.

Inner classes

El mecanismo de las inner classes permite definir una clase dentro de otra.
Esta característica está disponible a partir de JDK 1.1
Distinguiremos dos tipos de inner classes:

No anónimas:

class A
{
    ---
    class B
    {
       ...

Desde el exterior el tipo B es A.B
El fichero .class generado es A$B.class

Anónimas:

Es un mecanismo muy utilizado para la impementación de eventos en el nuevo modelo 1.1 para evitar tener que implementar un interface para cada listener.
Ejemplo:

...
button1.addActionListener(new ActionListener()
{
  public void actionPerformed(ActionEvent e)
  {
     button1_actionPerformed(e);
  }
});
...

En este caso se crea implícitamente un objeto de una subclase anónima de ActionListener en la que se implementa el método actionPerformed y dicho objeto es pasado como parámetro a addActionListener.
Si este código forma parte de un formulario llamado Frame1 se genera el fichero Frame1$1.class que corresponde a la clase anónima.x

Unidad anterior - Unidad siguiente