Interfejsy a dziedziczenie

Dzień dobry,
Temat będzie podstawowy. Mam problem ze zrozumieniem istoty interfejsów. Może podam przykład:

 
class Program
    {
        class pierwsza
        {
            private int _a;
            public pierwsza(int a)
            {
                _a = a;
            }
            public int dodaj(int b)
            {
                return _a+b;
            }
        }

        class druga : pierwsza, Iwyswietlanie
        {
            private int _c;
            public druga(int a, int c) : base(a)
            {
                _c = c;
            }
            public int odejmij(int d)
            {
                return _c - d;
            }
        }

        interface Iwyswietlanie
        {
            void wyswietl(int liczba);
        }

        class wyswietlanie : Iwyswietlanie
        {
            public void wyswietl(int liczba)
            {
                Console.WriteLine(liczba);
                Console.ReadKey();
            }
        }
        static void Main(string[] args)
        {
            druga t = new druga(1, 2);
            t.wyswietl(t.dodaj(3) + t.odejmij(4));
        }
    }

mam dwie klasy Pierwsza i Druga. Druga dziedziczy z Pierwszej. I teraz ideałem byłoby gdyby klasa Druga mogla skorzystać z metody Wyświetl klasy Wyświetlanie. Spróbowałem wykorzystać do tego interfejs ale on wymaga ode mnie implementacji tej metody wewnątrz klasy Drugiej. Myślę, że czegoś tutaj nie rozumiem. Mogę prosić o drobne naprowadzenie?

Pozdrawiam,
Zoritt

Interfejs wymusza tylko, że dana metoda musi być zaimplementowana, nie wymusza sposobu jej implementacji. Samo zaimplementowanie "IWyswietlanie" nie spowoduje, że będzie można użyć tej metody z innej klasy.

To, co chcesz uzyskać, to wielodziedziczenie, dziedziczenie z wielu klas. Nie da się tego osiągnąć w C#.

Zadeklaruj metodę wyswietl() klasy wyswietlanie jako statyczną (i samą klasę pewnie też), a w klasie druga będziesz mógł użyć wyswietlanie.wyswietl().

Włóż do klasy obiekt typu wyświetlanie i deleguj metody do niego. IDE powinno automatycznie wygenerować metody delegujące, tzn jakimś kreatorem. Tak jest przynajmniej w NetBeans :P

Metody statyczne mają tę wadę że nie da się ich dziedziczyć. Przynajmniej w Javie, nie wiem jak w C#.

OK. Dzięki za odpowiedzi.
Jeżeli pozwolicie podam jeszcze jeden przykład:

 
public interface Iwyswietl
   {
       void wyswietl();
   }

   class pierwsza : Iwyswietl
   {
       private int _a;
       public pierwsza(int a)
       {
           _a = a;
       }
       public void wyswietl()
       {
           Console.WriteLine(_a);
       }
   }
   class druga : Iwyswietl
   {
       private int _a;
       public druga(int a)
       {
           _a = a;
       }
       public void wyswietl()
       {
           Console.WriteLine(_a);
       }
   }

   class Program
   {
       static void Main(string[] args)
       {
           pierwsza jeden = new pierwsza(3);
           druga dwa = new druga(4);
           jeden.wyswietl();
           dwa.wyswietl();
           Console.ReadKey();
       }
   }

Problem jest taki, że usunięcie interfejsu z tego programu nie spowoduje zmiany działania. Mówiąc krótko jest on tutaj zupełnie zbędny. Wręcz dublowanie metody Wyswietl - niekorzystne. Przykład całkowicie dowodzi, że zupełnie nie czuje gdzie jest ukryta siła interfejsów. A przez skórę czuję, że gdzieś by mi się przydały ;-)

Pozdrawiam,
Zoritt

Zamiast:

pierwsza jeden = new pierwsza(3);
druga dwa = new druga(4);

daj:

Iwyswietl jeden = new pierwsza(3);
Iwyswietl dwa = new druga(4);

I wtedy korzystasz z interfejsów.

Dublują się implementacje? A pisałem przecież o delegatach. W klasie pierwsza czy druga daj w środku pole

Iwyswietl delegat = new wyswietl;

Zostaw implementacje interfejsów, a w implementacji metody wyswietl daj:

public void wyswietl() { delegat.wyswietl() }

Ewentualnie możesz po prostu tutaj zastosować pojedyńcze dziedziczenie. C# pozwala dziedziczyć z jednej klasy i nieskończonej liczby interfejsów.

Znajdziesz chwile czasu aby rozwinąć myśl dotyczącą zastosowania w tym przykładzie delegatów? Zdaje się, że wędka była za krótka ponieważ dokonałem kilku prób zastosowania i niestety zero ryby :-)

Pozdrawiam,
Zoritt

Kod w Javie, ale możesz go sobie łatwo przepisać do C#:

import java.util.ArrayList;
import java.util.List;


interface Obiekt {
    boolean czyMebel();
}

class Mebel implements Obiekt {
    public boolean czyMebel() {
        return true;
    }
}

class Pojazd implements Obiekt {
    public boolean czyMebel() {
        return false;
    }
}

interface Oznaczony {
    String pobierzNazwę();
}

class KrzesłoDziedziczące extends Mebel implements Oznaczony {
    public String pobierzNazwę() {
        return "KrzesłoDziedziczące";
    }
}

class StolikDziedziczący extends Mebel implements Oznaczony {
    public String pobierzNazwę() {
        return "StolikDziedziczący";
    }
}

class KrzesłoZDelegatem implements Obiekt, Oznaczony {
    private Mebel delegat = new Mebel();

    public boolean czyMebel() {
        return delegat.czyMebel();
    }

    public String pobierzNazwę() {
        return "KrzesłoZDelegatem";
    }
}

class StolikZDelegatem implements Obiekt, Oznaczony {
    private Mebel delegat = new Mebel();

    public boolean czyMebel() {
        return delegat.czyMebel();
    }

    public String pobierzNazwę() {
        return "StolikZDelegatem";
    }
}

public class Main {

    public static void main(String[] args) {
        List<Obiekt> obiekty = new ArrayList<Obiekt>();
        obiekty.add(new Mebel());
        obiekty.add(new Pojazd());
        obiekty.add(new KrzesłoDziedziczące());
        obiekty.add(new KrzesłoZDelegatem());
        obiekty.add(new StolikDziedziczący());
        obiekty.add(new StolikZDelegatem());
        for (Obiekt obiekt : obiekty) {
            System.out.println("Wypisuję kolejny obiekt.");
            System.out.println("Nazwa klasy to: " + obiekt.getClass().getName());
            System.out.println("Tak klasa " + (obiekt.czyMebel() ? "jest" : "nie jest") + " meblem.");
            if (obiekt instanceof Oznaczony) {
                System.out.println("Obiekt przedstawia się jako: " + ((Oznaczony) obiekt).pobierzNazwę());
            }
            System.out.println();
        }
    }
}

Tu masz:

• delegaty,
• dziedziczenie plus implementowanie interfejsu,
• implementowanie wielu interfejsów,
• wykorzystanie interfejsów (w metodzie main),

Dzięki wielkie. Zaraz sobie przeanalizuje :-)

Pozdrawiam,
Zoritt

Delegowana metoda to oczywiście czyMebel(). Przykład kiepski trochę (mało sugestywny), bo mało funkcjonalności jest delegowane. Kod możesz sobie wrzucić na ideone.com jeśli nie masz IDE do Javy.