En la Programación, una interfaz define el comportamiento que tendrá un objeto, pero en realidad no especificará el comportamiento. Es un contrato, que garantizará, que cierta clase puede hacer algo.
consideran este pedazo de código C# aquí:
using System;
public interface IGenerate
{
int Generate();
}
// Dependencies
public class KnownNumber : IGenerate
{
public int Generate()
{
return 5;
}
}
public class SecretNumber : IGenerate
{
public int Generate()
{
return new Random().Next(0, 10);
}
}
// What you care about
class Game
{
public Game(IGenerate generator)
{
Console.WriteLine(generator.Generate())
}
}
new Game(new SecretNumber());
new Game(new KnownNumber());
La clase de juego requiere un número secreto. Para probarlo, le gustaría inyectar lo que se usará como un número secreto (este principio se llama Inversion of Control).
La clase de juego quiere ser "de mente abierta" sobre lo que realmente creará el número aleatorio, por lo tanto, pedirá en su constructor "cualquier cosa, que tenga un método Generate".
En primer lugar, la interfaz especifica qué operaciones proporcionará un objeto. Simplemente contiene lo que parece, pero no se proporciona una implementación real. Esta es solo la firma del método. Convencionalmente, en las interfaces C# se agrega el prefijo I. Las clases ahora implementan la interfaz IGenerate. Esto significa que el compilador se asegurará de que ambos tengan un método que devuelva un int y se llame Generate
. El juego ahora se llama dos objetos diferentes, cada uno de los cuales implementa la interfaz correcta. Otras clases producirían un error al construir el código.
Aquí me di cuenta de la analogía modelo que utilizó:
Una clase es visto comúnmente como un modelo para un objeto. Una interfaz especifica algo que una clase debe hacer, por lo que se podría argumentar que, de hecho, es solo un modelo para una clase, pero dado que una clase no necesita necesariamente una interfaz, diría que esta metáfora se está rompiendo. Piensa en una interfaz como un contrato. La clase que lo "firme" será legalmente requerida (exigida por la policía del compilador) para cumplir con los términos y condiciones del contrato. Esto significa que tendrá que hacer, lo que se especifica en la interfaz.
Todo esto se debe a la naturaleza estática de algunos de los lenguajes OO, como es el caso de Java o C#. En Python, por otro lado, se usa otro mecanismo:
import random
# Dependencies
class KnownNumber(object):
def generate(self):
return 5
class SecretNumber(object):
def generate(self):
return random.randint(0,10)
# What you care about
class SecretGame(object):
def __init__(self, number_generator):
number = number_generator.generate()
print number
Aquí, ninguna de las clases implementa una interfaz. A Python no le importa eso, porque la clase SecretGame
simplemente intentará llamar a cualquier objeto que se pase. Si el objeto TIENE un método generate(), todo está bien. Si no es así: ¡KAPUTT! Este error no se verá en tiempo de compilación, pero en tiempo de ejecución, por lo tanto, posiblemente cuando su programa ya esté implementado y en ejecución. C# te avisaría mucho antes de que te acercaras a eso.
La razón por la que se utiliza este mecanismo, ingenuamente, porque en los lenguajes OO, naturalmente, las funciones no son ciudadanos de primera clase. Como puede ver, KnownNumber
y SecretNumber
contienen SÓLO las funciones para generar un número. Uno realmente no necesita las clases en absoluto. En Python, por lo tanto, uno podría simplemente tirar a la basura y recoger las funciones por sí solas:
# OO Approach
SecretGame(SecretNumber())
SecretGame(KnownNumber())
# Functional Approach
# Dependencies
class SecretGame(object):
def __init__(self, generate):
number = generate()
print number
SecretGame(lambda: random.randint(0,10))
SecretGame(lambda: 5)
Un lambda es sólo una función, que fue declarado "en línea, a medida que avanza". Un delegado es el mismo en C#:
class Game
{
public Game(Func<int> generate)
{
Console.WriteLine(generate())
}
}
new Game(() => 5);
new Game(() => new Random().Next(0, 10));
Los últimos ejemplos no son posibles como este en Java, ya que Java no puede sacudir alrededor con funciones como los otros dos (Python y C#) lata.Allí, las interfaces son su única forma de comportamiento específico de esta manera en av.
no es una tontería, pero arroja mucha luz sobre esta pregunta: http://stackoverflow.com/questions/444245/how-will-i-know-when-to-create-an-interface – rmeador
Lo haría dicen que es una palabra genérica, pero aún significa lo mismo para mí. Es como un muro para una entidad particular o una entidad más abstracta que proporciona algunos puntos de entrada al exterior y les da salida sin ningún conocimiento de las operaciones internas. Creo que se puede llamar como una abstracción para definir clases de menor a mayor nivel en OOP. – ikbal