abstract class/virtual class

[lauwsa]

In mijn boek hebben ze het over abstract classes, ik weet nu hoe ze werken maar er word niet uitgelegd waarom je ze zou gebruiken. Als je toch zeker waar dat je bvb "gettype" gaat vervangen in een volgende class, waarom zou je die dan in je vorige class maken?

Het enigste dat ik me hier bij kan bedenken is om bugs te voorkomen, omdat je dan zeker waar dat je die gemaakt hebt in een volgende class.

Wat ik nu heb gezien zijn virtual classes handig als je bvb iets met een object wilt doen wat voor de rest van de classes ook gaat gelden die aan de object class zijn gekoppeld. En dat je in "eerste class" wat wilt toevoegen waar nog eigenlijk geen andere class voor is.

Hopelijk heb ik het een beetje duidelijk uitgelegd wat ik bedoel.

edit, 1 zin weg gehaald
edit2: dit is in c++
edit3:

Het enigste nuttige dat ik kan vinden is dat je dan zeker weet dat bvb gettype zeker voorkomt in de class die aan "de eerste class" gekoppeld is, dus om foute te voorkomen.

[ Voor 16% gewijzigd door lauwsa op 02-12-2010 08:59 ]

[NMe]

Een boek dat wel ingaat op abstracte classes maak niet uitlegt waarom je ze nodig hebt? Handig.

Een abstract class doet zeker meer dan alleen fouten afvangen. Simpel voorbeeld: je hebt een abstracte class genaamd Shape waarvan je Triangle, Circle en Rectangle afleidt. De Shape geef je een method genaamd Draw. Elk van de drie afgeleiden heeft een constructor die anders werkt omdat elke shape andere variabelen nodig heeft om hem te kunnen tekenen. Hetzelfde geldt voor de Draw-method omdat je elke Shape anders moet tekenen.

Waar zit nu het voordeel? In het feit dat je Shapes kan doorgeven. Je kan een array maken van het type Shape waarin je elk van de afgeleide classes kunt gebruiken. Vervolgens kun je de Draw-method aanroepen ondanks dat je op dat moment geen idee hebt welk type shape je aan het tekenen bent.

[AtleX]

Stel je hebt wat classes die exact dezelfde interface hebben en die een groot gedeelte van de implementatie delen. Dan kan je een abstract base class maken waarvan je de methodes als abstract markeert zodat je de subclasses dwingt om deze te implementeren:

C#:

public abstract class BaseClass
    {
        public BaseClass()
        {
        }

        public void Method1()
        {
            // implementation
        }

        public abstract void Method2();
    }

public class SubClass1 : BaseClass
    {

        public override void Method2()
        {
            // implementation
        }
    }

    public class SubClass2 : BaseClass
    {

        public override void Method2()
        {
            // implementation
        }
    }

Je kan het dus zien als een interface met een gedeeltelijke implementatie, waardoor je die dus als volgt kunt gebruiken:

C#:

public class User
    {

        public User()
        {
            BaseClass bc1 = new SubClass1();
            BaseClass bc2 = new SubClass2();
        }
    }

Het exact type van bc1 & bc2 is hier niet interessant, want je weet dat ze allebei toch over dezelfde methods beschikken.

Als je dit zou oplossen met een class (zonder abstract en geen abstract method) en Method2() voeg je toe in de subclasses dan gaat bovenstaande niet werken. bc1.Method2() geeft een fout want die method is dan niet meer beschikbaar.

[edit]
Wel .NET, geen idee of er veel verschil in de exacte werking van het spul is vergeleken met C++

[ Voor 3% gewijzigd door AtleX op 02-12-2010 09:15 ]

[defcon84]

dan heb je nog je 2de vraag: de virtual

C#:

    public abstract class BaseClass
    {
        public BaseClass(){}
        public virtual void Method1(){/*implementation*/}
        public abstract void Method2();
    }

    public class SubClass1 : BaseClass
    {
        public override void Method1(){/*implementation*/}
        public override void Method2(){/*implementation*/}
    }

    public class SubClass2 : BaseClass
    {
        public override void Method2(){/*implementation*/}
    }

Dus een virtual method kan je overriden als de method niet doet wat je wil.
Die method heeft dus standaard al een body (code).

het verschil is, abstract moet je overriden, virtual moet niet..

[edit]
ook .NET dus

[Verwijderd]

Een abstracte class kan nooit direct worden geimplementeerd. Dit zal altijd via een derived class meten

code:

    public abstract class tstClass
    {

        public void DoIt()
        {

        }
    }

    public class tst : tstClass
    {
    }

        private void button2_Click(object sender, EventArgs e)
        {
            tstClass t = new tst();
            t.DoIt();
        }

  
// onderstaande werkt dus niet omdat hij abstract is en niet direct mag worden geimplementeerd
        private void button2_Click(object sender, EventArgs e)
        {
            tstClass t = new tstClass();
            t.DoIt();

        }

dus als jeeen class wil hebben die niet direct mag worden aangeroepen dan moet je hem abstract maken

[Haan]

Verwijderd schreef op donderdag 02 december 2010 @ 09:46:
Een abstracte class kan nooit direct worden geimplementeerd. Dit zal altijd via een derived class meten

code:

    public abstract class tstClass
    {

        public void DoIt()
        {

        }
    }

    public class tst : tstClass
    {
    }

        private void button2_Click(object sender, EventArgs e)
        {
            tstClass t = new tst();
            t.DoIt();
        }

  
// onderstaande werkt dus niet omdat hij abstract is en niet direct mag worden geimplementeerd
        private void button2_Click(object sender, EventArgs e)
        {
            tstClass t = new tstClass();
            t.DoIt();

        }

dus als jeeen class wil hebben die niet direct mag worden aangeroepen dan moet je hem abstract maken

Ja dat is heel leuk, maar de vraag is waarom je een class zou willen maken die niet direct mag worden aangeroepen NMe beschrijft dat tot nu toe het duidelijkst met een concreet voorbeeld.

[NC83]

Een ander bij komend feit is dat abstract classes de enige manier zijn om in C++ interfaces te declareren en in C# de enige manier om interfaces te maken die variablen bevatten die door alle derived classes gedeeld worden.

[lauwsa]

Heel erg bedankt iedereen, het is nu duidelijk .

abstract/virtual is dus best handig.

[Guldan]

@NME: daar zou je ook natuurlijk een interface voor kunnen gebruiken en de lijst met shape objecten casten naar de interface.

[Janoz]

Met Guldan. Het voorbeeld van NME is eerder een mooi voorbeeld van een Interface genaamd Drawable. Het grote verschil tussen een interface en een abstracte class is dat een abstracte class zelf ook een deel implementatie heeft. Nu kun je dat vaak ook gewoon middels normale inheritance oplossen, maar in sommige gevallen heb je functionaliteit in je superclass nodig waarvan je de implementatie op dat niveau niet kunt weten en is de class op zichzelf nog niet concreet genoeg.

[EddoH]

Maar het betreft hier C++, die heeft geen interfaces (zoals al opgemerkt door NC83)....

[NMe]

Guldan schreef op donderdag 02 december 2010 @ 15:24:
@NME: daar zou je ook natuurlijk een interface voor kunnen gebruiken en de lijst met shape objecten casten naar de interface.

Weet ik, maar ik gebruikte het dan ook eerder als heel simpel praktijkvoorbeeldje dan als iets wat direct goed ontwerp is. Ik had ook een abstract factory als voorbeeld kunnen nemen maar dit leek me eenvoudiger.

De ISO C++ standaard heeft trouwens bij mijn weten ook geen interface-keyword (correct me if I'm wrong, ik doe nooit meer wat met C++) dus als je in C++ werkt zoals de topicstarter dan zul je wel aan de abstracte classes moeten voor de interface die ik hierboven omschreef.

[Woy]

EddoH schreef op donderdag 02 december 2010 @ 17:10:
Maar het betreft hier C++, die heeft geen interfaces (zoals al opgemerkt door NC83)....

Natuurlijk wel. Een class met enkel pure virtual methodes is gewoon een interface. In Java en C# is het wat anders geïmplementeerd, maar dat is vooral omdat er geen multiple inheritance mogelijk is, en er dus een speciale constructie nodig is om interfaces enigszins werkbaar te maken.

[EddoH]

My bad, had de opmerking over de interface verkeerd begrepen, ik dacht dat er werd bedoeld waarom er een abstract class ipv interface gebruikt werd...
Uiteraard is een pure abstract class hetzelfde als een interface.