Concepto de Herencia:
La Herencia se puede
aplicar tanto a Clases Propias, como a Clases propias del lenguaje de
programación Java.
La
Herencia
consiste en crear una clase que obtenga todas las características de otra. Esta
clase a su vez tendrá también características propias.
El concepto de Herencia consiste en
crear una nueva Clase a partir de otra. La nueva Clase es una mejora de la anterior. O dicho de otra
manera, es una especialización de la
primera Clase.
Concretamente, la Herencia consiste en
tomar una Clase inicial, y, a partir de ella, crear otra Clase que posee las
mismas propiedades y métodos que la
Clase inicial, además de unas nuevas propiedades y métodos
que la Clase
inicial no poseía. La nueva Clase creada puede incluso redefinir métodos de la Clase inicial.
La Clase inicial se denomina Clase
Base, la Clase
creada a partir de la clase base se denomina Clase Derivada. La Clase Derivadala Clase Base
La Herencia es una técnica muy útil
que nos permite reutilizar código, es decir, que nos permite usar de nuevo lo
que ya teníamos programado añadiendo simplemente algunos cambios y adecuar el
código al proyecto actual.
En esta explicación guiada, veremos
un ejemplo de uso de la
Herencia con clases propias del lenguaje Java.
Planteamiento Inicial
“Botones Contadores”
Supongamos que en los proyectos
cotidianos se plantea la necesidad de usar botones que guarden el número de
veces que son pulsados. Estos botones funcionarían exactamente igual que los
botones normales (JButton) y tendrían su mismo aspecto, pero sería interesante
que además tuvieran los siguientes métodos:
Método setPulsaciones:
Permitirá asignar un número de
pulsaciones al botón.
btnContador.setPulsaciones(3);
//Se asignan 3 pulsaciones al botón btnContador
Método getPulsaciones:
Permitirá saber cuántas pulsaciones
tiene un botón.
int p = btnContador.getPulsaciones();
//Se recoge el número de pulsaciones del botón btnContador
//en la variable p
Método incrementarUno:
Permite incrementar en uno las
pulsaciones que tiene un botón.
btnContador.incrementarUno();
//Incrementa en uno las pulsaciones del botón btnContador
Método decrementarUno:
Permite decrementar en uno las
pulsaciones que tiene un botón.
btnContador.decrementarUno();
//Decrementa en uno las pulsaciones del botón btnContador
Método reiniciar:
Permite colocar las pulsaciones de
un botón a cero.
btnContador.reiniciar();
//Sitúa a cero las pulsaciones del botón btnContador
Método incrementarVarios:
Permite aumentar en una determinada
cantidad las pulsaciones del botón.
btnContador.incrementarVarios(4);
//Aumenta en cuatro las pulsaciones del botón btnContador
Método decrementarVarios:
Permite disminuir en una
determinada cantidad las pulsaciones del botón.
btnContador.decrementarVarios(6);
//Disminuye en 6 las pulsaciones del botón btnContador
Los botones de este tipo tendrían
una propiedad llamada pulsaciones de tipo entera que se
inicializaría a cero en el momento de construir el botón.
Desgraciadamente no existe un botón de este tipo en Java,
así que no podemos acudir a la ventana de diseño y añadir un botón como este.
Una posibilidad sería la de
programar la clase correspondiente a un botón de este tipo desde cero, pero
esto es un trabajo tremendamente complejo.
La solución a este problema es la Herencia. Básicamentela Clase JButton
La idea es crear una nueva clase a
partir de la clase JButton. A esta nueva clase la llamaremos BotonContador y haremos que herede de
la clase JButton. Por tanto, la clase BotonContador
tendrá todas las características de los JButton y además le añadiremos los
métodos mencionados antes.
Gracias a la herencia, nuestra
clase BotonContador poseerá todos los métodos de los JButton
(setText,
getText,
setForeground,
setToolTipText,
etc.) sin que tengamos que programar estos métodos.
Por otro lado, añadiremos a la
clase BotonContador nuestros propios métodos (setPulsaciones, getPulsaciones,
etc) y propiedades para que la clase esté preparada para nuestras necesidades.
Resumiendo:
programaremos un botón propio, con características necesarias para nuestro
trabajo, aprovechando las características de un botón JButton.
Programación de la Clase BotonContador:
Creación de la clase derivada:
La programación de la clase
derivada BotonContador se hará en un fichero aparte, al igual que la
programación de las clases de creación propia.
Se comenzará definiendo el comienzo
de la clase y añadiendo las llaves que limitan su contenido:
public
class BotonContador extends JButton {
}
Observa el código añadido: extends JButton antes
de la llave de apertura. Este es el código que le permite indicar a Java que
nuestra clase BotonContador derivará de la clase JButton.
Creación de las propiedades de la clase derivada:
La clase BotonContador es una
clase derivada de la clase JButton, y tendrá las mismas
propiedades que la clase JButton, pero a nosotros nos interesa añadir nuestras
propias propiedades. En nuestro caso, necesitaremos una variable que contenga
el número de pulsaciones del botón en todo momento.
public
class BotonContador extends JButton {
int pulsaciones;
}
Inicialización de las propiedades de la clase
derivada:
Nuestra propiedad pulsaciones
debe ser inicializada en el constructor de la clase. Para ello crea el
constructor de la clase:
public
class BotonContador extends JButton {
int pulsaciones;
public BotonContador() {
pulsaciones = 0;
}
}
Añadir métodos propios a la clase derivada:
Se añadirán los nuevos métodos que
queremos que la clase BotonContador posea. Estos son los
siguientes:
setPulsaciones - asigna un número de pulsaciones al
botón.
getPulsaciones - devuelve el número de pulsaciones
del botón.
incrementarUno - suma uno a las pulsaciones del botón
decrementarUno - resta uno a las pulsaciones del
botón
reiniciar - pone a cero las pulsaciones del
botón
incrementarVarios - suma
una cantidad las pulsaciones del botón.
decrementarVarios - resta una cantidad las pulsaciones
del botón.
Estos métodos trabajan con la
propiedad pulsaciones. Una vez programados estos métodos, la clase
quedará de la siguiente forma (observa la programación de los distintos métodos
para entenderlos):
public
class BotonContador extends JButton {
//propiedades
int pulsaciones;
//constructor
public BotonContador() {
pulsaciones = 0;
}
//métodos
//asigna
una cantidad de pulsaciones
public void setPulsaciones(int p) {
pulsaciones = p;
}
//devuelve
las pulsaciones del botón
public int getPulsaciones() {
return pulsaciones;
}
//incrementa
en uno las pulsaciones
public void incrementarUno() {
pulsaciones++;
}
//decrementa
en uno las pulsaciones
public void decrementarUno() {
pulsaciones--;
}
//pone
las pulsaciones a cero
public void reiniciar() {
pulsaciones = 0;
}
//aumenta
las pulsaciones en una cantidad c
public void incrementarVarios(int c) {
pulsaciones = pulsaciones + c;
}
//disminuye las
pulsaciones en una cantidad c
public void decrementarVarios(int c) {
pulsaciones = pulsaciones - c;
}
}
Como has podido observar, la
creación de una clase heredada es exactamente igual que la creación de una
clase propia. La única diferencia es que hacemos que dicha clase herede de otra
clase ya existente, dándole más posibilidades sin necesidad de programar nada:
public
class BotonContador extends JButton {
Uso de la clase
BotonContador:
Usaremos la clase BotonContador
en un simple proyecto de prueba para que puedas observar sus posibilidades.
Para ello, sigue los pasos que se
indican a continuación:
- Crea un proyecto llamado Botones Contadores,
que tenga un paquete principal
llamado paquetePrincipal y un JFrame
llamado VentanaPrincipal:
- Añadiremos la Clase BotonContador. Para
ello debes hacer clic derecho sobre el paquetePrincipal y
activar la opción Nuevo à Clase
Java. El nombre de la clase es BotonContador:
- Antes de empezar con el diseño de la ventana
principal programa la clase BotonContador. Debes hacer
doble clic sobre el fichero BotonContador.java e introducir
en él la clase BotonContador que hemos diseñado anteriormente usando
herencia.
El fichero BotonContador.java
debería quedar así:
/*
* To change this
license header, choose License Headers in Project Properties.
* To change this
template file, choose Tools | Templates
* and open the
template in the editor.
*/
package
paquetePrincipal;
import
javax.swing.JButton;
/**
*
* @author Edwin
Amado
*/
public
class BotonContador extends JButton {
//propiedades
int pulsaciones;
//constructor
public BotonContador() {
pulsaciones = 0;
}
//métodos
//asigna una
cantidad de pulsaciones
public void setPulsaciones(int p) {
pulsaciones = p;
}
//devuelve las
pulsaciones del botón
public int getPulsaciones() {
return pulsaciones;
}
//incrementa en
uno las pulsaciones
public void incrementarUno() {
pulsaciones++;
}
//decrementa en
uno las pulsaciones
public void decrementarUno() {
pulsaciones--;
}
//pone las
pulsaciones a cero
public void reiniciar() {
pulsaciones = 0;
}
//aumenta las
pulsaciones en una cantidad c
public void incrementarVarios(int c) {
pulsaciones = pulsaciones + c;
}
//disminuye las
pulsaciones en una cantidad c
public void decrementarVarios(int c) {
pulsaciones = pulsaciones - c;
}
}
- Ahora programaremos el diseño de la ventana principal.
Lo haremos desde código. Entra en el módulo VentanaPrincipal.java
(haciendo doble click en él) y pasa a la zona de código:
- En la zona de código programaremos el típico
método creacionVentana, llamado desde el constructor, donde se
programará el diseño de la ventana:
- Nuestro programa tendrá dos botones del tipo BotonContador.
Declara estos botones como variables globales de la clase:
- En el método creacionVentana
definiremos características de la ventana y construiremos estos botones y
los situaremos en la ventana:
- Como puedes ver, los botones contadores se construyen
igual que los JButton; y, de hecho, tienen los mismos métodos que los
JButton, ya que derivan de ellos. Así pues, un botón contador tiene un
método setText, setBounds, etc…
- Ejecuta el programa y observa el resultado.
Verás que en la ventana aparecen los dos botones contadores, sin embargo,
observarás que tienen el mismo aspecto que los JButton. Se vuelve a indicar
que esto es debido a que la clase BotonContador deriva de la
clase JButton.
- Ahora se añadirá un actionPerformed a
cada botón contador, para controlar sus pulsaciones. Añade al final
(dentro del método creacionVentana) el siguiente
código ya conocido, para la asignación de eventos actionPerformed a
los botones:
- Se tendrán que programar los métodos de
respuesta a los eventos, que aquí se han llamado pulsacionBotonA y pulsacionBotonB.
Prográmalos (fuera de creacionVentana) de la siguiente
forma:
- Cada vez que se pulse el Botón A, debería
aumentar su contador interno de pulsaciones en uno. Lo mismo debería pasar
con el Botón B. Esto se hace fácilmente usando el método incrementarUno,
propio de nuestros botones contadores:
- Resumiendo, cada vez que se pulsa el Botón
A, se le da la orden al Botón A de que incremente su
contador interno. Lo mismo sucede con el Botón B.
- Ahora programaremos dos botones más en la
ventana, pero estos serán botones normales y los crearemos desde la
ventana de diseño, para facilitar la tarea. Estos botones se llamarán btnVerPulsaciones
y btnReiniciar.
- Cuando se pulse el botón Ver Pulsaciones
debería aparecer un JOptionPane
indicando cuantas veces se ha pulsado el Botón A y cuantas el B.
Esto se hará simplemente pidiendo a cada botón su número de pulsaciones
almacenadas.
Accede al actionPerformed
del botón Ver Pulsaciones y programa lo siguiente:
En este botón le
pedimos al Botón A que nos diga
cuantas pulsaciones tiene anotadas (a través del método getPulsaciones) y lo
mismo hacemos con el Botón B. Esto
es posible ya que ambos botones son del tipo BotonContador, la clase
heredada que hemos programado.
- Ejecuta el programa y prueba lo siguiente:
-
Pulsa varias veces el Botón A y el B. Verás
que no sucede nada (aunque internamente cada uno de los botones está guardando
el número de pulsaciones en su propiedad pulsaciones)
-
Pulsa ahora el botón Ver Pulsaciones y
comprobarás como este botón te muestra las veces que pulsaste cada botón.
- Ahora programaremos el botón Reiniciar
de forma que los contadores internos de ambos botones A y B se pongan a cero.
- Accede al actionPerformed del botón Reiniciar y programa lo siguiente:
- Puedes comprobar el funcionamiento de este
botón ejecutando el programa y pulsando varias veces los botones
A y B. Luego mira las pulsaciones almacenadas en ambos
botones. Pulsa el botón Reiniciar y comprueba las
pulsaciones de nuevo. Deberían ser cero en ambos botones.
EJERCICIO
Se propone al lector que añada las
siguientes modificaciones al programa:
-
Añade desde código un nuevo botón Botón
C (de tipo BotonContador) que al pulsarse aumente su número de pulsaciones
interno en 2 (usa el método incrementarVarios propio de la clase BotonContador).
-
Cuando se pulse el botón Ver Pulsaciones también
debería verse el número de pulsaciones del Botón C.
-
Cuando se pulse Reiniciar, el número de
pulsaciones del Botón C debería situarse a cero también.
-
Añade desde diseño un cuadro de texto (llamado txtNumero)
y un botón normal (JButton) llamado btnIniciar. En el cuadro de texto se
introducirá un número, y al pulsar el botón btnIniciar, los valores
internos de los tres botones A, B y C se inicializarán al
número introducido:
CONCLUSIONES:
La clase inicial se denomina clase Base y la clase nueva creada a partir
de la clase base se llama clase Derivada:
Se puede hacer que una clase de creación propia derive o herede de otra
ya existente añadiendo:
extends NombreClaseBase
en la línea de creación de la clase.
La clase creada así obtendrá características de la clase de la que
hereda.
Aparte, esta clase tendrá métodos propios añadidos por el programador.
No hay comentarios.:
Publicar un comentario