Cargando

Ir a contenido


 


Java/Spring – Programando a interfaces

Este tutorial está dirigido a aquellos que conocen el lenguaje de programación Java y quieren expandir un poco en los conceptos que dominan.


Escrito por el jul 14 2014 19:45 java spring


Esta es la tercera parte de una serie de tutoriales enfocados en repasar los temas básicos del lenguaje Java para preparar al lector en el uso del Framework Spring. La primera parte de esta serie de tutoriales se puede conseguir aquí y la segunda parte se puede conseguir aquí. En este tutorial estaremos hablando de qué son las interfaces, qué es programar a interfaces, sus ventajas y cómo se relaciona con el Framework Spring.

¿Qué son las interfaces?


Ya hemos visto los conceptos de herencia y polimorfismo y las interfaces son un tipo de clase Java que se caracteriza por representar una funcionalidad particular. En su forma más común, las interfaces son una clase compuesta por métodos sin implementación.

interface Dibujable {
	
	 public void dibujar();
	 public void elegirColor(String color);
}

Las interfaces son siempre públicas y abstractas sin importar si colocas los modificadores o no y representan la manera en la que otros objetos interactúan con el objeto que la implementa. Puede sonar complicado pero es sencillo, cuando una clase implementa una interface está obligada a darle un cuerpo a los métodos que corresponden. Esto quiere decir que mientras un objeto implemente una interface puedes estar enteramente seguro que dicho objeto tiene los métodos correspondientes a la interface mencionada.

En Java, las interfaces se implementan con la palabra clave “implements” y una clase puede implementar una o varias interfaces pero está obligada a sobrecargar los métodos correspondientes a cada interface sin excepción o si no el compilador va a arrojar un error.


public class Cuadrado implements Dibujable {
	
	 public String colorDeBorde;
	 public String colorDeRelleno;
	 public int alto;
	 public int ancho;
	
	 @Override
	 public void dibujar() {
			 System.out.println("Se dibuja un cuadrado de ancho "+ancho+", alto "+alto+" y color "+colorDeRelleno);
	 }

	 @Override
	 public void elegirColor(String color) {
			 colorDeRelleno=color;
	 }

}

public class Linea implements Dibujable {
	 public String colordetrazo;
	 public String largo;

	 @Override
	 public void dibujar() {
			 System.out.println("Se dibuja una línea de "+largo);
	 }

	 @Override
	 public void elegirColor(String color) {
			 colordetrazo = color;
	 }

}

En este caso la interface te permite manipular sin problema cualquier cantidad de Objetos empleando el concepto de polimorfismo que vimos en la segunda parte y estos objetos no tienen que estar intrínsecamente relacionados entre sí más que por la forma en la que otras clases interactúan con ellos. En el caso de nuestro ejemplo podrías tener posteriormente objetos pentágono, paisaje o incluso ObraDeArte que implementen la interface Dibujable y todos podrían ser manejados por cualquier clase que pueda manipular la interface Dibujable.

import java.awt.Color;
import java.util.*;

public class DibujarCosas {

//Esta clase genera objetos dibujables al azar y los dibuja de colores al azar
public static void main(String[] args) {
			 List<Dibujable> l= new ArrayList<Dibujable>();
			 for (int i = 0; i<10; i++) {
				 if (Math.random() >0.5) {
						 l.add(new Linea());
				 }else {
						 l.add(new Cuadrado());
				 }
			 }
			 for (Dibujable d:l) {
				 float H, S, B;
				 H = (float)Math.random();
				 S = (float)Math.random();
				 B = (float)Math.random();
				 Color c = Color.getHSBColor(H, S, <img src='http://www.solvetic.com/public/style_emoticons/default/cool.png' class='bbc_emoticon' alt='B)' />;
				 d.elegirColor(String.valueOf(c));
				 d.dibujar();
			 }
	 }
}

Como verás en el ejemplo, el método principal se puede separar en 2 métodos principales, el que llena la Lista de objetos Dibujables y el que dibuja los objetos de la lista. Te invito a que uses estas clases y veas cómo se comportan antes de pasar a la siguiente sección donde veremos por qué podrías querer programar a la interface.

Al final una interface es igual a su contraparte real, tu teclado y tu mouse son las interfaces con las que interactúas con tu computadora, los detalles internos de cómo se llevan a cabo cosas como “Hacer Click” o “Presionar la tecla Esc” desde la interfaz a tu computadora están ocultos de ti y no son necesarios para ti. Lo único que importa es que puedes presionar la tecla Esc y hacer Click empleando dicha interface.


Programando a interfaces


Una vez revisado lo que es una interface, espero que puedas comprender lo importante que puede llegar a ser programar a una. Esencialmente te enfocas en crear tus programas pensando en la interface que vas a usar y no tanto en el objeto que te pasarían por parámetro. En el caso del ejemplo que hemos manejado hasta ahora se puede rescribir de la siguiente manera:

import java.awt.Color;
import java.util.*;

public class DibujarCosas {

	 //Esta clase genera objetos dibujables al azar y los dibuja de colores al azar
	 public static void main(String[] args) {
			 List<Dibujable> l= new ArrayList<Dibujable>();
			 llenarLista(l);
			 dibujarLista(l);
	 }
	 public static void llenarLista(List<Dibujable> l) {
			 for (int i = 0; i<10; i++) {
				 if (Math.random() >0.5) {
						 l.add(new Linea());
				 }else {
						 l.add(new Cuadrado());
				 }
			 }
	 }
	
	 public static void dibujarLista(List<Dibujable> l) {
			 for (Dibujable d:l) {
				 float H, S, B;
				 H = (float)Math.random();
				 S = (float)Math.random();
				 B = (float)Math.random();
				 Color c = Color.getHSBColor(H, S, <img src='http://www.solvetic.com/public/style_emoticons/default/cool.png' class='bbc_emoticon' alt='B)' />;
				 d.elegirColor(String.valueOf(c));
				 d.dibujar();
			 }
	 }
}

Ciertamente sólo separé las partes del método principal en los 2 métodos secundarios pero lo hermoso de esto es que esos 2 métodos mantienen independencia uno del otro y mantienen independencia de las implementaciones de la interface Dibujable. Si yo quisiera cambiar uno de los 2 métodos el otro no se vería afectado en lo más mínimo, si llegaran a aparecer las implementaciones Pentágono y ObraDeArte las podrías agregar en el proceso de creación del método llenarLista(List<Dibujable> l) y el método dibujarLista(List<Dibujable> l) no requeriría ningún cambio porque ha sido programado a interface.

+ Importante
Es que ambos métodos pueden pertenecer a clases distintas, pueden manejarse en ambientes distintos e incluso pueden nunca llegar a saber qué objeto están manejando realmente pero, siempre y cuando implementen la interface Dibujable van a poder manipularlo y van a poder ejecutar los 2 métodos que están asociados a esa interfaz.


Sé que parece terriblemente complicado en este momento pero más adelante veremos cómo hace Spring para manejar todo programado a una interface e incluso veremos cómo programar orientado a aspectos y entender esto nos va a ayudar muchísimo para comprender el funcionamiento de Spring.

Espero que continuemos con estos tutoriales semana a semana, no olviden dejar sus comentarios ¡hasta la próxima!
¿Te ha gustado y ayudado este Tutorial?
Puedes premiar al autor pulsando este botón para darle un punto positivo
  • -
  • 0
-
VOTA
5
0%
4
0%
3
0%
2
0%
1
0%

  Información

  •   Publicado jul 14 2014 19:45
  •   Actualizado jul 14 2014 21:12
  •   Visitas 850
  •   Nivel
    Profesional



Tutoriales Relacionados


Sin comentarios, sé el primero!

No esperes más y entra en Solvetic
Deja tus comentarios y aprovecha las ventajas de la cuenta de usuario ¡Únete!
Demuestra que eres experto!
  ESCRIBIR TUTORIAL
Suscribirse