interfaces are just contracts or signatures and they don't know anything about implementations.

coding against interface means, the client code always holds an interface object which is supplied by a factory. any instance returned by the factory would be of type interface which any factory candidate class must have implemented. this way the client program is not worried about implementation and the interface signature determines what all operations can be done. this can be used to change the behavior of a program at run-time. it also helps you to write far better programs from the maintenance point of view.

here's a basic example for you.

public enum language
{
    english, german, spanish
}

public class speakerfactory
{
    public static ispeaker createspeaker(language language)
    {
        switch (language)
        {
            case language.english:
                return new englishspeaker();
            case language.german:
                return new germanspeaker();
            case language.spanish:
                return new spanishspeaker();
            default:
                throw new applicationexception("no speaker can speak such language");
        }
    }
}

[stathread]
static void main()
{
    //this is your client code.
    ispeaker speaker = speakerfactory.createspeaker(language.english);
    speaker.speak();
    console.readline();
}

public interface ispeaker
{
    void speak();
}

public class englishspeaker : ispeaker
{
    public englishspeaker() { }

    #region ispeaker members

    public void speak()
    {
        console.writeline("i speak english.");
    }

    #endregion
}

public class germanspeaker : ispeaker
{
    public germanspeaker() { }

    #region ispeaker members

    public void speak()
    {
        console.writeline("i speak german.");
    }

    #endregion
}

public class spanishspeaker : ispeaker
{
    public spanishspeaker() { }

    #region ispeaker members

    public void speak()
    {
        console.writeline("i speak spanish.");
    }

    #endregion
}

this is just a basic example and actual explanation of the principle is beyond the scope of this answer.

edit

i have updated the example above and added an abstract speaker base class. in this update, i added a feature to all speakers to "sayhello". all speaker speak "hello world". so that's a common feature with similar function. refer to the class diagram and you'll find that speaker abstract class implement ispeaker interface and marks the speak() as abstract which means that the each speaker implementation is responsible for implementing the speak() method since it varies from speaker to speaker. but all speaker say "hello" unanimously. so in the abstract speaker class we define a method that says "hello world" and each speaker implementation will derive the sayhello() method.

consider a case where spanishspeaker cannot say hello so in that case you can override the sayhello() method for spanish speaker and raise proper exception.

please note that, we have not made any changes to interface ispeaker. and the client code and speakerfactory also remain unaffected unchanged. and this is what we achieve by programming-to-interface.

and we could achieve this behavior by simply adding a base abstract class speaker and some minor modification in each implementation thus leaving the original program unchanged. this is a desired feature of any application and it makes your application easily maintainable.

public enum language
{
    english, german, spanish
}

public class speakerfactory
{
    public static ispeaker createspeaker(language language)
    {
        switch (language)
        {
            case language.english:
                return new englishspeaker();
            case language.german:
                return new germanspeaker();
            case language.spanish:
                return new spanishspeaker();
            default:
                throw new applicationexception("no speaker can speak such language");
        }
    }
}

class program
{
    [stathread]
    static void main()
    {
        //this is your client code.
        ispeaker speaker = speakerfactory.createspeaker(language.english);
        speaker.speak();
        console.readline();
    }
}

public interface ispeaker
{
    void speak();
}

public abstract class speaker : ispeaker
{

    #region ispeaker members

    public abstract void speak();

    public virtual void sayhello()
    {
        console.writeline("hello world.");
    }

    #endregion
}

public class englishspeaker : speaker
{
    public englishspeaker() { }

    #region ispeaker members

    public override void speak()
    {
        this.sayhello();
        console.writeline("i speak english.");
    }

    #endregion
}

public class germanspeaker : speaker
{
    public germanspeaker() { }

    #region ispeaker members

    public override void speak()
    {
        console.writeline("i speak german.");
        this.sayhello();
    }

    #endregion
}

public class spanishspeaker : speaker
{
    public spanishspeaker() { }

    #region ispeaker members

    public override void speak()
    {
        console.writeline("i speak spanish.");
    }

    public override void sayhello()
    {
        throw new applicationexception("i cannot say hello world.");
    }

    #endregion
}