Graad 11 - Kwartaal 3 Toets Afbakening

Hi Graad 11's

Ons het more middag die kwartaal toets, soos ons laas kwartaal gereel het.  Dis ongelukkig al manier om dit te doen.  Die toets gaan sowat 1 uur lank wees vir teorie en prakties saam.  Ons hou dit redelik maklik en eenvoudig weens die handboek probleme.  Ek het ook toestemming van die departement gekry dat ons dit `n oopboek toets kan maak.

Hier is die afbakening.  Julle moet aandag gee aan al die volgende:

Teorie:

• Modulêre ontwerp
• Die komponente op die moederbord
• RAM
• Grafika kaarte
• Data oordrag
• Stoortoestelle
• Tipes bedryfstelsels
• Multitaak, Multidraad, en Multiverwerking

Prakties:

• Die hele Hoofstuk 4 van Delphi (IF stellings, radio buttons, ens.)

Sterkte.  Ek sien julle more so vroeg as moontlik na 2.

Mnr T.

Om Tekslêers in Skikkings ("Arrays") in te lees

Dit is eintlik baie eenvoudig om die data van `n tekslêer in `n array in te lees.

Eerstens, kom ons gestel ons het `n tekslêer wat `n lys name bevat, onder mekaar ingevoeg.  Die naam van die tekslêer is "Name.txt".

Ek gaan aanvaar julle weet klaar hoe om seker te maak dat die tekslêer bestaan.  (Dis op bl 27 en 28 van die handboek).

Dan moet die tekslêer "Assign" word en "reset" word.  Ons doen dit met die volgende kode:

AssignFile(NameLr, 'Name.txt');                              {Ons verwys gevolglik na die lêer as "NameLr"
Reset(NameLr);

Daarna moet ons fisies al die name uit die tekslêer uit inlees in die array in.  Ons doen dit as volg:

while (NOT EOF(NameLr)) AND (iTelName < MAKSNAME) do
begin
    inc(iTelName);
    readln(NameLr, arrName[iTelName]);
end;

In die stuk kode hierbo kan ons sien daar is `n veranderlike ("iTelName", `n teller), en `n konstante ("MAKSNAME"), wat die maksimum aantal name bevat wat jy self gespesifiseer het.

Ons kan sien uit reel 1 dat die kode `n lus is wat herhaal totdat OF die einde van die tekslêer bereik is, OF totdat die maksimum aantal name bereik is.

Wanneer die prosedure begin kan ons sien "iTelName" word elke keer met een vermeerder (dis ons teller).
Dan word die inhoud van NameLr ingelees in die Array "arrName" na die posisie met dieselfde waarde as "iTelName".  Met ander woorde, in siklus 1 sal die waarde in die tekslêer gelees word na posisie 1, in siklus 2 na posisie 2, in siklus 13 na posisie 13, en so voorts.

Eintlik baie eenvoudig, ne?

Subprogramme

Subprogramme is stukke kode wat saamgevoeg word om `n sekere doel te bereik in sekere situasies.

Byvoorbeeld, `n "Event Handler" is een sekere tipe subprogram (`n "Prosedure") wat gehardloop word wanneer `n spesifieke iets gebeur, byvoorbeeld wanneer daar op `n sekere button geclick word.

Buiten prosedures kry ons ook funksies.  Daar is ingeboude funksies (soos Sqrt, StrToIn, en so aan) in Delphi, maar jy kan ook jou eie funksies skep.

Waar `n Prosedure eenvoudig `n stel stappe is wat gevat word, is `n funksie se doel om `n resultaat te lewer; byvoorbeeld, `n wiskundige berekening.  FUNKSIES LEWER ALTYD `n RESULTAAT.  Dit is die grootste verskil tussen `n Prosedure en `n Funksie.

Ek word baie gevra wat is dan die verskil tussen `n objek / klas en `n prosedure of funksie.  Dis doodeenvoudig; `n objek of klas kan self verskeie prosedures of funksies hê.  Sien `n objek as `n mini program op sy eie, terwyl prosedures en funksies stelle kode is wat deur daardie mini program uitgevoer kan word.  En dit als saam vorm een groot program.

Funksies word gewoonlik binne in prosedures gehardloop.

Byvoorbeeld.  Op bl. 220 van Geniet Delphi Deel 2 is daar Aktiwiteit 7.  In daardie kode is daar `n paar dinge wat ek wil uitwys.

Eerstens sien ons daar word `n class geskep genaamd "TWerker".
In die "TWerker" class is daar twee functions ("BerekenBonus" en "BerekenSalaris") wat altwee resultate lewer in die vorm "real" (rieële getalle).

Dan word daar `n objek geskep genaamd "Werker" van die class "TWerker".  Met ander woorde, "Werker" het nou daardie funksies oorgeërf omdat hy deel is van die "TWerker" class.

Nou word die funksie verduidelik.  Ons sien dat "BerekenBonus" gaan kyk of die werker se aantal ure meer is as 40.  As dit meer is, dan vat hy die verskil tussen die aantal ure en 40 en vermenigvuldig dit met sy vergoeding per uur.  As dit NIE meer is nie, dan is die bonus 0.
"BerekenSalaris" aan die ander kant is die vergoeding per uur vermenigvuldig met die aantal ure, plus die bonus wat reeds bereken is.
Beide die "BerekenBonus" en die "BerekenSalaris" is FUNKSIES.  Hulle lewer `n resultaat.

Dan, in die einde, sien ons `n "PROCEDURE", wat dan doodeenvoudig die OBJEK skep, en daarna (op bl 221) nog `n PROCEDURE wat plaasvind wanneer die "Bereken" knoppie geclick word, wat doodeenvoudig die funksies uitvoer.

So `n mens kan dit half opsom as volg:

`n Klas word gedefinieër,
     waaruit `n Objek geskep word,
           wat `n stel Funksies bevat,
                  wat uitgevoer word deur `n Prosedure.

Maak dit sin?  Ek hoop so.  Gooi my met die vrae as julle het. ;-)

Object Oriented Programming Deel 2

Soos ons gister gepraat het behels OOP basies dat `n klas gespesifiseer moet word.  Die klas is soos die raamwerk waaruit "objects" geskep word.  Hy spesifiseer sekere vaste dinge en funksies.

Byvoorbeeld, in gister se illustrasie het ons gepraat van `n klas "kar".  Hy bevat instruksies vir hoe om `n kar te laat vorentoe ry, of agtertoe, en om links en regs te draai.  Hy spesifiseer ook dat die kar sekere veranderlikes het, soos kleur, maksimum spoed, sulke dinge.

Om `n klas in Delphi te definieer gebruik jy die volgende formaat:

type                                                                                           
TKlasNaam = class                                                   {`n Klas genaamd TKlasNaam word gedefinieer

   fVeld1 : datatipe;                                                    {`n Veranderlike word met die klas geassosieer

   fVeld2 : datatipe;                                                    {Nog `n klas veranderlike


  procedure ProsedureNaam;                                     {`n Prosedure wat met die klas geassosieer word
  function FunksieNaam : datatipe;                          {`n Funksie wat met die klas geassosieer word

end;

var
  ObjekNaam : TKlasNaam;                                      {`n Objek van die spesifieke klas word geskep

Nou kan ons sien dat die klas self sekere veranderlikes, prosedures en funksies het.  So elke objek van die betrokke klas wat geskep word sal dieselfde veranderlikes, prosedures en funksies hê.  Die waardes wat daaraan geheg word sal wel verskil.

Object Oriented Programming Deel 1

Hi julle.

Okay, ek wil begin met Object Oriented Programming.  Deur die loop van die volgende paar dae gaan ek baie posts hier opsit, oor al die dinge wat julle pla, so kom kyk gereeld, en comment asseblief as julle vrae het!

Soos ek vandag verduidelik het is OOP die alternatief vir Liniêre Programmering of "Procedural Programming".  Met linear programming het ons altyd in een lang stuk kode alles stap vir stap gedoen.  Die grootste verskil tussen OOP en LP lê in die manier hoe ons as programmeerders dink oor die program wat ons skryf.

In LP was die fokus op "Wat wil ek hê moet die program kan doen?"  Dan is daar `n reeks prosedures geskryf met `n klomp IF stellings om die program dit te laat doen.  Baie "code".

Met OOP is die fokus verskuif na "Watse DINGE wil ek in die program hê?"  Dan skryf jy `n "Class" vir elke tipe "ding", waarna jy verskeie "objects" kan skep van elke "class".

Byvoorbeeld.  Kom ons sê ek skryf `n game soos "Need for Speed".  In LP sal ek vreeslik baie code moet gebruik want elke kar sal byvoorbeeld afsonderlik geskep en geprogrammeer moet word, al het elke kar dieselfde basiese funksies (soos om vorentoe, agtertoe, links en regs te beweeg).  So dit beteken baie procedures en code, vir elke enkele kar afsonderlik.  Maar in OOP kan ek `n "class" skep genaamd "kar".  Dan skep ek byvoorbeeld `n Object genaamd "porsche" van tipe "kar".  Ek spesifiseer daarna die object "porsche" se maksimum spoed, en kleur, en vorm, en al die ander veranderlikes, maar die basiese goed wat dieselfde is vir elke kar is reeds in die class "kar" gespesifiseer.  Gevolglik spaar jy baie kode.  Dit maak ook jou troubleshooting baie makliker, want eerder as om deur tonne en tonne code te werk kan jy net kyk na jou class "kar" as dit `n fout is met alle karre (byvoorbeeld hulle draai almal links as hulle moet regs draai), of net kyk na die spesifieke Object as dit `n fout is vat net met die een kar gebeur (byvoorbeeld sy maksimum spoed is 180 in plaas van 220).

Ek hoop dit maak sin.  Vra vrae as julle nie verstaan nie.  Ek sal more meer verduidelik. ;-)

Terloops, hier is `n baie nice videoclip op YouTube wat dit ook nogal goed verduidelik:

http://www.youtube.com/watch?v=G_pglM4qYGA

Right.  Sterkte met julle leerwerk!

Mnr. T.