IMPLEMENTACIÓN E INTERFAZ EN NETBEANS
Definición:
Un interface es una colección de
definiciones de métodos (sin implementaciones) y de valores constantes.
|
Los
interfaces se utilizan para definir un protocolo de comportamiento que puede
ser implementado por cualquier clase del árbol de clases.Los
interfaces son útiles para.
·
capturar similitudes entre clases no relacionadas
sin forzar una relación entre ellas.
·
declarar métodos que una o varias clases necesitan
implementar.
·
revelar el interface de programación de un objeto
sin recelar sus clases (los objetos de este tipo son llamados objetos anónimos
y pueden ser útiles cuando compartas un paquete de clases con otros
desarrolladores).
En Java, un
interface es un tipo de dato de referencia, y por tanto, puede utilizarse en
muchos de los sitios donde se pueda utilizar cualquier tipo (como en un
argumento de métodos y una declaración de variables).
Los Interfaces No Proporcionan Herencia MúltipleAlgunas veces
se trata a los interfaces como una alternativa a la herencia múltiple en las
clases. A pesar de que los interfaces podrían resolver algunos problemas de la
herencia múltiple, son animales bastantes diferentes. En particular.
·
No se pueden heredar variables desde un interface.
·
No se pueden heredar implementaciones de métodos
desde un interface.
·
La herencia de un interface es independiente de la
herencia de la clase--las clases que implementan el mismo interface pueden o no
estar relacionadas a través del árbol de clases.
Definir un
InterfacePara crear un
Interface, se debe escribir tanto la declaración como el cuerpo del interface.declaraciondeInterface {
cuerpodeInterface} La Declaración de Interface declara varios atributos del interface, como su nombre o si se
extiende desde otro interface. El Cuerpo de Interface contiene las constantes y las declaraciones de métodos del
Interface.
Como mínimo, una
declaración de interface contiene la palabra clave interface y el nombre del
interface que se va a crear.
interface Contable {
. . .
}
Una declaración de
interface puede tener otros dos componentes: el especificador de accesopublic y una lista de "superinterfaces". Un interface puede
extender otros interfaces como una clase puede extender o subclasificar otra
case. Sin embargo, mientras que una clase sólo puede extender una superclase,
los interfaces pueden extender de cualquier número de interfaces. Así, una
declaración completa de interface se parecería a esto.
[public] interface Nombredenterface [extends listadeSuperInterfaces] {
. . .
}
El especificador de
acceso public indica que el
interface puede ser utilizado por todas las clases en cualquier paquete. Si el
interface no se especifica como público, sólo será accesible para las clases
definidas en el mismo paquete que el interface.
La clausula extends es similar a la
utilizada en la declaración de una clase, sin embargo, un interface puede
extender varios interfaces (mientras una clase sólo puede extender una), y un
interface no puede extender clases. Esta lista de superinterfaces es un lista
delimitada por comas de todos los interfaces extendidos por el nuevo interface.
Un interface hereda
todas las constantes y métodos de sus superinterfaces a menos que el interface
oculte una constante con el mismo nombre o redeclare un método con una nueva
declaración.
El cuerpo del
interface contiene las declaraciones de métodos para los métodos definidos en
el interface. Implementar
Métodos muestra cómo
escribir una declaración de método. Además de las declaraciones de los métodos,
un interface puede contener declaraciones de constantes. En Declarar
Variables Miembros existe más
información sobre cómo construir una declaración de una variable miembro.
Todos los valores
constantes definidos en un interface son implícitamente públicos, estáticos y
finales. El uso de estos modificadores en una declaración de constante en un
interface está desaconsejado por falta de estilo. Similarmente, todos los
métodos declarados en un interface son implícitamente públicos y abstractos.
Este código define
un nuevo interface llamado coleccion que contiene un valor constante y tres
declaraciones de métodos.
interface coleccion {
int MAXIMO = 500;
void añadir(Object obj);
void borrar(Object obj);
Object buscar(Object obj);
int contadorActual();
}
El interface
anterior puede ser implementado por cualquier clase que represente una colección
de objetos como pueden ser pilas, vectores, enlaces, etc...
Observa que cada
declaración de método está seguida por un punto y coma (;) porque un interface
no proporciona implementación para los métodos declarados dentro de él.
Utilizar
un Interface
Para utilizar un
interface se debe escribir una clase que lo implemente. Una clase declara todos
los interfaces que implementa en su declaración de clase. Para declarar que una
clase implementa uno o más interfaces, se utiliza la palabra clave implements seguida por una lista delimitada por
comas con los interfaces implementados por la clase.
Por ejemplo,
consideremos el interface coleccion presentado en la página anterior.
Ahora, supongamos que queremos escribir una clase que implemente un pila FIFO
(primero en entrar, primero en salir). Como una pila FIFO contiene otros
objetos tiene sentido que implemente el interface coleccion. La clase PilaFIFO
declara que implementa el interface coleccion de esta forma.
class PilaFIFO implements coleccion {
. . .
void añadir(Object obj) {
. . .
}
void borrar(Object obj) {
. . .
}
Object buscar(Object obj) {
. . .
}
int contadorActual() {
. . .
}
}
así se garantiza que
proporciona implementación para los métodos añadir(), borrar(), buscar()y contadorActual().
Por convención, la
clausula implements sigue a la clausula extends si es que ésta existe.
Observa que las
firmas de los métodos del interface coleccion implementados en la clase
PilaFIFO debe corresponder exactamente con las firmas de los métodos declarados
en la interface coleccion.
1. Confeccionar un
programa que muestre 3 objetos de la clase JRadioButton que permitan configurar
el ancho y alto del JFrame.
Importamos los dos
paquetes donde están definidas las clases e interfaces para la captura de
eventos:
import javax.swing.*;
import javax.swing.event.*;
//Heredamos de la clase
JFrame e implementamos la interface ChangeListener para capturar el cambio de
selección de objeto de tipo JRadioButton:
public class Formulario
extends JFrame implements ChangeListener{
//Definimos tres objetos de
la clase JRadioButton y uno de tipo ButtonGroup:
private JRadioButton radio1,radio2,radio3;
private ButtonGroup bg;
//En el constructor creamos
primero el objeto de la clase ButtonGroup:
bg=new ButtonGroup();
//Creamos seguidamente el
objeto de la clase JRadioButton, definimos su ubicación, llamamos al método
addChangeListener para informar que objeto capturará el evento y finalmente
añadimos el objeto JRadioButton al JFrame y al ButtonGroup:
radio1=new JRadioButton("640*480");
radio1.setBounds(10,20,100,30);
radio1.addChangeListener(this);
add(radio1);
bg.add(radio1);
//Exactamente hacemos lo
mismo con los otros dos JRadioButton:
radio2=new
JRadioButton("800*600");
radio2.setBounds(10,70,100,30);
radio2.addChangeListener(this);
add(radio2);
bg.add(radio2);
radio3=new
JRadioButton("1024*768");
radio3.setBounds(10,120,100,30);
radio3.addChangeListener(this);
add(radio3);
bg.add(radio3);
//En el método stateChanged
verificamos cual de los tres JRadioButton está seleccionado y procedemos a
redimensionar el JFrame:
public void stateChanged(ChangeEvent e) {
if (radio1.isSelected()) {
setSize(640,480);
}
if (radio2.isSelected()) {
setSize(800,600);
}
if (radio3.isSelected()) {
setSize(1024,768);
}
}
Ejecutamos el programa:
Podemos observar que al elegir un RadioButton, cambia las dimensiones indicadas en el interfaz .
|
