Interface vs Polymorphism

Vid polymorphism ärver jag inte bara "ritningen" för klassen utan också dessa fulla funktionalitet, dvs den ärvda klassens metoder,egenskaper, etc etc får jag på köpet. Vad får jag vid ett interface?, inte mycket förutom
ritningen på hur interfacet vill att jag ska skapa den härledda klassen, jag får implementera interfacets egenskaper,metoder om och om igen i vareviga klass som ärver från Interfacet. Vid polymorphism får jag alltihopa
på köpet i varenda klass som ärver, och gillar jag inte någon metod,egenskap i den ärvda klassen gör bara en override den.
Visst, det krävs ju också att den ärvda klassen implementerat virtual. Och sen det där att man kan gruppera klasser som ärvt från ett specifik interface kan man också göra med polymorphism, det går alldeles utmärkt,
bara de klasserna som man skapar en polymorphismarray på alla har ärvt från basklassen.
Såhär tex:

	//Skapa AnimalPolymorphismArray
            AnimalPolymorphism[] AnimalPolymorphismArray = new AnimalPolymorphism[10];

            AnimalPolymorphismArray[0] = new CatConsumeAnimalPolymorhism(); //CatConsumeAnimalPolymorphism har ärvt från AnimalPolymorphism klassen
            AnimalPolymorphismArray[1] = new DogConsumeAnimalPolymorphism();  //DogConsumeAnimalPolymorphism har ärvt från AnimalPolymorphism klassen

	//Skapa AnimalInterfaceArray
            AnimalInterface[] AnimalInterfaceArray = new AnimalInterface[10];

            AnimalInterfaceArray[0] = new CatConsumeAnimalInterface();  //CatConsumeAnimalPolymorphism har ärvt från AnimalInterface klassen
            AnimalInterfaceArray[1] = new DogConsumeAnimalInterface();  //CatConsumeAnimalInterface har ärvt från AnimalInterface klassen

Det enda som jag ser är nersidan med polymorphism är att man kan inte ärva från multipla klasser.

Men det jag inte riktigt förstår är varför det är sånt liv för interfaces, på vilket sätt tillför de nytta när man bara ärver en ritning på hur den härledda klassen ska se ut. Och så får man får själv implementera Interfacets alla metoder,egenskaper om och om igen i alla klasser som ärver från den. Vilket man inte behöver göra vid polymorphism.
Eller vad finns det mer för nytta med interfaces som jag inte vet om, om ni jämför med polymorphism?.

Nu är det java jag kan och i java jag tänker, men det är nyttan för mig med interfaces.
Säg att jag vill implementera en klass för att skriva ut saker på skärmen, en ström mao. Då kanske jag vill ha en standard-metod write. Sedan kanske jag vill ha två klasser som dels skriver ut i ett fönster och dels till konsolen. Då kanske jag vill låta den ena klassen förlänga en JCanvas (En grafisk komponent) och den andra kanske jag inte vill ska förlänga något. Då kan jag fortfarande skicka med en instans av vilketdera objekt till ett annat objekt. Nedan lite java-pseudokod:

class GrafiskStröm extends JCanvas implements MittStrömInterface{
void skrivUt(){
  //kod
}
// kod
}

class KonsolStröm implements MittStrömInterface{
void skrivUt(){
  //kod
}

// kod
}

class PrimtalsGenerator(){
   MittStrömInterface minStröm;

   PrimtalsGenerator(MittStrömInterface utström){
      minStröm = utström;
   }

   generatePrimes(){
      for (;;){
      // Blablabla

        minStröm.skrivUt(talet);
      }
   }
}

... I mainmetoden:
PrimtalsGenerator p;

if (grafisktLäge)
   p = new PrimtalsGenerator(new GrafiskStröm());
else
   p = new PrimtalsGenerator(new KonsolStröm());

p.generatePrimes();

Men det jag inte riktigt förstår är varför det är sånt liv för interfaces, på vilket sätt tillför de nytta när man bara ärver en ritning på hur den härledda klassen ska se ut. Och så får man får själv implementera Interfacets alla metoder,egenskaper om och om igen i alla klasser som ärver från den. Vilket man inte behöver göra vid polymorphism.
Eller vad finns det mer för nytta med interfaces som jag inte vet om, om ni jämför med polymorphism?.

Hela iden med OO och klasser är ju reuse, återanvänding av koden i olika projekt. Och som du beskriver så kan du ändra i dessa klasser. Du kan byta ut metoder med virtual. Du kommer säkert att upptäcka att du måste lägga till en metod i din heraki och gör detta. Detta ger tillsist att dina klasser bara funkar i just ett projekt. I andra så funkar en annan kopia av dem..osv. Du har helt enkelt ingen reuse alls. (nån som inte varit med om detta??)

Så det enda som man kan återanvända är interfaces, ritningen på hur dina klasser ser ut. När du använder dessa kan du byta ut objekt/moduler i dina projekt.

Det finns säkert sidor på internet som kan beskriva det här mycket bättre än jag. Men för de som är intresserade så gick jag en kurs i sommras med Juval Löwy. Där han diskuterade just detta och den kursen är klart att rekommendera.

Intressant är även att anmärka att både Java Framework och .Net Framework är uppbyggda med Interfaces.

Arv känns för mig ett givet sätt att bygga upp ett system om det är så fint uppdelat som Djur -> Hund, Katt Fågel. Men om man ska bygga upp en bra struktur på saker som inte innehåller liknande funktionalitet, t.ex. som ovan utskrift av text på skärm eller annan enhet så känns interface som en god idé.

Jag skulle vilja hävda att interface är betydligt viktigare än arv, och att återanvändning mellan projekt är en myt som skapats (eller åtminstone upprätthålls) för att tilltala ekonomiavdelningen.

Det här med reuse behöver ju inte stanna mellan olika projekt. Vid en uppgradering av befintliga projekt behövs antagligen även "ritningarna" justeras med avseende på nya features osv. Men samtidigt behålla en bakåtkompabilitet. Med ett interface är det ju bara att lägga till det man vill ha. Att ärva klasser rakt ned i olika versioner för samma sak går väl att göra, men å andra sidan blir det lätt kaka på kaka i ett infinit träsk, om nu en ny klass ska ärva från alla de andra i en seriell ordning bara för att den allra senaste featuren ska kunna pluppas dit. Jag ser arv hellre som en mer - för det existerande projektet - logisk lösning, än som reuse för all evinnerlighet. But hey! That is just my idea ;)

PeW skrev:

Jag ser arv hellre som en mer - för det existerande projektet - logisk lösning, än som reuse för all evinnerlighet.

(y)

 
        private void Form1_Load(object sender, EventArgs e)
        {
            //Interface metodanrop
            DogClassInheritIAnimal Dogge = new DogClassInheritIAnimal();
            CatClassInheritIAnimal Catte = new CatClassInheritIAnimal();

            TestInterfaceMetod(Dogge);
            TestInterfaceMetod(Catte);

            //Polymorphiskt metodanrop
            DogClassInheritAnimalBaseClass Dogge2 = new DogClassInheritAnimalBaseClass();
            CatClassInheritAnimalBaseClass Catte2 = new CatClassInheritAnimalBaseClass();

            TestPolymorphismMetod(Dogge2);
            TestPolymorphismMetod(Catte2);
}

        private void TestInterfaceMetod(IAnimal animalinterface) 
        {
            if (animalinterface is DogClassInheritIAnimal)
            {
                ((DogClassInheritIAnimal)animalinterface).DogProperty = "en hund";
            }

            if (animalinterface is CatClassInheritIAnimal)
            {
                ((CatClassInheritIAnimal)animalinterface).CatProperty = "en katt";
            }
        }

        private void TestPolymorphismMetod(AnimalBaseClass animalbaseclass)
        {
            if (animalbaseclass is DogClassInheritAnimalBaseClass)
            {
                ((DogClassInheritAnimalBaseClass)animalbaseclass).DogProperty = "en hund";
            }

            if (animalbaseclass is CatClassInheritAnimalBaseClass)
            {
                ((CatClassInheritAnimalBaseClass)animalbaseclass).CatProperty = "en katt";
            }
        }

Ja, ni ser vilka som ärver från vad, jag namngav de så att de blir self-explainatory.. Men här vill jag visa att man får ju samma funktionalitet med polymorphism som man får med ett interface, skillnaden är bara att med polymorphism ärver man föräldraklassernas källkod och metoder,egenskaper ja, hela rasket, vilket man inte gör om man ärver med interface, då ärver man bara ett tomt skal utan källkod. Men nån som kan förklara vad man ska med ett skal till?, jag tycker polymorphism har mer fördelar eftersom den följer en strikt klasshierarky. Nån som kan förklara mer detaljerat fördelarna med interface över poly, och vad man kan göra med interface som man inte kan göra med poly?. Jag blir inte riktigt klok på det här :l

1. Det är inte skalet man är ute efter, utan kontraktet, som bevisar att klassen uppföljer vissa kriterier.
2. Man kanske inte vill ha med bagage i form av en ärvd klass, eftersom man i slutändan ändå har överladdat alla metoder.
3. Vi behöver inte jämföra arv och interface, eftersom de innebär olika saker, om än med viss överlappning.
4. Man kan implementera hur många interface som helst, men endast ärva en klass
5. Jag vill inte hävda att det är något fel med arv. Tvärtom är det otroligt viktigt, och en förutsättning i t.ex. ASP.NET (ärva Page-klassen). Däremot är min erfarenhet att interface finner sin användning oftare, eftersom kontraktet ofta är det centrala, och inte metodåtervinning.

word