Gameprogrammeren: Interfaces Arjan Egges Paul Bergervoet Wouter van Toll

Terugblik: Abstracte klasse abstract class Klasse waarvan je mag overerven, maar die je nooit mag/wilt instantiëren Methoden en properties kunnen ook abstract zijn (maar dan moet de bijbehorende klasse dat ook zijn) abstract class Animal { // code shared by all animals } class Cat : Animal { // code that is specific for cats Geeft aan dat je nooit een gewone Animal mag maken

Multiple inheritance? Soms zou je het liefst iets gevaarlijks willen: Een klasse meerdere superklassen geven Dezelfde “superklasse” inzetten bij klassen die weinig met elkaar te maken hebben class Bird : Animal { // + animal-related code public void Fly() { ... } public void Land() { ... } } class Airplane : Vehicle // + vehicle-related code abstract class FlyingObject { public abstract void Fly(); public abstract void Land(); }

Multiple inheritance? “Multiple inheritance” is verboden Dus dit mag niet: Zou conflicten kunnen opleveren: wie krijgt voorrang, Animal of FlyingObject? Een veel voorkomende designfout (vak MSO, tweede jaar) class Bird : Animal, FlyingObject { ... }

Interfaces Oplossing: interface (Een soort “abstracte klasse die volledig abstract is”) Een lijstje methoden/properties waarvan je belooft dat je ze ooit gaat implementeren Die implementaties kunnen per klasse verschillen Klasse die een interface implementeert moet alle methoden/properties uit die interface bevatten Een klasse mag maar één superklasse hebben, maar mag meerdere interfaces implementeren!

Voorbeeld van een interface interface IFlyable { void Fly(); void Land(); } class Bird : Animal, IFlyable { // + animal-related code public void Fly() { ... } public void Land() { ... } class Airplane : Vehicle, IFlyable { // + vehicle-related code Naamconventie (niet verplicht) : begin met I Geen implementaties, alleen beloftes die een klasse moet nakomen Volgorde (verplicht): eerst de superklasse, daarna de interfaces Implementaties zijn altijd public; override is niet nodig

Interface gebruiken // dit mag allemaal: Bird b1 = new Bird(); Animal b2 = new Bird(); IFlyable b3 = new Bird(); IFlyable p1 = new Airplane(); List<IFlyable> flyers = new List<IFlyable>(); flyers.Add(b3); flyers.Add(p1); flyers.Add((IFlyable)b2); // of: "b2 as IFlyable“ foreach (IFlyable f in flyers) if (f is Animal) Console.WriteLine(“Flying animal found!"); Net alsof het een superklasse is!

Voorbeeld: IList en ICollection List en andere Collections gebruiken interfaces Die beloven wat een bepaald soort collection kan ICollection Volgorde van gegevens is niet belangrijk Voorbeeld: alle items in de inventory van de speler IList Gegevens die in een lineaire volgorde staan Voorbeeld: de achtergrondlagen in de volgorde waarin ze getekend moeten worden

ICollection-interface Ziet er zo uit: interface ICollection<E> { void Add(E x); bool Remove(E x); bool Contains(E x); int Count { get; }; // een read-only property void Clear(); … }

IList is zelf ook weer een ICollection! IList-interface IList is zelf ook weer een ICollection! interface IList<E> : ICollection<E> { E this [int n] {get; set;}; // notatie voor de indicering int IndexOf(E x); void Insert(int n, E x); void RemoveAt(int n); … }

Ander voorbeeld Multi-platform apps (bijv. met Xamarin Forms) Veel app-code is hetzelfde voor iOS, Android, ... Behalve functies die per telefoon verschillen (bijv. camera gebruiken, een nummer bellen, ...) Definieer een interface (bijv. ICaller) die belooft dat het in elk geval kan, op wat voor manier dan ook Verschillende ICaller-implementaties per platform