TesJo

Temario
Objetivo Del Tema..............................................................................................................................2
4 polimorfismo y Excepciones............................................................................................................3
4.1 Definición............................................................................................................................................. 3
El polimorfismo en acción.............................................................................................................................4
Uso de Polimorfismo............................................................................................................................................6
4.2 Clases abstractas: definición, métodos abstractos, implementación de clases abstractas, modelado
de clases abstractas................................................................................................................................... 7
Clases Abstractas.................................................................................................................................................7
Métodos Abastractos............................................................................................................................................8
Implementación De Clases Abstractas..............................................................................................................9
4.3 REUTILIZACIÓN DEL CÓDIGO.........................................................................................................10
4.4 TIPOS DE EXCEPCIONES................................................................................................................ 11
TIPOS DE EXCEPCIONES...............................................................................................................................12
4.5 GESTION DE EXCEPCIONES: MANEJO DE EXCEPCIONES, LANZAMIENTO DE EXCEPCIONES
................................................................................................................................................................. 13
 TesJo

Objetivo Del Tema

 Conocer las diferentes clases y métodos que se pueden utilizar dentro de la programación
para tener un panorama más amplio.

2
Ing. Mecatrónica
 TesJo

4 polimorfismo y Excepciones

4.1 Definición

El polimorfismo es un concepto de la programación orientada a objetos que nos permite

programar en forma general, en lugar de hacerlo en forma específica. En general nos sirve
para programar objetos con características comunes y que todos estos compartan la misma
superclase en una jerarquía de clases, como si todas fueran objetos de la superclase. Esto nos
simplifica la programación.
Para ponerlo en práctica se hará un ejemplo bastante sencillo. se hará una librería de clases que
represente figuras tridimensionales y bidimensionales, y su respectiva jerarquía de clases. las
clases deben ser capaces de tener funcionamiento bastante básico, como obtener áreas,
volúmenes y perímetros de la figura correspondiente
la representación de la jerarquía seria como esta:
la superclase de dicha jerarquía podría ser muy parecida a:

Figura. 1. Ejemplo

Las siguientes clases en el nivel de la jerarquía podrían quedar muy parecidos a estas

3
Ing. Mecatrónica
 TesJo

 public abstract class figura2D extends figura {

 public abstract int calcularArea ();
 public abstract int calcularPerimetro ();
}
 public abstract class figura3D extends figura {
 public abstract int calcularVolumen ();
}
Figura 2: Clase

El polimorfismo en acción

Supongamos que deseamos saber de la figura que tiene mayor área independientemente de su
forma. Perímetro programamos una función que halle el mayor de varios números reales
positivos.

Figura 3: Mayor área

Ahora, la llamada a la función valor mayor.

Figura 4. Funcion mayor

La funcion figura mayor que comprara el area de figura planas es semejante a la funcion
valorMayor anteriomente definida, se le pasa el array de objetos de la clase de la figura. La
funcion devuelve una refrencia objeto cuya area en la mayor .

Figura 5. Mayor

4
Ing. Mecatrónica
 TesJo

La clave de la definición de la función está en la línea.

Figura 6. Función

En la primera línea, se llama a la versión correcta de la función área dependiendo de la referencia

al tipo de objeto que guarde el elemento figuras[i] del array. En areaMayor se guarda el valor
mayor de las áreas calculadas, y en m figura. La figura cuya área es la mayor.
La principal ventaja de la definición de esta función estriba en que la función estriba en que la
función FiguraMayor esta definida en términos de variable Figuras de la clase base Figura, por
tanto, trabaja no solamente para una colección de círculos y rectángulos, sino también para

cualquier otra figura deriva de la clase base figura. Así si se deriva Triangulo de figura, y se añade
a la jerarquía de clases, la función figuraMayor podrá manejar objetos de dicha clase, sin
modificar para nada el código de la misma.
Veamos ahora la llamada de la función FiguraMayor

Figura 7. Función

Pasamos el array figura la función figuraMayor , el valor que retorna lo guardamos en fMayor .

Para conocer el valor del área, desde fMayor se llamará a la función miembro área. se llamará a
la versión correcta dependiendo de la referencia al tipo de objeto que guarde por fMayor.
si fMayor guarda una referencia a un objeto de la clase Circulo, llama a la función área definida en
dicha clase. si fMayor guarda una referencia a un objeto de la clase Rectángulo, llamara la
función área definida en dicha clase, y así sucesivamente.

La combinación de herencia y enlace dinámico se denomina polimorfismo. El polimorfismo es, por

tanto, la técnica que permite pasar un objeto de una clase derivada a funciones que conocen el
objeto solamente por su clase base.

El poder manipular un Objeto como si este fuera de un tipo genérico otorga mayor flexibilidad al
momento de programar con Objetos, el término Polimorfismo también es asociado con un
concepto llamado late-Binding observé el siguiente fragmento de código:

5
Ing. Mecatrónica
 TesJo

Figura 8. Código

Inicialmente se puede pensar que este código generaría un error debido a que el tipo de referencia es distinta a la
instancia del objeto, sin embargo, el fragmento anterior es correcto y demuestra el concepto de
Polimorfismo* para asentar este tema se describe un ejemplo más completo:

Uso de Polimorfismo

El uso de Polimorfismo posee ciertos detalles que no fueron descritos en el ejemplo anterior, uno de estos, que
también tiene implicaciones en otros componentes es: Casting.

6
Ing. Mecatrónica
 TesJo

4.2 Clases abstractas: definición, métodos abstractos, implementación

de clases abstractas, modelado de clases abstractas.

Clases Abstractas

Figura 9. Clases abstractas figura y subclase

Son clases de las que no es posible crear instancias; frecuentemente, están implementadas sólo
parcialmente o no están implementadas. Una clase abstracta es aquella que forzosamente se ha
de derivar si se desea que se puedan crear objetos de la misma o acceder a sus miembros
estáticos. El modificador abstract se utiliza para indicar que una clase está incompleta y que sólo
se va a utilizar como una clase base. Una clase abstracta se diferencia de una clase no abstracta
en lo siguiente:

1. No se puede crear una instancia de una clase abstracta directamente, y es un error en

tiempo de compilación utilizar el operador new en una clase abstracta. Aunque es posible
tener variables y valores cuyos tipos en tiempo de compilación sean abstractos, tales
variables y valores serán null o contendrán referencias a instancias de clases no
abstractas derivadas de los tipos abstractos.
2. Se permite que una clase abstracta contenga miembros abstractos, aunque no es
necesario.
3. No se puede sellar una clase abstracta.

Cuando una clase no abstracta se deriva de una clase abstracta, la clase no abstracta debe incluir
implementaciones reales de todos los miembros abstractos heredados; por lo tanto, reemplaza a
estos miembros abstractos. En el ejemplo:

7
Ing. Mecatrónica
 TesJo

abstract class A
{
public abstract void F();
}
abstract class B: A
{
public void G() {}
}
class C: B
{
public override void F() {
// actual implementación of F
}
}
Figura10. Ejemplo2

La clase abstracta A define el método abstracto F. La clase B define un método adicional G, pero
no proporciona una implementación de F, por lo que B también debe ser declarada como
abstracta. La clase C reemplaza F y proporciona una implementación real. Dado que no hay
miembros abstractos en C, está permitido que C sea no abstracta, aunque no es necesario.

Métodos Abastractos

Cuando una declaración de método de instancia incluye un modificador abstract, se dice que el
método es un método abstracto. Aunque un método abstracto es también implícitamente un
método virtual, no puede tener el modificador virtual.

Una declaración de método abstracto introduce un nuevo método virtual pero no proporciona una
implementación del método. En cambio, es necesario que las clases derivadas no abstractas
proporcionen su propia implementación mediante el reemplazo del método. Debido a que un
método abstracto no proporciona una implementación real, el cuerpo-del-método de un método
abstracto consiste simplemente en un punto y coma. Las declaraciones de métodos abstractos
sólo se permiten en clases abstractas.

public abstract class Shape

{
public abstract void Paint(Graphics g, Rectangle r);
}
public class Ellipse: Shape
{
public override void Paint(Graphics g, Rectangle r) {
[Link](r);
}
}
public class Box: Shape
{
public override void Paint(Graphics g, Rectangle r) {
[Link](r);
}
} 8
Ing. Mecatrónica
 TesJo

Figura 11. Abstracto

La clase Shape define la noción abstracta de un objeto de forma geométrica que puede dibujarse
él mismo. El método Paint es abstracto porque no existe una implementación predeterminada
significativa. Las clases Ellipse y Box son implementaciones Shape concretas. Ya que estas
clases no son abstractas, son necesarias para reemplazar el método Paint y proporcionar una
implementación real

Implementación De Clases Abstractas

El modificador abstract se utiliza para indicar que una clase está incompleta y que sólo se va a
utilizar como una clase base. Una clase abstracta se diferencia de una clase no abstracta en lo
siguiente:

1. No se puede crear una instancia de una clase abstracta directamente, y es un error en

tiempo de compilación utilizar el operador new en una clase abstracta. Aunque es posible

2. tener variables y valores cuyos tipos en tiempo de compilación sean abstractos, tales
variables y valores serán null o contendrán referencias a instancias de clases no
abstractas derivadas de los tipos abstractos.

3. Se permite que una clase abstracta contenga miembros abstractos, aunque no es

necesario.

4. No se puede sellar una clase abstracta.

Cuando una clase no abstracta se deriva de una clase abstracta, la clase no abstracta debe incluir
implementaciones reales de todos los miembros abstractos heredados; por lo tanto, reemplaza a
estos miembros abstractos. En el ejemplo

abstract class A
{
public abstract void F();
}
abstract class B: A
{
public void G() {}
}
class C: B
{
public override void F() {
// actual implementation of F
}
}

9
Ing. Mecatrónica
 TesJo

Figura 12. No abstracto

La clase abstracta A define el método abstracto F. La clase B define un método adicional G, pero
no proporciona una implementación de F, por lo que B también debe ser declarada como
abstracta. La clase C reemplaza F y proporciona una implementación real. Dado que no hay
miembros abstractos en C, está permitido que C sea no abstracta, aunque no es necesario.

4.3 REUTILIZACIÓN DEL CÓDIGO

La reutilización de código se refiere al comportamiento y a las técnicas que garantizan que una
parte o la totalidad de un programa informático existente se pueda emplear en la construcción de
otro programa. De esta forma se aprovecha el trabajo anterior, se economiza tiempo, y se reduce
la redundancia.
La manera más fácil de reutilizar código es copiarlo total o parcialmente desde el programa
antiguo al programa en desarrollo. Pero es trabajoso mantener múltiples copias del mismo código,
por lo que en general se elimina la redundancia dejando el código reusable en un único lugar, y
llamándolo desde los diferentes programas. Este proceso se conoce como abstracción.

La abstracción puede verse claramente en las bibliotecas de software, en las que se agrupan
varias operaciones comunes a cierto dominio para facilitar el desarrollo de programas nuevos.
Hay bibliotecas para convertir información entre diferentes formatos conocidos, acceder a
dispositivos de almacenamiento externos, proporcionar una interfaz con otros programas,
manipular información de manera conocida (como números, fechas, o cadenas de texto).
Para que el código existente se pueda reutilizar, debe definir alguna forma de comunicación o
interfaz. Esto se puede dar por llamadas a una subrutina, a un objeto, o a una clase.

La clase descendiente puede añadir sus propios atributos y métodos, pero también puede sustituir
u ocultar los heredados. En concreto:
1. Se puede declarar un nuevo atributo con el mismo identificador que uno heredado,
quedando este atributo oculto. Esta técnica no es recomendable.

2. Se puede declarar un nuevo método de instancia con la misma cabecera que el de la

clase ascendiente, lo que supone su sobre escritura. Por lo tanto, la sobre escritura o
redefinición consiste en que métodos adicionales declarados en la clase descendiente con
el mismo nombre, tipo de dato devuelto y número y tipo de parámetros sustituyen a los
heredados.

3. Se puede declarar un nuevo método de clase con la misma cabecera que el de la clase
ascendiente, lo que hace que éste quede oculto. Por lo tanto, los métodos de clase o
estáticos (declarados como static) no pueden ser redefinidos.

10
Ing. Mecatrónica
 TesJo
4. Un método declarado con el modificador final tampoco puede ser redefinido por una clase
derivada.

5. Se puede declarar un constructor de la subclase que llame al de la superclase de forma

implícita o de mediante la palabra reservada super.

6. En general puede accederse a los métodos de la clase ascendiente que han sido
redefinidos empleando la palabra reservada super delante del identificador del método.
Este mecanismo sólo permite acceder al método perteneciente a la clase en el nivel
inmediatamente superior de la jerarquía de clases.
 Primero veamos como seria la clase UnidadDeTiempo:

public class UnidadDeTiempo {

int valor;
int tope;
public int forward(){
if(valor == tope)
valor=0;
else
valor++;
return valor;
}

public int reset(){

valor=0;
return valor;
}
}

Y nuestra clase Horas:

public class Horas extends UnidadDeTiempo{
public Horas() {
[Link]=0;
[Link]=23;
}
}

Figura 13. Unidad del Tiempo

4.4 TIPOS DE EXCEPCIONES

¿Qué es una excepción?

Una excepción es un evento que ocurre durante la ejecución del programa que interrumpe el flujo
normal de las sentencias.
Ósea, algo que altera la ejecución normal.

11
Ing. Mecatrónica
 TesJo
Muchas clases de errores pueden generar excepciones desde problemas de hardware, como la
avería de un disco duro, a los simples errores de programación, como tratar de acceder a un
elemento de un array fuera de sus límites.

TIPOS DE EXCEPCIONES

Existen varios tipos fundamentales de excepciones:

Error: Excepciones que indican problemas muy graves, que suelen ser no recuperables y no
deben casi nunca ser capturadas.
Exception: Excepciones no definitivas, pero que se detectan fuera del tiempo de ejecución.
RuntimeException: Excepciones que se dan durante la ejecución del programa.

Todas las excepciones tienen como clase base la clase Throwable, que está incluida en el
paquete [Link], y sus métodos son:

 Trowable( String mensaje ); Constructor. La cadena es opcional

 Throwable fillInStackTrace(); Llena la pila de traza de ejecución.
 String getLocalizedMessage(); Crea una descripción local de este objeto.
 String getMessage(); Devuelve la cadena de error del objeto.
 void printStackTrace( PrintStream_o_PrintWriter s ); Imprime este objeto y su traza en
el flujo del parámetro s, o en la salida estándar (por defecto).
 String toString; Devuelve una breve descripción del objeto.

FUNCIONAMIENTO.
Para que el sistema de gestión de excepciones funcione, se ha de trabajar en dos partes de los
programas:
 Definir qué partes de los programas crean una excepción y bajo qué condiciones. Para ello
se utilizan las palabras reservadas throw y throws.
 Comprobar en ciertas partes de los programas si una excepción se ha producido, y actuar
en consecuencia. Para ello se utilizan las palabras reservadas try, catch y finally.

MANEJO DE EXCEPCIONES: try - catch – finally.

Cuando el programador va a ejecutar un trozo de código que pueda provocar una excepción (por
ejemplo, una lectura en un fichero), debe incluir este fragmento de código dentro de un bloque try:

try {
// Código posiblemente problemático

12
Ing. Mecatrónica
PeroTesJo
lo importante es cómo controlar qué hacer con la posible excepción que se cree. Para ello se
utilizan las cláusulas catch, en las que se especifica que acción realizar:

try {

// Código posiblemente problemático

} catch( tipo_de_excepcion e) {

// Código para solucionar la excepción e

} catch( tipo_de_excepcion_mas_general e) {

// Código para solucionar la excepción e

4.5 GESTION DE EXCEPCIONES: MANEJO DE EXCEPCIONES,

LANZAMIENTO DE EXCEPCIONES

Las excepciones son el mecanismo por el cual pueden controlarse en un programa Java las
condiciones de error que se producen. Estas condiciones de error pueden ser errores en la lógica
del programa como un índice de un array fuera de su rango, una división por cero o errores
disparados por los propios objetos que denuncian algún tipo de estado no previsto, o condición
que no pueden manejar.
Las excepciones son objetos que contienen información del error que se ha producido y que
heredan de la clase Throwable o de la clase Exception. Si nadie captura la excepción interviene
un manejador por defecto que normalmente imprime información que ayuda a encontrar quién
produjo la excepción.
Existen dos categorías de excepciones:

Excepciones verificadas: El compilador obliga a verificarlas. Son todas las que son lanzadas
explícitamente por objetos de usuario.
Excepciones no verificadas: El compilador no obliga a su verificación. Son excepciones como
divisiones por cero, excepciones de puntero nulo, o índices fuera de rango.

LANZAMIENTO DE EXCEPCIONES:

throw – throws.

13
Ing. Mecatrónica
 TesJo
Muchas veces el programador dentro de un determinado método deberá comprobar si alguna
condición de excepción se cumple, y si es así lanzarla. Para ello se utilizan las palabras
reservadas throw y throws.

Por una parte la excepción se lanza mediante la sentencia throw:

if ( condicion_de_excepcion == true )
throw new miExcepcion();

Se puede observar que hemos creado un objeto de la clase miExcepcion, puesto que las
excepciones son objetos y por tanto deberán ser instanciadas antes de ser lanzadas.
Aquellos métodos que pueden lanzar excepciones, deben cuáles son esas excepciones en su
declaración. Para ello se utiliza la sentencia throws:
 tipo_devuelto miMetodoLanzador() throws miExcep1, miExcep2 {
// Codigo capaz de lanzar excepciones miExcep1 y miExcep2
}
 Se puede observar que cuando se pueden lanzar en el método más de una excepción se
deben indicar en sus declaraciones separadas por comas.

Ejemplo de gestión de excepciones.

 Ahora que ya sabemos cómo funciona este sistema, conviene ver al menos un pequeño
ejemplo, que ilustre al lector en el uso de las excepciones:

// Creo una excepción personalizada

class MiExcepcion extends Exception {
MiExcepcion(){

super(); // constructor por defecto de Exception

}

MiExcepcion( String cadena ){

super( cadena ); // constructor param. de Exception
}
}

// Esta clase lanzará la excepción

class Lanzadora {

void lanzaSiNegativo( int param ) throws MiExcepcion {

if ( param < 0 )
throw new MiExcepcion( "Numero negativo" );

}
class Excepciones {
public static void main( String[] args ) {
// Para leer un fichero
Lanzadora lanza = new Lanzadora();
FileInputStream entrada = null;
int leo;
try {
14
Ing. Mecatrónica entrada = new FileInputStream( "[Link]" );
while ( ( leo = [Link]() ) != -1 )
[Link]( leo );
[Link]();
 TesJo

[Link]( "Excepcion: " + [Link]() );

}

catch ( IOException e ){ // Estándar

[Link]( "Excepcion: " + [Link]() );
}

finally {
if ( entrada != null )
try {

[Link](); // Siempre queda cerrado

} catch ( Exception e ) {

[Link]( "Excepcion: " + [Link]() );

}

[Link]( "Fichero cerrado." );

}
}
}

class Excepciones {
public static void main( String[] args ) {
// Para leer un fichero

FileInputStream entrada = null;

Lanzadora lanza = new Lanzadora();
int leo;
try {

entrada = new FileInputStream("[Link]");

while ( ( leo = [Link]() ) != -1 )
[Link]( leo );

[Link]( "Todo fue bien" );

}
catch ( MiExcepcion e ){ // Personalizada
[Link]( "Excepcion: " + [Link]() );
}
catch ( IOException e ){ // Estándar
[Link]( "Excepcion: " + [Link]() );
}
finally {

[Link](); // Así el fichero siempre queda cerrado

[Link]( "Fichero cerrado" ); } } } 15
Ing. Mecatrónica
 TesJo

Este programa lee un fichero ([Link]), y lee su contenido en forma de números. Si alguno de
los números leídos es negativo, lanza una excepción MiExcepcion, Además gestiona la excepción
IOException, que es una excepción de las que Java incluye y que se lanza si hay algún problema
en una operación de entrada/salida. Ambas excepciones son gestionadas, imprimiendo su
contenido (cadena de error) por pantalla.

La salida de este programa, suponiendo un número negativo sería:

Excepción: Numero negativo - Fichero cerrado

En el caso de que no hubiera ningún número negativo sería:

Todo fue bien - Fichero cerrado

En el caso de que se produjese un error de E/S, al leer el primer número, sería:

Excepción: [Link] - Fichero cerrado

16
Ing. Mecatrónica