sencillos - que es una interface de java
DeberÃas siempre codificar a las interfaces en Java (6)
En general, estoy de acuerdo con las otras respuestas: utilice una interfaz cuando sepa o anticipe un cambio y / o una implementación diferente, o vaya a prueba.
Pero no siempre es fácil saber de antemano qué puede cambiar en el futuro, especialmente si no tienes tanta experiencia. Creo que la solución para ese problema es la refactorización: mantenerlo simple (= sin interfaz), siempre que no sea necesario. Cuando surja la necesidad, simplemente realice una refactorización de "Introducir / Extraer interfaz" (compatible con casi todos los IDEs decentes).
Cuando lo haces, extrae solo los métodos que realmente necesitan los llamadores. No tema extraer más de una interfaz por separado (si no todos los métodos extraídos son realmente coherentes).
Un controlador de la refactorización podría ser la prueba: si no puede probar fácilmente algo con clases, solo considere la introducción de una / algunas interfaces. Esto también le permitirá usar burlas, lo que puede simplificar enormemente las pruebas en muchos casos.
Editar: basado en el comentario de Tarski, realicé un escenario / ajuste más importante a las declaraciones anteriores:
Si proporciona una API externa (para otros [sub] proyectos, o realmente la lanza "al azar"), el uso de interfaces en la API (excepto para las clases de valor simple) es casi siempre una buena idea.
Le permitirá cambiar la impl si lo desea sin alterar el código del cliente. Tendrá un problema solo si también tiene que cambiar la interfaz. No romper la compatibilidad será muy complicado (si no imposible).
Entiendo los principios de Codificación a Interfaces: desacoplar la implementación de la interfaz y permitir que las implementaciones de la interfaz se intercambien dentro y fuera.
¿Debo codificar a las interfaces para cada clase que escribo o es esa exageración ? No quiero duplicar la cantidad de archivos fuente en un proyecto a menos que realmente valga la pena.
¿Qué factores puedo usar para decidir si codigo por interfaz o no?
Larga historia corta, no. Usted es el creador de la aplicación, por lo que tiene una buena idea de lo que podría cambiar. Algunos de los libros de patrones de diseño se vuelven un poco locos, en mi opinión, ya que parece que siempre impulsan el diseño a las interfaces y no a la implementación, pase lo que pase. A veces, es exagerado. Para mi última aplicación (tamaño pequeño), tengo una interfaz de base de datos porque creo que hay una posibilidad de que más adelante lo transfiera a la web y cambie a MySQL. Por supuesto, en realidad, sería fácil crear una interfaz de base de datos en el camino de mi clase existente y simplemente agregar "implementa myDbInterface" más tarde con un par de pequeños cambios. Esto funciona porque yo soy el único desarrollador. En un equipo más grande, o en un tipo diferente de producto, puede ser una respuesta diferente. Solo use su mejor criterio (después de leer todas las buenas respuestas de SO por supuesto).
Lo uso cuando al menos uno de los siguientes es verdadero:
1) Quiero desacoplar módulos / clases no relacionadas entre sí, y quiero que se refleje en las dependencias del paquete java.
2) Cuando el desacoplamiento es importante en términos de dependencias de construcción
3) Cuando la implementación puede cambiar a través de la configuración o dinámicamente en el tiempo de ejecución (generalmente debido a algún patrón de diseño)
4) Cuando quiero que una clase sea comprobable, hago sus "puntos de enlace" a las interfaces de recursos externos, para que pueda usar implementaciones simuladas.
5) Menos común: cuando quiero tener una opción para restringir el acceso a alguna clase. En este caso, mi método devuelve una interfaz en lugar de la clase real, por lo que la persona que llama sabe que no espero que haga otras operaciones en el valor devuelto.
Me gusta pensar que uno usa interfaces cuando la capacidad de conexión y la posibilidad de un comportamiento diferente es importante. Los servicios son el ajuste perfecto. Uno podría querer una implementación predeterminada, pero la falsificación (burla), etc. es otra. Esto obviamente significa que debe haber un intf ya que siempre habrá al menos 2 formas.
Los tipos de valor, por otro lado, deberían ser clases finales. Nunca deberían extenderse. Los tipos de valor incluyen algo como suburbio, MimeType. Si hay variaciones de estos, usa la composición. Como objetivo, intento poner poco comportamiento, si hay alguno en mis tipos de valores. Validar el tipo simple que envuelve, etc. es probablemente lo más complejo que hace. Por ejemplo, una clase de color que toma r / g / b debería validar que cada componente está entre 0 y 255 y eso es todo.
No, todas las clases no deberían tener una interfaz. Es excesivo al cuadrado.
Utiliza una interfaz cuando necesita abstraer lo que se hace de cómo se hace, y está seguro de que la implementación puede cambiar.
Eche un vistazo a la API de colecciones de java.util para ver un buen ejemplo. La interfaz de la Lista es una bonita abstracción para la idea general de una Lista, pero puede ver que hay muchas formas de implementarla: ArrayList, LinkedList, etc.
ACTUALIZACIÓN: ¿Y qué pasa con el caso en el que se diseña una clase concreta, se decide después de tener clientes que se necesita una interfaz y se rompe a los clientes al agregar una interfaz? Sí, eso es lo que sucede. ¿Cómo puedes saber lo que no sabes? Ningún software o metodología puede arreglar eso.
La buena noticia para usted es que extraer una interfaz de una clase concreta es una fácil refactorización para usted y para sus clientes. Los IDE manejan ese tipo de cosas rutinariamente. Usted y sus clientes deben aprovecharlos.
Yo diría que las capas, como los servicios y la persistencia, siempre deberían tener interfaces. Cualquier cosa que pueda ser proxiada debe tener una interfaz. Si está haciendo Spring AOP, cualquier cosa que desee decorar con un aspecto debe tener una interfaz.
Los objetos modelo o de valor, como Persona o Dirección o Teléfono, no deberían tener una interfaz. Un objeto de valor inmutable no debe tener una interfaz.
El resto cae en áreas grises. Usa tu mejor juicio.
Sí, use la interfaz cuando espera que cambie un comportamiento. . En el futuro.
O su clase que puede manejar los cambios de manera clara.
p.ej.
public static void main(String s[])
{
Employee e1=new Employee(new Salesman());
Employee e2=new Employee(new Manager());
system.out.println(e1.performaction());
system.out.println(e1.performaction());
}
Class Employee
{
//which changes frequently
Authority a;
public Employee(Authority a)
{
this.a=a;
}
public String performAction()
{
a.action();
}
}
// ------------------------------------------------ ------------------
interface Authority
{
public String action();
}
class Manager implements Authority
{
public String action()
{
returns "I manages People";
}
class SalesMan implements Authority
{
public String action()
{
returns "I Sell things Company makes ";
}
}