Interfaces forståelse..

Interfaces bruges til at fortælle at en given class overholder et interface. Et interface er kun en erklæring af metoder, ikke implementation.

Arv bruges til at arve implementation (og interface) fra en class til en anden.

Så vidt jeg ved kan en class kun arve fra en class, men kan implementere flere interfaces.

I C++ (og nogle andre sprog) har man "kun" arv, men kan arve fra flere class'er. Man kan opnå det samme som et interface, ved at arve fra classer med kun pure virtual funktioner.

I nyere sprog som java og C# bruger man interfaces til at skelne mellem implementation og interfaces. I praksis er der dog en ret flydenede grænse mellem de to.

Man kan også sige at det at man skelner mellem arv og interfacees er "syntax sukker", det tilføjer egentlig ikke noget nyt, men det hjælper på forståelsen.

En måde at bruge interfaces på, kunne være hvis man er flere om et projekt, og man derfor vil være sikker på at alle koder modulerne på samme måde. Så kunne man lave et modul interface, der dikterede hvilke metoder og medlemsvariabler der som minimum skal være med - og så nægter den at compile hvis det ikke er tilfældet.

Eksempel(er ikke sikkert jeg 100% kan huske java syntaxen, så der er måske nogle fejl i den):

køretøj interface:

public interface Køretøj {
   void start();
   void kør();
}

bil klasse:

public class Bil implements Køretøj {
   void start() {
      System.out.println("BIL startet");
   }
   void kør() {
      System.out.println("BIL kørere");
   }
}

varvogn klasse:

public class VareVogn implements Køretøj {
   //Disse metoder kræver interfacet:
   void start() {
      System.out.println("VAREVOGN startet");
   }
   void kør() {
      System.out.println("VAREVOGN kører");
   }
   //Denne metode, er bare en aldmindelig metode
   public VareVognContent indhold;
   VareVognContent getVareVognContent() {
      return indhold;
   }
}

En del af programmet der håntere køretøjer(starter og køre, måske en chefør klasse) kan så arbejde med ALLE klasser der implementere køretøj interfacet:

Vector<Køretøj> mineBiler;
mineBiler.add(new Bil());
mineBiler.add(new VareVogn());

for(int i = 0; mineBiler.size(); i++) {
   //nu kan vi håntere alle former for køretøjer!
   Køretøj køretøj = mineBiler.get(i);
   køretøj.start();
   køretøj.kør();
}

//DETTE KAN MAN _IKKE_ GØRE, DA VI KUN KENDER KØRETØJ METODERNE OG IKKE VAREVOGN METODERNE:
VareVognContent indhold = mineBiler.get(1).getVareVognContent();

Et eksempel på hvordan den kan blive brugt til noget lidt mindre søgt, er et IDrawAble interface.

Det behøves kun en metode, nemlig void draw(). Man kan så et sted i sit program lave en liste(vector) over alle de ting der skal tegnes til skærmen. Det er måske både "Rectangle" og "Button" (og sikkert mange flere) objecter der skal tegnes til skærmen, og disse objecter extender(arver) fra to helt forskellige klasser(måske "Shape" og "GUIElement").

Siden man kun kan arve fra en klasse, kan man bruge et IDrawAble interface, og med et for-loop tegne alle Draw able objecter til skærmen, ved at kalde deres draw metode.

(i dette eksempel kunne det være at GUIElement allerede skulle have implementeret IDrawAlbe interfacet, siden alle gui elementer skal tegens, men det er ikke sikkert alle former(Shape) skal tegnes.)