Capítulo VI: "Arreglos en Java"
Los arreglos en Java son dinámicos, pero no
extensibles, lo cual significa que deben ser creados con el
tamaño que tendrán hasta el final de su
vida.
Un arreglo se declara de la siguiente forma:
<tipo>[] <nombre>;
O sea, para declarar, por ejemplo, un arreglo de
números enteros utilizaremos la siguiente
sentencia:
int[] arrInt;
Es importante notar que el arreglo aún no ha sido
creado, sino meramente declarado. Para crear el arreglo (reservar
su memoria e
inicializarlo) deberemos recurrir al operador
new:
arrInt = new int[10];
Este comportamiento
debe comprenderse de esta forma: en Java todo es un objeto, y los
objetos deben ser creados mediante el operador new. El caso de
los arreglos no es diferente, el tipo de datos del arreglo
(int[] en este caso) es una clase y cada
una de sus instancias debe ser creada explícitamente, el
tamaño puede pensarse como un parámetro al
constructor de la clase.
A partir de este momento podemos utilizar arrInt como un
arreglo de cualquier otro lenguaje.
Una de las características que hacen de Java un
entorno de programación seguro, y que se
relaciona con el manejo de los arreglos es que el lenguaje no
permite la indexación de arreglos fuera de rango, o sea,
una asignación de este tipo generará una
excepción:
ArrInt[25] = 1;
Otra forma de declararlos es la siguiente:
UNIDIMENSIONALES:
tipo nombre_array[]=new tipo[nº];
tipo nombre_array[]={valores};
BIDIMENSIONALES:
tipo nombre_array[][]=new
tipo[nº][nº];
tipo nombre_array[][]={valores};
Ejemplo 6.1
Se sabe que la velocidad de
un proyectil está dada por la ecuación, en forma
vectorial: V= ai+ bj+ ck.
Diseñe una aplicación que sea capaz de leer
los valores
de las constantes a, b y c. y muestre la magnitud y dirección de dicho proyectil.
1 import javax.swing.*;
2 public class
Proyectil{
3
public static void
main (String args []){
4 String leer;
5 double
magnitud, direccion, sum;
6 double
vector[]=new
double[3];
7 int
ban=1;
8
while(ban==1)//miestras hayan datos a procesar
9 {
10 //leemos el valor de las
constantes
11
leer=JOptionPane.showInputDialog("Ingrese el valor de
a:");
12
vector[0]=Double.parseDouble(leer);
13
leer=JOptionPane.showInputDialog("Ingrese el valor de
b:");
14
vector[1]=Double.parseDouble(leer);
15
leer=JOptionPane.showInputDialog("Ingrese el valor de
c:");
16
vector[2]=Double.parseDouble(leer);
17
//calculamos la
magnitud
18
//la cual es la raíz
cuadrada de las suma+
19
//de las componentes al
cuadrado
20
sum=(vector[0]*vector[0])+(vector[1]*vector[1])+(vector[2]*vector[2]);
21
magnitud=Math.sqrt(sum);
22 //La
dirección viene dada por la tangente
inversa
23
//del cociente de las componentes
x,y
24
direccion=Math.atan(vector[1]/vector[0]);
25
JOptionPane.showMessageDialog(null, "El
valor de la magnitud es:
"+magnitud+"n y con
un angulo direccional de:
"+direccion+"
Radianes");
26
leer=JOptionPane.showInputDialog("¿Hay más datos a procesar?nnSi=1 y
No=0");
27
ban=Integer.parseInt(leer);
28 }//del
while
29
}//del
main
30
}//de la clase
Ejemplo 6.2
Se tienen las notas de 5 exámenes de 10
alumnos, y se desea promediar la nota final de cada uno de
ellos. Diseñe una aplicación que solucione este
problema.
1 import javax.swing.*;
2 public class
MatrizNotas{
3
public static void
main (String args []) {
4 int
f,c;
5
double suma,
promedio;
6
double notas
[][]=new double[10][5];
7 String leer;
8 for(f=0;
f<10; f++)//las
filas
9
{
10
suma=0;
11
for(c=0; c<5;
c++)
12
{
13
leer=JOptionPane.showInputDialog("Ingrese la nota:
"+c+" del alumno:
"+f);
14
notas[f][c]=Double.parseDouble(leer);
15
while(notas[f][c]>10 ||
notas [f][c]<0)
16
{
17
leer=JOptionPane.showInputDialog("Ingrese la nota:
"+c+" del alumno:
"+f);
18
notas[f][c]=Double.parseDouble(leer);
19
}
20
suma=suma+notas[f][c];
21 }
22
promedio=suma/5;
23
JOptionPane.showMessageDialog(null, "El
alumno, tiene un promedio de:
"+promedio);
24 }
25 }
26 }
27
Algunas de sus características más
importantes de los arrays son las
siguientes:
1. Los arrays se crean con el operador new
seguido del tipo y número de elementos.
2. Se puede acceder al número de elementos de un
array con la variable miembro implícita length (por
ejemplo, vect.length).
3. Se accede a los elementos de un array con los
corchetes [] y un índice que varía de
length-1.
4. Se pueden crear arrays de objetos de cualquier
tipo. En principio un array de objetos es un array de
referencias que hay que completar llamando al operador
new.
5. Los elementos de un array se inicializan al
valor por defecto del tipo correspondiente (cero para valores
numéricos, el carácter nulo para char,
false para boolean, null para Strings
y para referencias).
6. Como todos los objetos, los arrays se pasan
como argumentos a los métodos
por referencia.
7. Se pueden crear arrays anónimos (por
ejemplo, crear un nuevo array como argumento actual en la llamada
a un método).
Inicialización de
arrays:
1. Los arrays se pueden inicializar con valores
entre llaves {…} separados por comas.
2. También los arrays de objetos se pueden
inicializar con varias llamadas a new dentro de unas
llaves {…}.
3. Si se igualan dos referencias a un array no se copia
el array, sino que se tiene un array con dos nombres, apuntando
al mismo y único objeto.
4. Creación de una referencia a un array.
Son posibles dos formas:
double[] x; // preferible
double x[];
5. Creación del array con el operador
new:
x = new double[100];
6. Las dos etapas 4 y 5 se pueden unir en una
sola:
double[] x = new double[100];
Preguntas
- ¿Qué es un arreglo, array, matriz o
vector?________________________________________________________________________________________________________________________ - ¿Par que sirve el operador new, al momento de
declarar un
arreglo?_________________________________________________________________________________________________________________________ - ¿Cuáles son las diferencias entre un
arreglo de una dimensión y dos
dimensiones?____________________________________________________________________________________________________________________ - Mencione dos de las características más
releventes de los
arryas?_________________________________________________________________________________________________________________________
Descubre el error
A continuación se presentan una serie de
códigos los cuales pueden poseer alguna clase de error,
puedes identificarlos y corregirlos???
- int v = new int[10];
v[i]=i+5;
- for(int i=0; i<10, i++);
- int [][] mat = new int();
4. int [] b = {{1, 2, 3}, {4, 5, 6}, };// esta coma es
permitida
Ejercicios
- Diseñe un programa que
guarde los 10 números dígitos y luego los imprima
en forma ascendente y descendente. Usando, para ello, un
arreglo de una dimensión. - Dibuje, en un Applet, el nombre más grande de
cierta cantidad de alumnos en una escuela.
Cuyos datos están almacenados en arreglo de
cadenas. - Diseñe una aplicación en java, que lea
un vector de 10 posiciones y luego, muestre un mensaje en la
pantalla, indicando la cantidad de ceros que hay en el arreglo.
La cantidad de cifras positivas y la cantidad de cifras
negativas. - En un vector de 20 posiciones se almacenan los
sueldos de n empleados, de los cuales se desea saber, cuantos
empleados ganan más del mínimo (sueldo
mínimo: $160.00), cuántos ganan menos que el
sueldo mínimo. - Realice una búsqueda binaria en un arreglo
unidimensional. Una búsqueda binaria, es de la siguinte
forma: se lee el valor que se desea buscar, se compara la
primera posición, si son iguales, fin de la
búsqueda; de lo contrario, compararlo con la
posición dos, y así sucesivamente, si se llega al
final del arreglo y no se encontró el valor, se debe
indicar con una leyenda. Pero si se encuentra, se debe
especificar la posición, que ese valor ocupa en el
arreglo. - diseñe una matriz en Java, de 6*6 elementos, y
luego muestre, la suma de sus filas, y columnas por
separado. - Se desea crear un Applet, el cual sea capaz de leer
una matriz de 5*6, y luego determine si la suma de la diagonal
es mayor que la suma de la diagonal menor, además que
dibuje estos valores, junto con los elementos de la matriz en
el fondo del Applet. - Se desea saber la suma y la multiplicación de
dos matrices A y
B, cada una con m*n elementos. - Dibuje una matriz de 3*3 elementos en un Applet y
simule, y luego encuentre su determinante, por el método
de Sarros, el cual consiste el aumentarle a la matriz original
la primera y segunda columna, luego multiplicar en diagonal,
cambiando de signo los productos
realizados de arriba hacia abajo. Posteriormente se suman todos
los productos y el resultado es el determinante.
Capítulo VII: Clases en Java
Al fin!!!… lo que hasta el capítulo anterior,
pareciera que hayamos estado
repasando el lenguaje
C/C++, puesto que Java, posee mucho de estos lenguajes. Pero
nos estamos adentrando a la esencia de la Programación
Orientadaza o Objetos.
Un programa se construye a partir de un conjunto de
clases.
Una vez definida e implementada una clase, es posible
declarar elementos de esta clase de modo similar a como se
declaran las variables del
lenguaje (de los tipos primitivos int, double,
String, …). Los elementos declarados de una clase
se denominan objetos de la clase. De una única
clase se pueden declarar o crear numerosos objetos. La
clase es lo genérico: es el patrón o
modelo para
crear objetos.
Cada objeto tiene sus propias copias de las variables
miembro, con sus propios valores, en general distintos de los
demás objetos de la clase. Las clases pueden tener
variables static, que son propias de la clase y no de cada
objeto.
- Conceptos Claves
Una clase es una agrupación de
datos (variables o campos) y de funciones
(métodos) que operan sobre esos datos. A estos datos y
funciones
pertenecientes a una clase se les denomina variables y
métodos o funciones miembro. La
programación orientada a objetos se basa en la
programación de clases.
Una clase es una agrupación de datos
(variables o campos) y de funciones (métodos) que
operan sobre esos datos. La definición de una clase se
realiza en la siguiente forma:
[public] class Classname { //lo de public es
opcional
// definición de variables y
métodos
…
}
donde la palabra public es opcional: si no se
pone, la clase tiene la visibilidad por defecto, esto es,
sólo es visible para las demás clases del
package. Todos los métodos y variables deben ser
definidos dentro del bloque {…} de la clase.
Un objeto (en inglés,
instance) es un ejemplar concreto de
una clase. Las clases son como tipos de variables,
mientras que los objetos son como variables concretas de
un tipo determinado.
Classname unObjeto;
Classname otroObjeto;
A continuación se enumeran algunas
características importantes de las clases:
1. Todas las variables y funciones de Java deben
pertenecer a una clase. No hay variables y funciones
globales.
2. Si una clase deriva de otra (extends), hereda
todas sus variables y métodos.
3. Java tiene una jerarquía de clases
estándar de la que pueden derivar las clases que crean los
usuarios.
Una clase sólo puede heredar de una única
clase (en Java no hay herencia
múltiple). Si al definir una clase no se especifica de
qué clase deriva, por defecto la clase deriva de
Object. La clase Object es la base de toda la
jerarquía de clases de Java.
5. En un fichero se pueden definir varias clases, pero
en un fichero no puede haber más que una clase
public. Este fichero se debe llamar como la clase
public que contiene con extensión *.java.
Con algunas excepciones, lo habitual es escribir una sola clase
por fichero.
6. Si una clase contenida en un fichero no es
public, no es necesario que el fichero se llame como la
clase.
7. Los métodos de una clase pueden referirse de
modo global al objeto de esa clase al que se aplican por
medio de la referencia this.
8. Las clases se pueden agrupar en packages,
introduciendo una línea al comienzo del fichero
(package packageName;). Esta agrupación en
packages está relacionada con la jerarquía
de directorios y ficheros en la que se guardan las
clases.
Para la creación de un objeto se necesita el
operador new, y que se declaren las variables de instancia dentro
de una clase. Mediante una clase se pueden declarar varios
objetos que tendrán los mismos atributos.
Creación de Un Objeto
nomb_clase nomb_objeto=new
nomb_clase([valores]);
Cuando se hace referencia a un método este debe
estar declarado y desarrollado al igual que el objeto. Para
declarar y desarrollar un método debe estar dentro de una
clase y se debe indicar el valor que devuelve, el nombre y los
valores que se le pasan.
Definición de los
Métodos
valor devuelto
nombre_método([valores])
{
cuerpo;
}
Si tenemos que hacer referencia a las variables de
instancia y los métodos contenidos en un objeto se
necesita el operador punto(.).
Objeto.nomb_método( );
Objeto.nomb_método(valores);
Objeto.variable;
Veamos un Ejemplo para ilustrar lo que se ha
dicho:
Ejemplo 7.1
Diseñe una Clase, para crear objetos del tipo
Alumnos, en el cual, permita ingresar el nombre, edad y Nota de
ciertos objetos de ese tipo.
Solución:
- Digite el siguiente código
1 /*Archivo
Alumnos.Java*/
2
import
javax.swing.*;
3
public class Alumnos{
4 //declaración de
los atributos
5
public String
Nombre;
6
public int Edad;
7 public double
Nota;
8
9 //declaración de los
métodos
10
public void
EstablecerNombre()
11 {
12
Nombre=JOptionPane.showInputDialog("Ingrese el nombre:
");
13
}
14
public void EstablecerEdad(int x)
15 {
16 Edad=x;//el valor recibido lo asigna a
Edad
17
}
18
public void EstablecerNota(double y)
19 {
20 Nota=y;
21 }
22 /*Este
método, muestra todos los
datos del
23 del objeto en pantalla*/
24 public void
MostrarDatos()
25
{
26
String salida="Nombre del Alumno:
"+Nombre+"nEdad:
"+Edad+"nNota:
"+Nota;
27
JOptionPane.showMessageDialog(null, salida);
28 }
29 }
2. Luego guarde el archivo, Compílelo, pero NO lo
ejecute. Con esto estamos creando nuestra Clase, con la cual,
podremos construir Objetos de este tipo.
3. Ahora, y en otro archivo digite las siguientes
sentencias:
1 /*Archivo
UsaAlumnos.java*/
2 class UsaAlumnos{
3 public
static void main (String args []) {
4 //declaramos
y creamos un objeto del tipo Alumnos
5 Alumnos Datos=new Alumnos();
6 //LLamamos a los
métodos
7
Datos.EstablecerNombre();
8 Datos.EstablecerEdad(20);
9
Datos.EstablecerNota(9.5);
10
11 //Ahora mostramos los
Datos
12
Datos.MostrarDatos();
13 }
14 }
4. Luego Guarde el archivo, Compílelo y
Ejecútelo.
Explicación.
En el ejemplo anterior puede notar que, los atributos,
son esas variables simples, es las cuales almacenaremos información relevante a los objetos que,
crearemos a partir de esa clase.
Además que, los estamos declarando como
públicos, lo cual indica que tenemos acceso directo desde
cualquier otro archivo a los atributos. Los métodos son
del tipo public y no devuelven ningún valor, por
tal razón son declarados como void. Además
que. El método EstablecerEdad y EstablecerNota, reciben un
argumento cada uno de ellos, el cual es asignado al respectivo
atributo.
- Constructores
Un Constructor es una función,
método, etc, de las clases, la cual es llamada
automáticamente cuando se crea un objeto de esa
clase.
Por ser métodos, los constructores también
aceptan parámetros. Cuando en una clase no especificamos
ningún tipo de constructor, el compilador añade uno
público por omisión sin parámetros, el cual
NO hace nada.
Características de los
Constructores
- Un constructor, tiene el mismo nombre de la clase a
la cual pertenece. - No puede ser Heredado.
- No retorna ningún valor (Ni void), por lo cual
no debe especificarse ningún tipo de dato. - Debe declararse como public, sólo en casos
realmente extraordinarios será de otro tipo.
Supongamos una clase llamada Datos
public class Datos
{
//declaracion de
atributos
public Datos();//constructor sin
parametros
public Datos(int Edad)
{//Constructor con
parámetros
EdadM=Edad;
}
}
Ejemplo 7.2
Se Desea crear un objeto del tipo Coordenadas, que
indique, la posición de un punto en el plano cartesiano, y
permita calcular la distancia existente con otro punto,
además del punto medio entre ellos.
1 /*Archivo
Coordenadas.java*/
2
3 public class Coordenadas {
4 private int
x,y;//Atributos
5 public Coordenadas (int x1 , int y1)//constructor
6
{
7
//asignamos esos
valores
8
x=x1;
9
y=y1;
10
}
11
public double Distancia (int x1, int y1)
12 {
13 //este
método recibe como parametros
14 //las
coordenadas del segundo punto
15 double D;
16
D=Math.sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1));
17 return D;//Retornamops el valor de la
distancia
18
}
19
public void Pmedio(int x1, int y1)
20 {
21 double p1, p2;
22 p1=(x+x1)/2;
23 p2=(y+y1)/2;
24
System.out.println("El puntomedio
es: "+p1+","+p2);
25 }
26 }
1 /*Archivo
UsaCoordenadas.java*/
2
public class UsaCoordenadas {
3 public static
void main (String args
[]){
4 Coordenadas
P=new Coordenadas
(10,20);
5
//calculamos la Distancia:
6
System.out.println("La Distancia es:
"+P.Distancia(5,6));
7 //Punto
Medio
8
P.Pmedio(5,6);
9
}
10 }
Explicación:
Un método, si va a devolver algún valor,
éste debe especificarse cuando se hace la
definición del mismo, para el caso, el método
Distancia, devuelve el valor de la distancia, es por ello que lo
especificamos como public double. Además que,
cuando realizamos la llamada de ese método, es en ese
preciso lugar que aparecerá el valor que devuelve. Por
otra parte, los atributos, son de acceso privado, lo cual implica
que, sólo podemos acceder a ellos, en la clase
Coordenadas.
- Sobrecarga
Cuando en una clase, se definen un mismo método,
con diferente número de parámetros, o bien con el
mismo numero de parámetros pero diferenciándose en
la definición, en la cual, al menos un parámetro
sea de diferente tipo, cuando esto sucede, se dice que el
método está sobrecargado.
Ejemplo 7.3
Cree una aplicación en Java, que imprima un
número imaginario. Nota, los números imaginarios,
poseen una parte real y otra imaginaria, acompañada por la
constante i.
1 class Imaginario {
2 private
int real, imag;
3 public Imaginario()
4 {
5 real=0;
6 imag=0;
7 }
8 public Imaginario(int x, int y)
9 {
10 real=x;
11 imag=y;
12 }
13 public void
Mostrar()
14
{
15
System.out.println("El Numero
Imaginario es: "+real+"
+ "+imag+"i");
16 }
17 }
1 class
UsaImaginario{
2
public static void
main (String args []) {
3 Imaginario oI=new
Imaginario(5,6);
4
oI.Mostrar();
5
}
6
}
Preguntas
- ¿Que es y para que sirven las
Clases?___________________________________________________________________________________________________________________________ - ¿Cuál es la diferencia entre las
sentencia public y
private?________________________________________________________________________________________________________________ - ¿Qué es un
constructor?___________________________________________________________________________________________________________ - Mencione dos características de los
constructores:_________________________________________________________________________________________________________________________________ - ¿Por qué, la clase a partir de la cual
creamos los objetos y la clase que la utiliza, deben estar en
el mismo
directorio?_________________________________________________________________________________________________________________________________________________
Descubre el error
1. class punto{
Public int x;
Private int y;
void punto( )
{x=10;y=20;}
}
- punto p=new Punto( );
- System.out.printl(p.X + " "+p.Y);
- public punto(int , int ){x=a;y=b;}
5. punto(int a, int b){a=x; y=b;}
punto(){a=-1;b=-1;}
Ejercicios
- Diseñe Una clase que permita crear Objetos del
tipo Perros. La cual
almacene información pertinente al nombre, raza y peso
de cierta cantidad de Perros. - Se desea crear un programa que lea dos números
imaginarios, y luego imprima: la suma, resta y
multiplicación de ellos. (La parte real se suma con la
parte real, la parte imaginaria con la parte imaginaria, y
así para la resta y multiplicación). - Diseñe una mini-Agenda, en la cual usted
guarde los datos personales (nombre, teléfono y e-mail) de sus amigos. Haga
uso, para ello de un Arreglo de referencias a objetos del tipo
Agenda(). - Diseñe una clase en Java, llamada Leer(), la
cual devuelva una cadena que el usuario haya ingresado por
separado, y luego las concatene, dejendo un espacio entre
ellas. Ejemplo=str1=Manuel; str2=Ortez à Cadena=Manuel Ortez. - Cree un Objeto del tipo Fecha(), el cual recibe como
argumentos, el día, mes y año. Y luego imprima
esos Datos. - Se desea crear un objeto del tipo Moneda, el cual
realice el cambio de
colones a dólares (1 colón=8.75 dólares).
Al ingresar una cantidad en colones imprima la respectiva
equivalencia el dólares, pero solo con DOS
decimales.
Capitulo VIII: Paquetes, Interfaces y
Herencia
8.1 Paquetes (Packages)
Un package es una agrupación de clases. En
la API de Java 1.1 había 22 packages; en
Java 1.2 hay 59 packages, lo que da una idea del
"crecimiento" experimentado por el lenguaje. Además, el
usuario puede crear sus propios packages. Para que una
clase pase a formar parte de un package llamado
pkgName, hay que introducir en ella la
sentencia:
package pkgName;
que debe ser la primera sentencia del fichero sin contar
comentarios y líneas en blanco.
Los nombres de los packages se suelen escribir
con minúsculas, para distinguirlos de las clases, que
empiezan por mayúscula. El nombre de un package
puede constar de varios nombres unidos por puntos (los propios
packages de Java siguen esta norma, como por
ejemplo java.awt.event). Todas las clases que forman parte
de un package deben estar en el mismo directorio. Los
nombres compuestos de los packages están
relacionados con la jerarquía de directorios en que se
guardan las clases. Es recomendable que los nombres de las
clases de Java sean únicos en Internet.
Es el nombre del package lo que permite obtener esta
característica. Una forma de conseguirlo es incluir el
nombre del
dominio (quitando quizás el país),
como por ejemplo en el package siguiente:
es.ceit.jgjalon.infor2.ordenar
Las clases de un package se almacenan en un
directorio con el mismo nombre largo (path) que el
package. Por ejemplo, la clase,
es.ceit.jgjalon.infor2.ordenar.QuickSort.class
debería estar en el directorio,
CLASSPATHesceitjgjaloninfor2ordenarQuickSort.class
donde CLASSPATH es una variable de entorno del PC que
establece la posición absoluta de los directorios en los
que hay clases de Java (clases del sistema o de
usuario), en este caso la posición del directorio
es en los discos locales del ordenador.
Pasos Para Crear un Paquete
- Seleccionar el Nombre de Paquete. Ejemplo:
MiPaquete.es; misClases.Utilidades. Para ello cree una carpeta
llamada Ejemplo, en el disco
duro. - Crear una estructura
Jerárquica de carpetas en el disco duro. Esta estructura
jerárquica se hace corresponder con una estructura en el
disco duro con una estructura jerárquica de carpetas, de
tal forma que los nombres de las carpetas coinciden con los
nombres de los elementos del paquete. (Para ello, dentro de la
carpeta Ejemplo, cree una carpeta llamada MIsClases, y dentro
de ella, una llamada es) Lo cual se especifica con la variable
CLASSPATH. Para nuestro ejemplo, la variable CLASSPATH debe
indicar, entre otras, la ruta de la carpeta MisClases. En
JGRASP en Settings escoger Path/Classpath luego escoger la
carpeta CLASSPATH. - Copie en esta carpeta (Carpeta es) los archivos
correspondientes a Alumnos.java, Coordenadas.java e
Imaginario.java (los cuales han sido creados en el
capítulo anterior).package MisClases.es;
- Modifique estos archivos, colocándoles a cada
uno de ellos la instrucción: - vuélvalos a compilar.
- Luego copie el archivo que utiliza la clase
Coordenadas.java (Nos referimos al archivo
UsaCoordendas.java). este archivo puede guardarlo en la
dirección: C:Ejemplo.import MisClases.es.Coordenadas;
- Modifique este archivo colocándole la
sentencia:Con lo Anterior ya hemos creado, nuestro primer
paquete, lo cual, es de manera similar, que Java controla,
los paquetes que dispone para la realización de
nuestros programas.
- Interfaces
- Vuélvalo a Compilar y
Ejecútelo.
Una interfaz, pareceriera que no tiene ningún
tipo de aplicación o implementación, dentro de los
programas que, creamos en Java. Sin embargo no es así. Ya
que, una interfaz indica, como será la "apariencia", que
la clase tendrá. Además que, establece cierto
"protocolo" entre
las clases.
Para declarar una clase haremos uso de la palabra
reservada interface (la cual sustituye a la palabra
class).
Y para implementar la interfaz, haremos uso de la
palabra reservada implements la cual debe especificarse,
al momento de declarar la clase que, implementará dicha
interfaz.
Ejemplo:
Supongamos que queremos crear un programa que, dadas la
base y la altura de un rectángulo, nos devuelva su area,
su perímetro y su volumen. Pero
haciendo uso de una interfaz.
Solución:
- En archivo nuevo digite el siguiente código:
1 //declaración de la
interfaz
2 public interface
Calculos {
3
public double Perimetro();//calcula el Perímetro
4 public double
Area();//calcula
Area
5
public double Volumen();//calcula el volumen
6 }//fin de
la interfaz
2. Guarde este archivo y compílelo.
3. En otro archivo digite el siguiente
código:
1 //Declaración de la clase que implementa la
Interfaz Calculos
2
public class Rectangulo extends Object implements Calculos{
3 private double
base, altura;
4
public
Rectangulo()//constructor
5
{
6
base=0;
7
altura=0;
8
}
9
//establece la base
10 public void
AignarBase(double
x)
11
{
12
base=x;
13
}
14
//estabece el valor de la
altura
15
public void AsignarAltura(double y)
16 {
17 altura=y;
18 }
19 //Calculamos el Perímetro
20 public double
Perimetro()
21
{
22
return
2*base+2*altura;
23
}
24
//calculamos el
area
25
public double Area()
26 {
27 return base*altura;
28 }
29 public double
Volumen()
30
{
31
double
espesor=5;
32
return
base*altura*espesor;
33 }
34 }
4. Guarde y compile.
5. Ahora digite, en otro archivo, la siguiente secuencia
de código:
1 //vamos a
probar la clase
2
//y la interfaz
3 import
javax.swing.*;
4
import
java.text.DecimalFormat;//para
que los resultados
5
//se muestren con decimales
6 public class
PruebaRect {
7
public static void
main (String args []) {
8 double
a,b,c;
9
String salida;
10
DecimalFormat df=new
DecimalFormat(".00");
11 //creamos
el objeto, que contenga sólo dos
decimales
12
Rectangulo rect=new
Rectangulo();
13
14
//Dimenciones del
rectangulo:
15
rect.AsignarBase(8.5);
16
rect.AsignarAltura(10.98);
17
18 //calculos
19
a=rect.Perimetro();
20 b=rect.Area();
21
c=rect.Volumen();
22
23
//impresión
24 salida="El rectangulo, tiene un perímetro de:
"+df.format(a)+"nUn
area de: "+df.format(b)+"nY un volumen de:
"+df.format(c);
25
JOptionPane.showMessageDialog(null, salida);
26 }
6. Guárdelo, compílelo y
ejecútelo.
Quizá el lector piense que, una interfaz no tiene
mayor uso, y a lo mejor, ni se perciba su funcionamiento y mucho
menos su implementación. Y siendo franco, al principio, ni
yo entendía el por que usar una interfaz. Sin embargo Las
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 la 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 se comparte un paquete de clases con otros
desarrolladores). El objetivo de
definir interfaces es permitir una mayor abstracción de
datos, por ejemplo, permitiendo que un método reciba un
objeto de una instancia de alguna clase que implementa una
interface, de modo que pueda invocarse a un método
definido en esta, aunque no se conozca la clase real que se
está utilizando.
 Página anterior | Volver al principio del trabajo | Página siguiente  |