DESARROLLO DE CLASES

PR UD4 – Tema 1

IES Armando Cotarelo Valledor

Adrián Fernández González
Tabla de contenido
1. Introducción .............................................................................................................................. 2
2. Herencia .................................................................................................................................... 2
2.1. Sobrescritura. Polimorfismo de sobrecarga ....................................................................... 3
2.1.1. Super ........................................................................................................................... 4
2.2. instanceof ........................................................................................................................... 5
2.3. Final .................................................................................................................................... 5
2.4. Polimorfismo de inclusión o tipo ....................................................................................... 6
2.5. Ocultación y Static .............................................................................................................. 7
3. Interfaz ...................................................................................................................................... 8
3.1. Interfaces y polimorfismo .................................................................................................. 9
3.2. Interfaces y herencia ........................................................................................................ 10
3.3. Interfaz vs. Herencia......................................................................................................... 10
3.4. Interfaz bandera. Flag interface ....................................................................................... 10
4. Clase Object ............................................................................................................................. 10
4.1. Métodos base ................................................................................................................... 10
4.1.1. toString ...................................................................................................................... 11
4.1.2. equals ........................................................................................................................ 11
4.1.3. clone .......................................................................................................................... 11
5. Enum ....................................................................................................................................... 12
5.1. Valor asociado .................................................................................................................. 13
5.2. Recorrer el enumerado .................................................................................................... 14
Desarrollo de clases
1. Introducción
En la programación orientada a objetos, una de las características más potentes, es la
herencia. Esta es la capacidad que tienen las clases para establecer una jerarquía, una serie de
clases que comparten un padre, compartiendo sus atributos y métodos.

Esto permite una mejor organización, una menor cantidad de código escrito y la capacidad de
agrupar un conjunto de clases y objetos bajo un grupo común.

2. Herencia
La herencia es la capacidad de las clases de extender a otra clase, obteniendo todos aquellos
métodos y atributos a los que tenga acceso.

Esto permite crear varios objetos de un tipo con características similares, pero, a su vez,
propiedades únicas.

Para establecer esta relación de herencia, en la declaración de la clase, se añade la palabra

extends seguida de la clase a la que extiende.

En este caso, la clase Empleado hereda de la clase Persona.

Cuando se establece esta relación, todos aquellos elementos públicos, de paquete o

protegidos del padre son accesibles desde la clase hijo.

En este caso, desde la clase Empleado, que hereda de la clase Persona, se puede acceder al
atributo nombre como si fuese suyo.

La herencia en Java es simple, es decir, una clase solo puede heredar de una clase, aunque
esta, a su vez, puede heredar de otra, creando una cadena.

Por otro lado, una clase puede ser padre de otras muchas, pudiendo múltiples clases extender
de una misma clase.

Por tanto, se crea una estructura jerárquica en forma de árbol.

2.1. Sobrescritura. Polimorfismo de sobrecarga
La herencia permite realizar lo que se denomina sobrescritura, modificar el funcionamiento de
un método ya definido por el padre, de tal forma que todo objeto hijo invoque su propio
método y no el del padre.

En este caso, en la clase Hijo se sobrescribe el método hablar, por lo que si se invoca desde un
objeto de la clase Padre se muestra un mensaje y si se invoca desde un objeto de la clase Hijo,
muestra otro.
2.1.1. Super
La palabra reservada super permite invocar un método de una clase superior tal como la
palabra this lo hace de la propia.

En este caso, desde la clase Rana se invoca al constructor de la clase Anfibio, padre de la
primera, pasándole los atributos gestionados por esta y luego asigna los suyos propios.

Tal como se hizo hasta ahora, pueden sobrescribirse los constructores, aunque estos invoquen
a super.

Con super se puede invocar también el método del padre que ha sido sobrescrito, para
completar su funcionamiento.
En este ejemplo, la clase Perro, extiende a la clase Animal, sobrescribe el método sonido y lo
invoca en su interior. De esta forma, se muestra primero el mensaje de la clase Animal y luego
el de la clase Perro.

2.2. instanceof
El operador instanceof permite verificar si un objeto es instancia de una clase o una subclase
de esta.

En este ejemplo, h es un objeto de la clase Hijo, por lo que es instancia de él mismo y su padre,
la clase Padre. En cambio, p es un objeto de la clase Padre, por lo que no es de Hijo.

2.3. Final
El modificador final establece que dicho elemento no va a ser modificado y, por tanto, no
puede ser modificado mediante herencia.

Si una clase se establece como final, no puede ser extendida.

Si un método se establece como final, no puede ser sobrescrito.

2.4. Polimorfismo de inclusión o tipo
La herencia permite lo que se denomina el polimorfismo de inclusión, la capacidad de los
objetos a ser asignados a variables de un tipo padre y ser utilizados como tal, manteniendo sus
características propias. Esto permite cosas como declarar conjuntos como los arrays de un tipo
padre y agrupar todos los elementos para gestionar las características que tienen en común.

Al estar referenciados desde el tipo padre, podrán ser invocados todos aquellos métodos que
disponga el padre, pero llamándolos desde la clase en cuestión. Esto quiere decir que,
aquellos que hayan sido sobrescritos, serán invocados en el hijo, haciendo la lógica allí
implementada y no la del padre, independientemente del tipo que sea.

En este caso, aunque ambos objetos estén referenciados como de tipo Padre, el objeto h es un
objeto de la clase Hijo, por tanto, se invoca el método sobrescrito por dicha clase.

Para entender esto bien, solo hay que imaginarse un disfraz. Una persona, por mucho que se
vista de otra, seguirá hablando y actuando como ella misma.

Si se requiere utilizar un método de una clase hijo, es necesario realizar un casteo a dicha
clase, pero hay que verificar primero que esa es la clase correcta con el uso de instanceof, por
ejemplo, de lo contrario, si no se hace y no es, lanzará una excepción.

Por otro lado, para todo lo que se requiera un objeto de clase padre, puede ser utilizado un
objeto hijo. Por ejemplo, si un método requiere un objeto de clase Padre como parámetro, se
puede facilitar un objeto de clase hijo, ya que este dispone de los métodos que dispone el
padre.
2.5. Ocultación y Static
Como se mencionó en el tema anterior, los elementos estáticos pertenecen a la clase, no son
elementos de un objeto y, por tanto, aunque se puede acceder a ellos si la visibilidad lo
permite, no pueden ser sobrescritos, pero si ocultados.

Si se vuelve a declarar un atributo, ya sea estático o no, o un método estático de una clase
padre, este se oculta, es decir, que, si se invoca desde el hijo, se usará el del hijo y no del
padre, mientras que, si se invoca en el padre, se usa la del padre.

En caso de los elementos estáticos, se puede invocar el del padre de igual manera que se haría
con una constante, anteponiendo el nombre de la clase.

Por otro lado, en cualquier caso, se puede usar super para acceder a los del padre desde la
clase hijo si estos son accesibles.

Hay que tener en cuenta que, al usar el polimorfismo de inclusión, aquellos elementos que han
sido ocultados, serán invocados en función del elemento referenciado.
En este caso, ambas clases disponen de un método estático denominado show, por lo que el
del hijo oculta al del padre si se invoca directamente en dentro de la clase. En cambio, si se
invoca desde fuera, se llamará al de la clase referenciada por el tipo del objeto, no el objeto
creado.

3. Interfaz
Una interfaz es una declaración de métodos que una o varias clases van a implementar.

Las interfaces carecen de atributos, constructores ni comportamiento, tan solo declaran las
cabeceras de los métodos públicos que serán implementados a posteriori y, como mucho,
constantes.

Estas, por tanto, se utilizan para estipular comportamientos comunes de múltiples clases, el
qué hacer. Luego, cada clase concreta se encargará de estipular el cómo se hace.
Las interfaces pueden ser implementadas por múltiples clases independientes que no tienen
por qué compartir una estructura jerárquica entre ellas.

Para ello, se añaden mediante la palabra implements.

En este ejemplo, la clase Perro implementa la interfaz IAnimal, implementando la lógica de

todos y cada uno de los métodos declarados en la propia interfaz.

Como puede observarse, la clase puede extender e implementar a la vez.

A diferencia de la herencia, una misma clase puede implementar múltiples interfaces a la vez,
tan solo separándolas por comas.

Puesto que carecen de un constructor y ningún tipo de implementación, las interfaces NO

pueden ser instanciadas.

3.1. Interfaces y polimorfismo

Una de las mayores potencias y utilidades de las interfaces es conjuntamente con el
polimorfismo de inclusión.

Un conjunto de clases, completamente dispares, pueden ser agrupadas mediante una interfaz
y ser tratadas como tal, pudiendo invocar los métodos declarados en la misma y realizando las
acciones que hayan implementado cada una de las clases.

Hay que tener en cuenta que, al igual que con la herencia, solo se pueden invocar aquellos
métodos de la interfaz, pero realizando la operación que tenga implementado cada uno.

También, al igual que en la herencia, si se verifica un objeto de la clase que implementa la

interfaz contra esta mediante instanceof, devolverá true.
3.2. Interfaces y herencia
Hay que tener en cuenta que, al igual que una clase heredada obtiene las propiedades de
todos sus ancestros, lo mismo pasa con la implementación de las interfaces.

Una clase que herede de otra que implementa una interfaz, tiene esas características y, por
tanto, la implementa y puede ser utilizada como tal.

3.3. Interfaz vs. Herencia

Una interfaz suele usarse cuando un conjunto de clases no relacionadas mediante una
jerarquía, han de disponer de unas cualidades comunes o cuando la herencia se queda corta.

Por ejemplo, varios animales pueden implementar una interfaz INadador en caso de que
tengan la capacidad de nadar.

En este caso, una clase base Pez implementa directamente la interfaz, ya que todos los peces
nadan, mientras que la clase Mamifero no lo hace porque no todos tienen esa capacidad.

Por otro lado, podría haber una clase Persona que no hereda de Animal que también tenga la
cualidad de nadar, implementando INadador.

3.4. Interfaz bandera. Flag interface

Hay un tipo de interfaces especiales denominadas bandera. Estas son interfaces vacías cuyo
único propósito es el de agrupar realizando polimorfismo de inclusión o indicar una cualidad
para ser verificada mediante el uso de instanceof.

4. Clase Object
La clase Object es la clase padre de toda clase en Java, es el ancestro final en la jerarquía.

Esta clase dispone de los métodos básicos que pueden ser utilizados por cualquier objeto y
cualquier clase, además de poder ser sobrescritos para personalizar su comportamiento.

4.1. Métodos base

Estos métodos son comunes para todos los objetos y pueden ser sobrescritos para modificar o
personalizar su comportamiento.
4.1.1. toString
Uno de los métodos más utilizados de la clase Object y también de los más sobrescritos es el
método toString. Este permite la transformación de un objeto a String, mostrando aquella
información que se considere oportuna.

Por defecto, mostrará el paquete, seguido del nombre de la clase, @ y la referencia a memoria
donde se encuentra el objeto.

En este caso, el resultado podría ser algo similar a lo siguiente:

Este método es invocado de forma automática cada vez que se intenta mostrar por pantalla el
objeto directamente, por lo que, sobrescribirlo mejora la operación.

Su principal uso es el de mostrar la información relevante que pueda ser susceptible de ser
mostrada al usuario o para tareas de mantenimiento y pruebas, evitando tener que estar
invocando los getters de todos los atributos.

4.1.2. equals
El método equals permite comparar dos objetos, generalmente de la misma clase, y devuelve
si son iguales.

Por defecto, equals solo devuelve true si ambos son el mismo objeto en memoria, lo cual no
siempre es así ni se requiere que sea así.

Por tanto, al implementarlo se puede establecer una forma real de comparación, como puede
ser comparar los valores de los atributos o uno en concreto.

4.1.3. clone
Este método realiza y devuelve una copia exacta del objeto en cuestión, creando un nuevo
objeto idéntico al original.
5. Enum
Los enum o enumerados, son un tipo de elemento especial que permite establecer un
conjunto de valores posibles para algo concreto. Por ejemplo, las tallas de la ropa, S, M, L, XL,
etc.

Esto restringe el uso de valores, asegurando que solo se seleccionará uno de los posibles.

En este ejemplo, se establecen tres posibles periodos de la Historia como un enum. Nótese
que están estipulados en mayúsculas y como una lista, separados por comas.

Para usar uno de los valores de los enumerados, se referencian como constantes de una clase.

Los enumerados son usados como tipos, estableciéndolos allí donde se requiera su valor. De
esta forma, si no se introduce uno de los posibles valores establecidos, dará error de tipos y se
lanzará una excepción, de igual forma que un valor String no puede ser introducido en una
variable de tipo int.

En este caso, al crear un objeto de la clase Ropa, ha de usarse uno de los posibles valores del
enumerado Talla.

Los enumerados son similares a una clase con variables estáticas, con un par de salvedades:

 Los enum no disponen de un valor asociado, aunque puede ser establecido.

 Disponen de una serie de métodos propios útiles.
 Funcionan como una clase, pudiendo añadir atributos y métodos propios.
 Pueden recorrerse como si fuese una lista.
 Establecen una restricción de tipos cuando se usan.
 No pueden ser instanciados.
5.1. Valor asociado
Por defecto, los enumerados no disponen de un valor, si se muestran por pantalla, se mostrará
su nombre tal cual.

Para establecer un valor, hay que crear un atributo, un constructor y un getter, pero de una
forma especial.

Primero, se crea un atributo que será el encargado de guardar el valor.

Luego, se crea un constructor privado cuyo parámetro es el valor a establecer. Hay que tener
en cuenta que, como se ha indicado antes, los enumerados no son clases y, por tanto, no
pueden ser instanciados, de ahí que el constructor sea privado.

A continuación, se crea el getter público del valor como cualquier otro.

Por último, cuando se establecen los distintos elementos del enumerado, se incluye, entre
paréntesis el valor. Esto funciona como una llamada al constructor privado.

Una vez realizado esto, puede obtenerse el valor llamando al getter.

Para un uso más sencillo, en vez del getter o, de forma adicional, puede sobrescribirse el
método toString para que devuelva el valor, ahorrando así, la llamada al getter.
Como puede observarse, no es necesario llamar al getter para mostrar el valor.

A mayores, pueden añadirse tantos métodos como se requiera para añadir funcionalidades
adicionales.

5.2. Recorrer el enumerado

A diferencia de las propiedades de las clases, los enumerados pueden ser recorridos para
comparar o verificar. Esto se realiza mediante un foreach.