Uw eigen klassen maken

Objectgeoriënteerd ontwerpen is een complex onderwerp. Er zijn mensen die hun hele leven wijden aan de academische studie en professionele toepassing van deze discipline. Toch volgen hier een paar ideeën die u op weg kunnen helpen.

1. Denk goed na over de rol die instanties van een bepaalde klasse vervullen in de toepassing. In het algemeen hebben objecten één van de volgende rollen:

   • Waardeobject: deze objecten dienen vooral als gegevenscontainers. Deze bevatten waarschijnlijk meerdere eigenschappen en minder methoden (of soms geen methoden). Ze zijn over het algemeen gecodeerde weergaven van duidelijk gedefinieerde items. Een muziekspelertoepassing kan bijvoorbeeld een Song-klasse bevatten die één echt nummer bevat en een Playlist-klasse die een conceptuele groep liedjes bevat.

   • Weergaveobject: dit zijn objecten die op het scherm worden weergegeven. Voorbeelden zijn gebruikersinterface-elementen zoals een vervolgkeuzelijst of statusuitlezing, grafische elementen zoals een karakter in een videogame enzovoort.

   • Toepassingsstructuur: deze objecten spelen verschillende ondersteunende rollen in de logica of verwerking die door toepassingen worden uitgevoerd. U kunt bijvoorbeeld een object maken dat bepaalde berekeningen uitvoert in een biologiesimulatie. U kunt een object maken dat verantwoordelijk is voor het synchroniseren van waarden tussen een kiesbediening en volume-informatie in een muziekspelertoepassing. Een ander object kan de regels in een videospel beheren. Of u kunt een klasse maken voor het laden van een opgeslagen afbeelding in een tekentoepassing.

2. Bepaal de specifieke functionaliteit die de klasse nodig heeft. De verschillende typen functionaliteit worden vaak de methoden van een klasse.

3. Wanneer de klasse moet dienen als een waardeobject, bepaalt u de gegevens die de instanties moeten bevatten. Deze gegevens zijn goede kandidaten voor eigenschappen.

4. Aangezien u de klassen specifiek voor uw project ontwerpt, is het belangrijkste uitgangspunt dat u de functionaliteit biedt die voor uw toepassing nodig is. Probeer deze vragen zelf te beantwoorden:

   • Welke gegevens worden in uw toepassing opgeslagen, bijgehouden en gemanipuleerd? Het antwoord op deze vraag helpt u bij het identificeren welke waardeobjecten en eigenschappen u nodig hebt.

   • Welke actiesets voert de toepassing uit? Wat gebeurt er bijvoorbeeld wanneer de toepassing eerst wordt opgeladen, wanneer er op een bepaalde knop wordt geklikt, wanneer een film ophoudt met spelen, enz.? Dit zijn goede kandidaten voor methoden. Dit kunnen ook eigenschappen zijn als de 'acties' bepaalde individuele waarden bevatten.

   • Welke informatie is vereist voor het uitvoeren van een bepaalde actie? Deze gegevens worden de parameters van de methode.

   • Van welke zaken die in een klasse veranderen tijdens het uitvoeren van de toepassing, moeten andere onderdelen van uw toepassing kennisnemen? Dit zijn goede kandidaten voor gebeurtenissen.

5. Is er een bestaand object dat vergelijkbaar is met het object dat u nodig hebt behalve dat hierbij een functionaliteit ontbreekt die u wilt toevoegen? Overweeg in dat geval om een subklasse te maken. (Een subklasse is een klasse die bouwt op de functionaliteit van een bestaande klassen in plaats van het definiëren van de volledige eigen functionaliteit.) Om bijvoorbeeld een klasse te maken dat op het scherm een visueel object is, gebruikt u het gedrag van een bestaand weergaveobject als basis voor uw klasse. In dat geval zou het weergaveobject (zoals MovieClip of Sprite) de basisklasse zijn en zou uw klasse deze klasse uitbreiden.

Wanneer u eenmaal een ontwerp voor uw klasse hebt of ten minste een idee van de informatie die erin wordt opgeslagen en welke acties het uitvoert, is de werkelijke syntaxis van het schrijven van een klasse eenvoudig.

U moet minimaal de volgende stappen uitvoeren om uw eigen ActionScript-klasse te maken:

1. Open een nieuw tekstdocument in uw ActionScript-tekstbewerkingsprogramma.

2. Voer een instructie class in om de naam van de klasse te definiëren. Om een instructie class toe te voegen, voert u de woorden public class en de klassenaam toe. Voeg accolades openen en sluiten toe rond de inhoud van de klasse (de methode- en eigenschapdefinities). Bijvoorbeeld:

   public class MyClass 
   { 
   }

   Het woord public geeft aan dat de klasse kan worden benaderd vanuit elke andere code. Zie Naamruimteattributen voor toegangsbeheer voor andere alternatieven.

3. Typ een instructie package om de pakketnaam aan te geven die uw klasse bevat. De syntaxis is het woord package , gevolgd door de volledige pakketnaam, gevolgd door de accolades openen en sluiten rond het instructieblok class ). Wijzig de code in de vorige stap bijvoorbeeld in het volgende:

   package mypackage 
   { 
       public class MyClass 
       { 
       } 
   }

4. Definieer elke eigenschap in de klasse met de instructie var binnen de hoofdtekst van de klasse. De syntaxis is dezelfde als u gebruikt om een willekeurige variabele te declareren (met toevoeging van de optie public ). Wanneer bijvoorbeeld de volgende regels worden toegevoegd tussen beide accolades van de klassendefinitie, worden eigenschappen textProperty , numericProperty en dateProperty gemaakt:

   public var textProperty:String = "some default value"; 
   public var numericProperty:Number = 17; 
   public var dateProperty:Date;

5. Definieer elke methode in de klasse met dezelfde syntaxis die wordt gebruikt om een functie te definiëren. Bijvoorbeeld:

   • Voor het maken van een methode myMethod() , voert u het volgende in:

     public function myMethod(param1:String, param2:Number):void 
     { 
         // do something with parameters 
     }

   • Voor het maken van een constructor (de speciale methode die wordt aangeroepen tijdens het proces waarin een instantie van een klasse wordt gemaakt), maakt u een methode met precies dezelfde naam als de naam van de klasse:

     public function MyClass() 
     { 
         // do stuff to set initial values for properties 
         // and otherwise set up the object 
         textVariable = "Hello there!"; 
         dateVariable = new Date(2001, 5, 11); 
     }

     Als u geen constructormethode in uw klasse invoegt, maakt de compiler automatisch een lege constructor in uw klasse. (Met andere woorden, een constructor zonder parameters en instructies.)

   Er zijn weinig andere klasse-elementen die u kunt definiëren. Deze elementen zijn complexer.

   • Accessors zijn een speciale kruising tussen een methode en een eigenschap. Wanneer u de code schrijft om de klasse te definiëren, schrijft u de accessor als een methode zodat u meerdere handelingen kunt uitvoeren (in plaats van alleen een waarde lezen of toekennen, wat alles is dat u kunt doen wanneer u een eigenschap definieert). Wanneer u echter een instantie van uw klasse maakt, behandelt u de accessor als een eigenschap en gebruikt u alleen de naam om de waarde te lezen of toe te kennen.

   • Gebeurtenissen in ActionScript worden niet gedefinieerd met een specifieke syntaxis. In plaats daarvan definieert u gebeurtenissen in uw klasse met behulp van de functionaliteit van de EventDispatcher-klasse.