…is eigenlijk overbodig! Array …is eigenlijk overbodig! array: oject dat een rij waarden bevat, met speciale notaties List: array “ingepakt” in een klasse, met standaard notaties uitgebreide Declaratie Creatie Opvragen Wijzigen Lengte String [ ] a; List<String> a; List a; a = new String[10]; a = new List(); a = new List<String>(); ……a[5]…… ……a[5]…… …a.Get(5)… a[5] = ……; a[5] = ……; a.Set(5,…); …a.Length… …a.Count… Invoegen Achtervoegen a.Insert(5,…); a.Add(…);

Hoe is List gemaakt? class List<Elem> { } Elem [] elems; int n; { elems = new Elem[10]; n = 0; } void Add(Elem e) { } if (n>=elems.Length) vergroot(); elems[n]=e; n++; Elem Get (int p) { return elems[p]; } this [int p] private void vergroot() { } get { } Elem [] kopie; kopie= new Elem[2*n]; for (int t=0; t<n; t++) kopie[t] = elems[t] int Count { get { return n; } } elems = kopie;

Ja: je kunt een List maken zonder dat een array nodig is class AndereList<Elem> { } …… null © AndereList<Elem>() { …… } 3 Elem this[int p] { …… } int Count { …… } void Add(Elem e) { …… }

Ja: je kunt een List maken zonder dat een array nodig is class AndereList<Elem> { } : IList interface IList<Elem> { } …… int Count { get; } ; void Clear(); void Add(Elem e) ; Elem this [int p] { get; set; }; void Insert (int p, Elem e); © AndereList<Elem>() { …… } Elem this[int p] { …… } int Count { …… } Klasse implementeert de methodes Interface specificeert de methodes void Add(Elem e) { …… }

Implementaties van Collections ICollection LinkedList Queue Stack IList List ISet HashSet SortedSet IDictionary SortedList Sorted Dictionary

Hoofdstuk 12.1 (aparte pdf-file) Klassen en objecten

Programma en Geheugen opdrachten variabelen methoden objecten klasse veranderen zijn gegroepeerd in zijn gegroepeerd in methoden objecten bewerken zijn gegroepeerd in hebben als type klasse klasse klasse

Een eigen klasse om variabelen te groeperen Voorbeeld: een Kleur bestaat uit Rood, Groen, Blauw class Kleur Kleur paars; { paars = new Kleur(); public byte Rood; byte Groen; byte Blauw; paars.Rood = 128; paars.Blauw = 128; paars.Groen = 0; int x = paars.Grijswaarde(); }

Eigen klasse Kleur class Kleur { public byte Rood, Groen, Blauw; } constructor-methode public Kleur( ) { } Rood=255; Groen=255; Blauw=255; constructor-methode met parameters public Kleur( byte r, byte g, byte b ) { } Rood=r; Groen=g; Blauw=b; nog een constructor-methode public Kleur( byte x) { } Rood=x; Groen=x; Blauw=x; methode die iets uitrekent public byte Grijswaarde( ) { } return (3*Rood + 6*Groen + Blauw) / 10; }

Gebruik van klasse Kleur Kleur wit, paars, oranje, lichtgrijs, donkergrijs; wit = new Kleur( ); aanroep van een constructor-methode paars = new Kleur( 128, 0, 128 ); oranje = new Kleur( 255, 128, 0 ); lichtgrijs = new Kleur( 180 ); donkergrijs = new Kleur( 60 ); byte x = oranje.Grijswaarde( ); aanroep van een methode met een resultaat Kleur oranjeInZwartwit; oranjeInZwartwit = new Kleur(x); aanroep van een void-methode oranje.MaakDonkerder( );

Methodes in de eigen klasse Kleur elke klasse is automatisch subklasse van object class Kleur : object { public byte Rood, Groen, Blauw; methode die iets uitrekent public byte Grijswaarde( ) { } return (3*Rood + 6*Groen + Blauw) / 10; (byte) (0.3*Rood + 0.6*Groen + 0.1*Blauw); public void MaakDonkerder( ) { } void-methode die het object verandert Rood = (byte) (Rood * 0.9) ; Groen = (byte) (Groen * 0.9) ; Blauw = (byte) (Blauw * 0.9) ; Rood = Rood * 0.9; Groen = Groen * 0.9; Blauw = Blauw * 0.9; de variabelen van methode die een leesbare versie van de Kleur maakt override public string ToString( ) { } return $"{Rood} {Groen} {Blauw}"; }

Gebruik van klasse Kleur class MijnApp : Activity { TextView tf; void OnCreate(Bundle b) { base.OnCreate(b); tf = new TextView(this); Kleur oranje = new Kleur( 255, 128, 0); oranje.MaakDonkerder( ); aanroep van een void-methode string s = oranje.ToString( ); aanroep van een methode met een resultaat tf.Text = s;

Gebruik van klasse Kleur class MijnView : View { void OnDraw(Canvas c) { Paint verf = new Paint( ); Kleur oranje = new Kleur( 255, 128, 0); oranje.MaakDonkerder( ); aanroep van een void-methode string s = oranje.ToString( ); aanroep van een methode met een resultaat c.DrawText( s, 10, 10, verf);

Meer constructormethodes in klasse Kleur class Kleur { public byte Rood, Groen, Blauw; constructor-methode met parameters public Kleur( byte r, byte g, byte b ) { } Rood=r; Groen=g; Blauw=b; constructor-methode die een kopie maakt public Kleur( Kleur orig ) { } Rood=orig.Rood; Groen=orig.Groen; Blauw=orig.Blauw; constructor-methode die een string ontleedt public Kleur( string s ) { } string[ ] woorden = s.Split( ); array van strings handige methode van string Rood = byte.Parse( woorden[0] ); Groen = byte.Parse( woorden[1] ); Blauw = byte.Parse( woorden[2] ); Rood = woorden[0]; Groen = woorden[1]; Blauw = woorden[2]; }

Methodes in de eigen klasse Kleur class Kleur { public byte Rood, Groen, Blauw; public void MaakDonkerder( ) { } void-methode die het object verandert Rood = (byte) (Rood * 0.9) ; Groen = (byte) (Groen * 0.9) ; Blauw = (byte) (Blauw * 0.9) ; Rood = Rood * 0.9; Groen = Groen * 0.9; Blauw = Blauw * 0.9; de variabelen van public Kleur DonkerdereVersie( ) { } methode die een nieuw object oplevert Kleur res; res = new Kleur(this); res.MaakDonkerder ( ); return res; }

static variabelen zitten niet in het object class Kleur { public byte Rood, Groen, Blauw; static variabelen zitten niet in het object public static byte Max = 255; constructor-methode public Kleur( ) { } maar hebben er iets mee te maken Rood=Max; Groen=Max; Blauw=Max; }

Static methoden class Kleur { public byte Rood, Groen, Blauw; static variabelen zitten niet in het object public static byte Max = 255; constructor-methode public Kleur( ) { } maar hebben er iets mee te maken Rood=Max; Groen=Max; Blauw=Max; public static Kleur Parse( string s ) { } static methoden hebben geen object onderhanden return new Kleur(s); public static Kleur Geel = new Kleur(Max,Max,0); static variabele met de eigen klasse als type }

Interface & 3 implementaties (niet in het diktaat) Interface & 3 implementaties

Modelleren Hoe sla je gegevens op, zo dat je de operaties Zoek Voegtoe gemakkelijk kunt uitvoeren? interface IColl { bool Zoek(string s); void Voegtoe(string s); }

Idee 1 Ongeordende rij Zoek: allemaal proberen 18 ? 3 23 4 6 29 1 14 5 26 11 8 18 34 15 10 Ongeordende rij Zoek: allemaal proberen 18 ?

Idee 1 Ongeordende rij Zoek: allemaal proberen 3 23 4 6 29 1 14 5 26 11 8 18 34 15 10 Ongeordende rij Zoek: allemaal proberen 16 Voegtoe: aan het eind neerzetten 16

implementeert de interface Implementatie 1 implementeert de interface class Rij : IColl { private string[] data; private int n; constructor-methode public Rij( ) { } data = new string[100]; n = 0; public bool Zoek(string s) { for (int t=0; t<n; t++) if (data[t]==s) return true; return false; } public bool Voegtoe(string s) { data[n] = s; n = n+1; } }

Idee 2 Gesorteerde rij Zoek: begin in ’t midden 1 1 3 4 5 6 8 10 11 3 4 5 Gesorteerde rij 6 8 Zoek: begin in ’t midden 10 11 14 14 15 zoek verder in de goede helft... 15 18 23 26 29 34 23 ...tot er maar één over is 26 29 34

Idee 2 Gesorteerde rij Zoek: begin in ’t midden en halveer gebied 1 3 4 5 6 8 10 11 14 15 18 23 26 29 34 Gesorteerde rij Zoek: begin in ’t midden en halveer gebied 16 Voegtoe: schuif de rest op 18 23 en zet ’m ertussen 26 29 34

implementeert ook de interface Implementatie 2 implementeert ook de interface class SortRij : IColl { private string[] data; private int n; public Rij( ) { } data = new string[100]; n = 0; public bool Zoek(string s) { int van = 0; int tot = n; while (tot > van) { int mid = (van+tot)/2; if (data[mid]==s) return true; if (data[mid] < s) van = mid+1; else tot = mid; } return false; } }

Worst case analyse Benodigde tijd bij n elementen Ongeordende rij zoek n stappen Ongeordende rij zoek n stappen voegtoe 1 stap Gesorteerde rij zoek 2log(n) stappen Gesorteerde rij zoek 2log(n) stappen voegtoe n stappen Gesorteerde rij “halveringsmethode” 64 - 32 - 16 - 8 - 4 - 2 - 1 We zetten de twee methoden nog even naast elkaar,en bekijken de tijd die nodig is voor zoeken en toevoegenals functie van n, het aantal elementen in de verzameling. Om te zoeken in een ongeordende rij moet je in het ergste geval alle elementen langs; het zoeken kost dan net zoveel stappen als er elementen zijn. Maar nieuwe waarden kun je direct neerzetten, dus toevoegen kan altijd in één stap. In een gesorteerde rij zoeken we met de halveringsmethode. Begin je met 64 elementen, dan zijn er na één stap nog maar 32 over. Na een tweede vergelijking zijn er nog maar 16 kandidaten,en al snel is er nog maar één over. In deze getallen kun je de machten van twee herkennen, en omgekeerd is dus het aantal stappen de logaritme met grondtal 2 van het aantal elementen. Zoeken gaat in een gesorteerde rij sneller dan in een ongeordende rij, maar toevoegen kost juist veel meer tijd: in het ergste geval moet je alle elementen één voor één opschuiven. Gelukkig is er nog een derde structuur om elementen op te slaan, waarin niet alleen het zoeken, maar ook het toevoegen in een logaritmisch aantal stappen kan gebeuren. We gaan deze zoekboom-structuur nu nader bekijken. “Zoekboom” zoek 2log(n) stappen voegtoe 2log(n) stappen

wortel Zoekboom diepte 14 4 23 3 10 15 29 1 6 11 18 26 34 5 8

Zoekboom links is kleiner rechts is groter 4 14 3 10 11 6 1 5 8 23 15 29 18 26 34 14 3 4 10 1 6 5 8 11 4 23 3 6 10 11 5 8 10 15 29 1 6 11 18 26 34 5 8

Zoekboom zoek kleiner? linksaf! groter? rechtsaf! 18 ? 14 4 23 3 10 15 29 1 6 11 18 26 34 5 8

Zoekboom voegtoe zoek maak nieuw hok 16 14 4 23 3 10 15 29 1 6 11 18 26 34 16 5 8

Implementatie Zoekboom implementeert de interface class Boom : IColl { private string midden; 14 private Boom links, rechts; public bool Zoek(string s) { if (this==null) return false; Recursieve aanroep: de method roept zichzelf aan Recursieve aanroep: de method roept zichzelf aan if (s == this.midden) return true; if (s < this.midden) return links.Zoek(s); else return rechts.Zoek(s); } }

Analyse Benodigde tijd bij n elementen Ongeordende rij zoek n stappen voegtoe 1 stap Gesorteerde rij zoek 2log(n) stappen voegtoe n stappen De logaritmische zoektijd in een gesorteerde rij danken we aan het feit dat het zoekgebied in elke stap halveert. Bij zoeken in een zoekboom is dat ook zo: bij elke stap valt de helft af, dus de zoektijd is de logaritme van het aantal elementen in de boom. Omdat een element toevoegen aan een zoekboom op dezelfde manier verloopt als zoeken, kan ook het toevoegen in logaritmische tijd gebeuren. Dat is veel beter dan in een gesorteerde rij, waar het opschuiven van elementen veel tijd kost. Weliswaar kan het toevoegen in een ongeordende rij nog net iets sneller, maar daar duurt het zoeken juist weer erg lang. De zoekboom combineert dus de voordelen van de twee andere methoden. Zoekboom zoek 2log(n) stappen voegtoe 2log(n) stappen

Zoekboom wortel diepte 4 23 15 29 10 3 1 6 11 5 8 18 26 34 14 class Boom : IColl { private string midden; private Boom links, rechts; public int Diepte( ) { if (this==null) return 0; int d1 = links.Diepte(); int d2 = rechts.Diepte(); return Math.Max(d1, d2); } public int Totaal( ) { if (this==null) return 0; int t1 = links.Totaal(); int t2 = rechts.Totaal(); return t1 + t2 + this.midden; } }

Propositie- Formule } /\ /\ \/ not /\ not /\ x \/ z y y z x y interface IFormule { Propositie- Formule string ToString(); void Verzamel(ISet<string>); bool Waarde(Valuatie v); } class ... : IFormule {...} /\ /\ \/ not /\ not /\ x \/ z y y z x y