Programowanie obiektowe przyniosło wiele nowych wynalazków, najbardziej docenionym są oczywiście klasy i obiekty. Zapewne wielu z Was zadaje sobie pytanie:
"Ok, skoro mamy klasy, z których możemy tworzyć obiekty, możemy sobie dziedziczyć itd, to co to są te interfejsy i po co właściwie musiałbym ich używać?"
Postaram się odpowiedzieć na to pytanie.
O Interfejsach w C# słów kilka
Pamiętam jeszcze podczas studiów, jak zdarzało się kiedy studenci interfejsem określali "okienko z przyciskami i polami, nazywanymi fachowo kontrolkami" :) Oczywiście winforms czy WPF jest "interfejsem użytkownika", natomiast służy do czegoś innego niż "interfejs dla programisty" :)
Interfejs jest czymś w rodzaju klasy. Wewnątrz interfejsu znajdują się metody (
ale bez ich oprogramowania!) jakie obsługuje.
Niewątpliwie zaletą interfejsów jest fakt, że
klasa może dziedziczyć po wielu interfejsach.
Interfejsy implementujemy podobnie jak klasy, zastępując słowo kluczowe
class słowem interface.
Jak to bez implementacji metod? W takim razie po co? są od tego metody w klasie...
Jak już wcześniej wspomniałem, interfejs zawiera wyłącznie nazwy metod, których nie implementuje. Sama implementacja metody odbywa się po stronie klasy, która dziedziczy po interfejsie/interfejsach.
Najprościej mówiąc:
Interfejs mówi, CO na pewno ma robić klasa (jakie czynności powinna realizować, jakie metody udostępniać).
Metoda mówi JAK daną czynność wykonać.
Interfejs jest swojego rodzaju inspektorem, który mówi programiście: "Hola, nie oprogramowałeś metody w klasie, którą powinna realizować!"
A teraz trochę praktyki.
Tworzymy grę, czyli praktyczne wykorzystanie interfejsów
Załóżmy, że tworzymy prostą grę strategiczną, w której występują:
- Ludzie
- Żołnierze
- Inżynierowie
- Budynki
- obronne
- pozostałe
Żołnierze, pojazdy oraz inżynierowie mogą się poruszać w czterech kierunkach mapy: góra, dół, lewo, prawo.
Przyjmijmy, że Budynki raczej się nie poruszają :) W dodatku część budynków może strzelać (np działka antyrakietowe).
Teraz określimy nasze interfejsy: jeden do poruszania, drugi do strzelania:
interface IMovement
{
void goUP();
void goDown();
void goLeft();
void goRight();
}
interface IShoot
{
void Shoot(Unit who);
}
W najprostrzym modelu, możemy podzielić jednostki na ludzi, pojazdy i budynki.
Stwórzmy zatem początkowe: Human, Building, oraz Unit:
abstract class Unit
{
public int Health = 100;
}
class Human : Unit
{
//...
}
class Building : Unit
{
//...
}
do szczęścia przydałoby się podzielić jeszcze ludzi na żołnierzy i inżynierów, oraz rozszerzyć budynki na działka:
class Soldier : Human
{
}
class Engineer : Human
{
}
class Cannon : Building
{
}
jak już ustaliliśmy, ludzie mogą się poruszać. podłączmy zatem interfejs IMovement do klasy Human:
class Human : Unit, IMovement
{
}
Jeśli spróbujemy teraz skompilować nasz kod, otrzymamy informację iż nie zimplementowaliśmy metod do poruszania się naszych jednostek!
Zatem skorygujmy nasz kod
class Human : Unit, IMovement
{
//...
public void goUP()
{
//idź do góry
}
public void goDown()
{
//idź w dół
}
public void goLeft()
{
//idź w lewo
}
public void goRight()
{
//idź w prawo
}
}
Teraz kompilacja przejdzie bez problemu.
zmodyfikujmy teraz naszą klasę Cannon:
class Cannon : Building, IShoot
{
void Shoot(Unit who)
{
//strzelaj do wskazanej jednostki!
}
}
i kompilacja... niestety znowu problem. Musimy pamiętać o tym, że
metody oparte o interfejs zawsze muszą być publiczne! W końcu jest to funkcjonalność "widoczna" przez programistów, którzy później stworzą obiekt naszej przykładowej klasy Cannon.
poprawmy zatem:
class Cannon : Building, IShoot
{
public void Shoot(Unit who)
{
//strzelaj do wskazanej jednostki!
}
}
i teraz jest dobrze :)
pełny kod:
///////////////////////////////////////////////
abstract class Unit
{
public int Health = 100;
}
class Human : Unit, IMovement
{
//...
public void goUP()
{
//idź do góry
}
public void goDown()
{
//idź w dół
}
public void goLeft()
{
//idź w lewo
}
public void goRight()
{
//idź w prawo
}
}
class Building : Unit
{
//...
}
class Soldier : Human, IShoot
{
public void Shoot(Unit who)
{
}
}
class Engineer : Human
{
}
class Cannon : Building, IShoot
{
public void Shoot(Unit who)
{
//strzelaj do wskazanej jednostki!
}
}
interface IMovement
{
void goUP();
void goDown();
void goLeft();
void goRight();
}
interface IShoot
{
void Shoot( Unit who);
}
///////////////////////////////////////////////
Teraz zobacz, jak to działa. stwórz obiekty utworzonych klas....
Soldier soldier1 = new Soldier();
Building armory = new Building();
Engineer engineer1 = new Engineer();
... i zobacz, jakie nasze obiekty mogą wykonywać operacje.
Podsumowanie
Interfejsy umożliwiają dokładne określenie funkcji, jakie powinny realizować klasy (jakie powinny posiadać metody).
Jeśli do klasy podłączymy interfejsy, kompilator nie przepuści nas dalej, dopóki nie oprogramujemy naszych klas zdefiniowanymi przez interfejs metodami (które muszą być publiczne).
Bez interfejsów można oczywiście żyć, jednak pozwalają w sposób ładny uporządkować nasz kod. Gdybyśmy na przykład do naszej klasy IShoot dodali metodę ShootAlternative, kompilator nie przepuściłby nas momentu, kiedy wszystkie klasy dziedziczące po IShoot posiadałyby implementację wspomnianej metody.
Oczywiście interfejsy można wykorzystać nie tylko przy tworzeniu gier, ale wszędzie tam, gdzie ważne jest opanowanie tworzonego oprogramowania.
Nie ma sensu stosować interfejsów w przypadku gdy ten pojawi się w najwyżej jednej klasie skromnej aplikacji. Przy większych systemach warto jednak zadać sobie pytanie:
Czy z interfejsami nie będzie bezpieczniej i wygodniej?
X3me
