OBJECT SPAGHETTI : PATTERNS BIEDEN UITKOMST? Wat is het probleem nou eigenlijk? public class CoffeeDrinker { private CoffeeProducer mycoffeeproducer;
|
|
- Anna van Doorn
- 8 jaren geleden
- Aantal bezoeken:
Transcriptie
1 OBJECT SPAGHETTI : PATTERNS BIEDEN UITKOMST? Object georiënteerde (OO) systemen kennen vele voordelen ten opzichte van traditionele procedurele systemen. Zo zouden OO systemen flexibeler en beter onderhoudbaar zijn. In de praktijk valt dat nogal eens tegen. Een van de oorzaken is het niet of onvoldoende scheiden van de objecten - Object Spaghetti - Neem een object en de rest zit er aan vast. Naast hoe je het niet moet doen beschrijft en illustreert dit artikel de mogelijkheden die je als Java Programmeur hebt om deze ellende te omzeilen. Wat is het probleem nou eigenlijk? Een object georiënteerd systeem bestaat uit klassen die elkaar diensten verlenen. Om elkaar diensten te kunnen verlenen moeten ze elkaar kennen (naar elkaar kunnen refereren) Bijvoorbeeld een object dat koffie drinkt (ik!) en een KoffieZetApparaat. Als ik koffie wil drinken heb ik een referentie nodig naar het KoffieZetApparaat en ben ik er dus van afhankelijk. Het betekent ook dat als je de KoffieDrinker wilt compileren je altijd de KoffieZetApparaat klasse nodig hebt. En wat nu als je een keer Espresso wilt? Dan zul je heel je programma moeten aanpassen en opnieuw compileren. Leuk, zul je zeggen, maar daar hebben we in Java interfaces voor. Interfaces maken het mogelijk een onderscheid te maken tussen wat een object kan (zijn methoden) en zijn daadwerkelijke implementatie. Een interface kan dus worden geïmplementeerd door twee verschillende objecten die helemaal niets met elkaar te maken hebben, echter door de interface kunnen ze wel uniform benaderd worden. Laten we een interface CoffieProducer maken die werkt als scheiding tussen mij en het Koffie Zet Apparaat (CoffeeDevice) - zodat we de implementatie kunnen wijzigen zonder dat ik dingen moet leren over andere soorten KoffieZetApparaten. In UML : Helemaal goed! Behalve dan de vraag van hoe komt de CoffeeDrinker aan zijn CoffeeProducer? Dat is lastig want je kunt geen object maken van een interface - daar voor heb je een klasse nodig. En dat is de kern van het probleem - hoe komt een object dat gebruik maakt van een interface aan de implementatie van die interface? Laten we eens wat proberen : public class CoffeeDrinker { private CoffeeProducer mycoffeeproducer; public CoffeeDrinker() { mycoffeeproducer=new CoffeeDevice();
2 public void drink() { System.out.println("Drinking "+mycoffeeproducer.getcoffee()); Of in UML : In dit voorbeeld wordt de CoffeeProducer aangemaakt in de constructor van CoffeeDrinker. Deze oplossing werkt, maar uiteindelijk schiet je er niets mee op, want de CoffeeDrinker heeft nog steeds een harde (statische) afhankelijkheid met het CoffeeDevice. Dat wil zeggen als je CoffeeDrinker compileert heb je nog steeds de CoffeeDevice klasse nodig, terwijl de bedoeling nou net was om dat te voorkomen. Zucht.. Use the Constructor Luke! Een alternatief is om de CoffeeProducer mee te geven als constructor argument : public CoffeeDrinker(CoffeeProducer p) { mycoffeeproducer=p; en bij iedere instantie (instance) die je maakt van CoffeeDrinker een CoffeeProducer mee te geven : CoffeeDrinker drinker=new CoffeeDrinker(new CoffeeDevice()); drinker.drink(); Nou, de CoffeeDrinker is nu niet meer afhankelijk van het CoffeeDevice. Die verantwoordelijkheid ligt nu bij diegene die de CoffeeDrinker construeert. De verantwoordelijkheid is gedelegeerd. Een goede oplossing. Of niet? Dat hangt er een beetje van af aan wie je het delegeert. Als die klasse inderdaad verantwoordelijk is voor de keuze voor het ene of de andere CoffeeProducer dan zou dat best eens kunnen. Doet de klasse echter niet meer dan het doorgeven van de CoffeeProducer dan is de keus twijfelachtig. Echter in beide gevallen is die klasse nogsteeds statisch gelinked. En dat wilden we toch voorkomen? Laten we een kijken of het Singleton pattern oplossing kan bieden.
3 Singleton to the Rescue? Een Singleton biedt toegang tot een enkele (gedeelde) instance van een type zonder te verklappen welk specifiek type dat is. We zouden bijvoorbeeld een CoffeeProducerSingleton kunnen maken welke de code bevat voor het aanmaken van de CoffeeProducer. En dan iedere keer als we de CoffeeProducer willen hebben hem opzoeken door middel van die Singleton. Zeg maar het Java equivalent van de Gouden Gids of Google. Klinkt goed! Laten we eens kijken wat er gebeurt met de afhankelijkheden (dependencies) als we in ons voorbeeld de CoffeeProducer interface voorzien van een Singleton. Zo iets dus : De implementatie van de CoffeeDrinkerSingleton kan als volgt zijn : public class CoffeeProducerSingleton { private static final CoffeeProducer instance=new CoffeeDevice(); public static CoffeeProducer getinstance() { return instance; Met dit als resulterende code in de constructor van CoffeeDrinker : public CoffeeDrinker() { mycoffeeproducer=coffeeproducersingleton.getinstance(); Wat gebeurt er : De CoffeeDrinker wil een CoffeeProducer hebben en vraagt dat aan de CoffeeProducerSingleton. Deze maakt een CoffeeDevice aan (als dat nog niet gebeurt was) en geeft het terug aan de CoffeeDrinker. Het lijkt Goed tm te werken, immers de CoffeeDrinker kent alleen de Interface en de CoffeeProducerSingleton. Echter het probleem wordt verplaatst. De CoffeeProducerSingleton kent op zijn beurt weer het CoffeeDevice. Dus indirect zitten ze toch nog steeds statisch aan elkaar gelinked echter nu via een tussen object. Handige mensen roepen nu : maar waarom gebruik je geen Class.forName("CoffeeDevice").newInstance()?? En inderdaad je kan heel prima via dynamic classloading, zonder direct naar het type te refereren, een instance maken. De vraag is wie je voor de gek houdt op deze manier? Java of Jezelf, aangezien er nog steeds een harde koppeling is ook al
4 wordt deze tijdens het compileren niet meer opgemerkt. Bereid je maar voor op bergen ClassNotFoundExceptions op volslagen onverwachte momenten. Uiteraard kan je de CoffeeDrinker en de CoffeeProducerSingleton weer scheiden door een extra interface toe te voegen maar dan heb je het volgende probleem : Hoe komt de CoffeeDrinker aan zijn CoffeeProducerSingleton? En voor je het weet heb je een CoffeeProducerSingletonSingleton gemaakt... en zoef je eindeloos rond in cirkels. Dit gaat dus niet werken. Op een één of andere manier moeten we dus voor elkaar zien te krijgen dat de Singleton wel het object kan terug geven maar niet de kennis heeft om het object te maken of probeert het aanmaken te delegeren. Mmmm daar heb ik eens wat over gelezen... Service Locator Service Locator is ook wel bekend onder de naam Registry. Eigenlijk een veralgemeende Singleton zonder kennis van specifieke typen. Met een Registry kan je een koppeling maken tussen een (interface) type en een object. Dat betekent dus dat de CoffeeDrinker tegen de Registry kan zeggen 'Welk object hoort bij de interface CoffeeProducer?' en krijgt dan netjes een object van het type CoffeeDevice of ExpressoDevice terug naar gelang welke koppeling er gemaakt is. In UML ziet het er als volgt uit : Zoals je ziet weet de CoffeeDrinker alleen iets over de CoffeeProducer en de Registry. Perfect! En de Registry weet nog minder. Die weet alleen hoe een bepaalde klasse gekoppeld moet worden aan een bepaalde instance maar welke dat nu zijn boeit hem voor geen meter. Waar de kennis dan wel zit? Nou dit is helemaal verschoven naar het initialisatie of start punt van het programma (de 'public static void main(string[] args)' zeg maar) Hier wordt de registry gevuld met de correcte interface/instance waarden. In het onderstaande voorbeeld link ik de CoffeeProducer interface aan een instance van CoffeeDevice. public static void main(string[] args) { Set up Registry.getInstance().register(CoffeeProducer.class,new CoffeeDevice());
5 Drink some Coffee. new CoffeeDrinker().drink(); Een mogelijke implementatie van een Registry is iets in de geest van een HashMap gecombineerd met een Singleton : public class Registry private static Registry myinstance=new Registry(); public static Registry getinstance() { return myinstance; private Map myimpl=new HashMap(); public void register(class atype,object animplementation) { myimpl.put(atype,animplementation); public Object get(class atype) { return myimpl.get(atype); De constructor van CoffeeDrinker ziet er nu als volgt uit : public CoffeeDrinker() { mycoffeeproducer=(coffeeproducer)registry.getinstance().get(coffeeproducer.class); Zoals je ziet lijkt deze constructor erg op het Singleton voorbeeld. De CoffeeProducer referentie wordt opgezocht door het werk uit te besteden aan een derde partij. Echter de derde partij heeft nu tijdens het compileren geen enkele referentie meer naar het CoffeeDevice. Deze kennis wordt pas bekend gemaakt zodra het programma wordt gestart - in de klasse waar de main methode zit (Main in het voorbeeld). En slechts deze klasse heeft de kennis van welke specifieke componenten er gebruikt worden. De rest van de applicatie werkt gescheiden van elkaar via interfaces. Te gek! Dat is precies zoals we wilden! Alhoewel het casten niet zo mooi is.. Maar er is vast wel een slimmerik die daar wat op bedenkt. Massa Productie Er zijn natuurlijk vele wegen die naar een object leiden. En Service Locator is een hele goede. Maar Service Locator heeft wel de beperking dat je er alleen bestaande instances mee kan opzoeken. En niet nieuwe instances mee kan produceren. Verdorie. Wat nu als we (verspilziek dat we zijn :-) iedere keer een nieuw CoffeeDevice nodig zouden hebben? Hoor ik daar iemand 'Factory' roepen? Een Factory is een object dat andere objecten maakt. In Taiwan staat een grote fabriek die koffiezetapparaten maakt. Iets in die geest. Als design pattern heb je er twee verschillende smaken van. Het FactoryMethod pattern - dat object instantiëring delegeert aan een sub-klasse. En de AbstractFactory die een interface definieert waarmee je objecten kan maken. Het Factory Method Pattern
6 Hieronder zie je het UML diagram van het FactoryMethod pattern. Wat op valt is dat CoffeeDrinker een abstracte klasse is geworden en een extra methode definieert : createcoffeeproducer(). Dit is een abstracte (niet geïmplementeerde) methode welke geïmplementeerd moet worden in een sub-klasse van CoffeeDrinker - de CoffeeDeviceDrinker of de EspressoDrinker welke de kennis hebben over welk koffiezetapparaat er gemaakt moet worden. Conceptueel misschien iets minder sterk, maar goed. Het betekent ook dat alhoewel CoffeeDrinker onafhankelijk is, je altijd een sub-klasse nodig hebt als je echt wat wilt doen. De keus voor het soort coffee device wordt gemaakt in de sub klasse. Naast het feit dat je voor iedere nieuwe CoffeeProducer een subclass moet definiëren heb je nu ook afhankelijkheden tussen de CoffeeDrinker en zijn subclasses - wat nadelig kan zijn als je de implementatie van CoffeeDrinker wilt wijzigen. Al met al een beperkte oplossing voor ons probleem. Het Abstract Factory Pattern AbstractFactory gooit er nog een schepje boven op door een aparte interface te definiëren voor het aanmaken van CoffeeDevices. Dit is dus geen doe-het-zelf koffiezetapparaat maar een echte uit Taiwan! De CoffeeDrinker kent alleen de interfaces en krijgt zijn referentie naar de CoffeeProducerFactory via zijn constructor of via de Registry. (Hij maakt in ieder geval niet zelf een Factory aan - want dan heb je weer een statische referentie naar een klasse.) Er zijn twee implementaties van CoffeeProducerFactory - een voor elk koffiezetapparaat. Dus het EspressoDevice wordt gemaakt door de EspressoDeviceFactory. Ze vormen een paar om het zo te zeggen - constructie en gebruik zijn van elkaar gescheiden door twee aparte interfaces. Het toevoegen van een nieuw soort koffiezetapparaat (cappuccino!) kan eenvoudig gedaan worden door twee klassen toe te voegen (CappuccinoDevice en CappuccinoDeviceFactory (made in Italy)). Alle componenten zijn enkel afhankelijk van de interfaces. Een nadeel is wel het aantal klassen wat je nodig hebt om dit voor elkaar te krijgen.
7 Al dat gedoe met factories en de hoeveelheid extra klassen en interfaces die het oplevert doet je afvragen of dit nu niet anders kan, zonder jezelf te moeten verlagen tot Class.forName(). Nu zijn recentelijk de zogenaamde 'Inversion of Control/Dependency Injection' frameworks populair geworden (bijvoorbeeld de PicoContainer en het Spring Framework). Deze frameworks bieden de mogelijkheid om classes te instantiëren zonder direct te specificeren wat de dependencies zijn. Dependency Injection Dependency Injection is een mooie naam voor het instantiëren van een klasse en daarbij het (semi-)automatisch bepalen en toekennen van zijn afhankelijkheden. Het kan op een aantal verschillende manieren gedaan worden. De belangrijkste zijn : Construction Injection, Setter Injection en Interface Injection. De naam verklapt al een hoop over de werking dus ik zal hier alleen ingaan op Constructor Injection. Als je een klasse wilt instantiëren moet je de constructor argumenten weten. Door gebruik te maken van reflectie (in de java.lang.reflect package) kan je bepalen wat de argument typen zijn. Gegeven de argument typen kan je opzoeken welke instanties daarbij horen (bijvoorbeeld door gebruik te maken van een Registry). Concreet in ons voorbeeld : Stel dat we op automagische wijze een de CoffeeDrinker willen instantiëren. De CoffeeDrinker neemt een CoffeeProducer type als argument voor zijn constructor. Als dit interface type geregistreerd is in de Registry dan kunnen we de implementatie er bij zoeken. Dan hebben we dus een waarde voor de constructor van CoffeeDrinker! Dan is het daarna slechts nog een kwestie van de constructor afvuren om een spik splinter nieuwe CoffeeDrinker te maken. Afijn hieronder het proces in 3 stappen gevisualiseerd.
8 De vraag is nu nog even hoe doe je dit in (voorbeeld) code : public class Factory { public Object newinstance(class type) { Constructor[] cs=type.getconstructors(); for (int t=0;t<cs.length;t++) { Class[] types=cs[t].getparametertypes(); Object[] values=new Object[types.length]; if (resolve(types,values)) try { return cs[t].newinstance(values); catch (Exception ex) { throw new RuntimeException("Failed instantiating "+type.getname(),ex); return null; Hierboven wordt via Reflectie de constructors van het gespecificeerde type opgevraagd en daarna wordt per constructor gekeken naar de benodigde argumenten. Wanneer van al deze argument types instanties beschikbaar zijn kan de constructor worden uitgevoerd en het resultaat terug gegeven worden. De resolve methode (onder) is verantwoordelijk voor het opzoeken van de argument waarden in de Registry en ze terug te geven in de value array. protected boolean resolve(class[] types,object[] instances) { Registry r=registry.getinstance(); for(int t=0;t<types.length;t++) { instances[t]=r.get(types[t]); if (instances[t]==null) return false; return true; Uiteraard is dit een heel eenvoudige implementatie die enkel Singleton objecten ondersteunt. Echter het is slechts een klein beetje meer werk om de link interface type -> implementatie type te leggen zodat ook het Factory pattern ondersteunt wordt
9 waarbij het instantiëren wordt overgelaten aan de newinstance methode. Of dat de argumenten uit een een aparte configratie file worden gelezen. Of dat je gebruik maakt van JDK 1.5 annotaties. etc. etc. Maar goed! Genoeg gedroomd - Nu is het tijd voor een bak echte koffie : public static void main(string[] args) { Registry.getInstance().register(CoffeeProducer.class,new CoffeeDevice()); Factory thefactory=new Factory(); CoffeeDrinker drinker=(coffeedrinker)thefactory.newinstance(coffeedrinker.class); drinker.drink(); Eerst registreren we de CoffeeProducer interface en zijn bijbehorende implementatie, het CoffeeDevice in de Registry. Dan bouwen we de klasse die de slimmigheid bevat en daarna roepen we deze aan. De methode newinstance loopt alle constructors af (er is er maar één) en kijkt of de argumenten van die constructor vervuld kunnen worden door de types op de zoeken in de Registry. Gelukkig bestaat er een instantie van de CoffeeProducer. Het resultaat : een compleet geconfigureerd CoffeeDrinker object. Als we wat we gemaakt hebben nu in een UML vorm gieten dan ontstaat een interessant plaatje : Er is nu scheiding ontstaan tussen applicatie specifieke klassen (de onderste helft), de framework klassen (Factory en Registry) en de Initialisatie (Main). Enkel de Main klasse heeft alle kennis in zich van de applicatie. De overige klassen zijn of onwetend of netjes gescheiden via interfaces. State of the art technology.. of niet?
10 Er is altijd een prijs te betalen voor het gebruik van frameworks die werken via reflectie. Ze zijn langzamer ten opzichte van echte implementaties. Daarnaast zijn ze ook een stuk ondoorzichtiger. Dat betekent als je aan het debuggen gaat en er wordt ergens een nieuw object gemaakt dat je eerst door een zooi reflectie code heen moet - dat is niet prettig. Conclusie : Als we flexibele software willen schrijven dan is het verstandig om de onderdelen te scheiden door middel van interfaces. Echter we hebben gezien dat het gebruik van interfaces niet automatisch leidt tot flexibele software. Het feit dat je concreet een type moet kennen om er een object van te kunnen maken gooit roet in het eten. Er zijn drie strategieën die gebruikt kunnen worden afhankelijkheden te ontkoppelen : Weten - waarin via overerving in de afhankelijkheid word voldaan. Het FactoryMethod pattern doet dit bijvoorbeeld. Uiteraard blijven de subklassen wel sterk verbonden met de originele ontkoppelde klasse, wat een nadeel kan zijn. Opzoeken - waarin het object zelf opzoek gaat naar zijn afhankelijkheden. Met behulp van een Service Locator is dit mogelijk. Met deze methode houdt je altijd een enkel centraal (maar wel neutraal!) type over waarin de interfaces en implementaties samen komen. Vertellen - het object wordt verteld wat zijn afhankelijkheden zijn door middel van zijn constructor en/of een setter methods. Door middel van Dependency Injectie kan dit nagenoeg transparant zonder eindeloos parameters te hoeven doorgeven van de ene naar de andere constructor. Een alternatief vormt de AbstractFactory waarbij het aanmaken van het object wordt geabstraheerd achter een interface (waar je natuurlijk weer een implementatie van moet zien te krijgen) De prijs die voor het ontkoppelen betaalt moet worden is afhankelijk van de gekozen technologie. Bij het gebruik van het AbstractFactory pattern zegt de (vele) code duidelijk wat het doet. Bij Dependency Injection gebeurt een hoop onderwater via reflectie - ondoorzichtig - echter het is wel een manier waarbij je veel code kunt vervangen door initialisatie en configuratie. Erik Hooijmeijer Ctrl-Alt-Dev Erik Hooijmeijer is senior developer bij 42 B.V. Naast het ontwerpen en bouwen van bedrijfs kritische toepassingen in Java is hij altijd bezig met de ontwikkeling van zogenaamde speelbare concepten.
Datatypes Een datatype is de sort van van een waarde van een variabele, veel gebruikte datatypes zijn: String, int, Bool, char en double.
Algemeen C# Variabele Een variabele is een willekeurige waarde die word opgeslagen. Een variabele heeft altijd een datetype ( De soort waarde die een variabele bevat). Datatypes Een datatype is de sort
Nadere informatieIMP Uitwerking week 13
IMP Uitwerking week 13 Opgave 1 Nee. Anders moet bijvoorbeeld een venster applicatie een subklasse zijn van zowel Frame en WindowListener. Als de applicatie ook een button of een menu heeft, dan moet het
Nadere informatieZelftest Programmeren in Java
Zelftest Programmeren in Java Document: n0883test.fm 22/01/2013 ABIS Training & Consulting P.O. Box 220 B-3000 Leuven Belgium TRAINING & CONSULTING INLEIDING BIJ DE ZELFTEST PROGRAMMEREN IN JAVA Deze test
Nadere informatieKleine cursus PHP5. Auteur: Raymond Moesker
Kleine cursus PHP5 Auteur: Raymond Moesker Kleine cursus PHP PHP is platform en CPU onafhankelijk, open source, snel, heeft een grote userbase, het is object georiënteerd, het wordt omarmd door grote bedrijven
Nadere informatieDesign patterns Startbijeenkomst
Design patterns Startbijeenkomst Harrie Passier Docenten Sylvia Stuurman (1 e examinator) Sylvia.Stuurman@ou.nl Harrie Passier (2 e examinator) Harrie.Passier@ou.nl Aarzel niet vragen te stellen! Rooster
Nadere informatieUnit testen van EJB's. Koert Zeilstra - iprofs
Unit testen van EJB's Koert Zeilstra - iprofs Inleiding We weten tegenwoordig allemaal dat we ons product moeten testen om de kwaliteit te verhogen en behouden Software-ontwikkelaars zijn over het algemeen
Nadere informatieOntwerp van Informatiesystemen
1ste bach HIB Ontwerp van Informatiesystemen Prof. Verelst Q www.quickprinter.be uickprinter Koningstraat 13 2000 Antwerpen 112 2,50 Online samenvattingen kopen via www.quickprintershop.be Table of Contents
Nadere informatieUniversiteit van Amsterdam FNWI. Voorbeeld van tussentoets Inleiding programmeren
Universiteit van Amsterdam FNWI Voorbeeld van tussentoets Inleiding programmeren Opgave 1: Wat is de uitvoer van dit programma? public class Opgave { static int i = 0 ; static int j = 1 ; int i = 1 ; int
Nadere informatieOvererving & Polymorfisme
Overerving & Polymorfisme Overerving Sommige klassen zijn speciaal geval van andere klasse Docent is een speciaal geval van werknemer, dwz. elke docent is ook werknemer Functionaliteit van docent = functionaliteit
Nadere informatieDesign patterns.
Design patterns joost.vennekens@mechelen.lessius.eu Wat zijn dat? Programma zit niet goed in elkaar Zondigt tegen ontwerpprincipes En dat zorgt voor probleem Ontwerppatroon: standaard oplossing voor een
Nadere informatieVoorbeeldtentamen Inleiding programmeren (IN1608WI), Oktober 2003, , Technische Universiteit Delft, Faculteit EWI, Afdeling 2.
Voorbeeldtentamen Inleiding programmeren (IN1608WI), Oktober 2003, 14.00-15.30, Technische Universiteit Delft, Faculteit EWI, Afdeling 2. Dit tentamen bestaat uit twee delen. Deel 1 (14.00-14.45, gesloten
Nadere informatieTentamen Imperatief Programmeren
Tentamen Imperatief Programmeren Maandag 22 oktober 2001 Toelichting Dit is een open boek tentamen, d.w.z. het cursusboek mag gebruikt worden. N.B.: Het tentamen is individueel: voor het maken van de opgaven
Nadere informatieDIAGNOSTISCHE TOETS Softwaresystemen UITWERKING
DIAGNOSTISCHE TOETS Softwaresystemen datum: Donderdag van Week 7 UITWERKING Deze diagnostische toets bevat vragen over excepties en concurrency. Beantwoord de vragen zo goed mogelijk in 30 minuten Bespreek
Nadere informatieTentamen Object Georiënteerd Programmeren TI1206 29 oktober 2014, 9.00-11.00 Afdeling SCT, Faculteit EWI, TU Delft
Tentamen Object Georiënteerd Programmeren TI1206 29 oktober 2014, 9.00-11.00 Afdeling SCT, Faculteit EWI, TU Delft Bij dit tentamen mag je geen gebruik maken van hulpmiddelen zoals boek of slides. Digitale
Nadere informatieUitwerking Aanvullend tentamen Imperatief programmeren Woensdag 24 december 2014, 13.30 15.30 uur
Uitwerking Aanvullend tentamen Imperatief programmeren Woensdag 24 december 2014, 13.30 15.30 uur 1. deze opgave telt voor 30% van het totaal. Schrijf een compleet programma, dat door de gebruiker vanaf
Nadere informatieINFITT01 - Internettechnologie WEEK 8
INFITT01 - Internettechnologie WEEK 8 Programma Databases (JDBC, JNDI, ORM, JPA) MVC & Spring/Struts EJB Databases Veel web applicaties moeten informatie over langere tijd op kunnen slaan. Een voor de
Nadere informatieObjectgeorïenteerd werken is gebaseerd op de objecten die door het systeem gemanipuleerd worden.
Herhaling Objectgeorïenteerd werken is gebaseerd op de objecten die door het systeem gemanipuleerd worden. De basisbouwsteen is het object; een geïntegreerde eenheid van data en operaties werkend op deze
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 6 december 2013 Terugblik Programma en geheugen Opdrachten Variabelen Methoden Objecten Klasse Programma en geheugen Opdrachten Variabelen zijn gegroepeerd in
Nadere informatieObject Oriented Programming
Object Oriented Programming voor webapplicaties Door Edwin Vlieg Waarom OOP? Basis uitleg over OOP Design Patterns ActiveRecord Model View Controller Extra informatie Vragen OOP Object Oriented Programming
Nadere informatieJava. Basissyllabus. Egon Pas
Java Basissyllabus Egon Pas 2011 BeanPole bvba Gasmeterlaan 92-9000 Gent BTW BE 472.902.516 Tel: + 32 9 224 42 17 Fax: + 32 9 223 62 88 www.beanpole.be info@beanpole.be 1 Programmeren 1.1 Hoe werkt een
Nadere informatieInformatica. Objectgeörienteerd leren programmeren. Van de theorie met BlueJ tot een spelletje met Greenfoot... Bert Van den Abbeele
Informatica Objectgeörienteerd leren programmeren Van de theorie met BlueJ tot een spelletje met Greenfoot... Bert Van den Abbeele http://creativecommons.org/licenses/by-nc-nd/3.0/legalcode Objectgeörienteerd
Nadere informatieProgrammeren in Java 3
26 september 2007 Deze les korte herhaling vorige les Unified Modelling Language notatie van een class afleiding pointers abstracte classes polymorphisme dubieuze(?) constructies interfaces Meer over class
Nadere informatieProgrammeren in Java 3
2 september 2007 voor deeltijdstudenten Kop van Zuid Rotterdam, 3 juni 2007 Even voorstellen Naam: Wessel Oele(31) Docent bij opleiding technische informatica Kamer: I210 (tweede verdieping, links de gang
Nadere informatieAbstracte klassen & Interfaces
Abstracte klassen & Interfaces Overerving public class Vierhoek {... Vierhoek public class Rechthoek extends Vierhoek {... public class Ruit extends Vierhoek {... Rechthoek Ruit Elke rechthoek is een vierhoek.
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 11 december 2015 Ingebouwde datastructuren Meer boomstructuren Access specifiers Gebruikersinvoer Codestijl Packages SAT-solver Ingebouwde datastructuren Ingebouwde
Nadere informatieScala. Korte introductie. Sylvia Stuurman
Korte introductie Sylvia Stuurman Wat is er zo bijzonder aan? Schaalbaar Objectgeoriënteerd (handiger dan Java!) Functioneel Scripts schrijven Gecompileerd: Java bytecode Pagina 2 voor scripts Pagina 3
Nadere informatieVI. Klassen en objecten
VI. Klassen en objecten Klassen en objecten vormen het fundament van OOP. We zullen dus uitgebreid aandacht besteden aan klassen en objecten. U kunt Java niet begrijpen zonder goed met klassen en objecten
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 18 december 2015 Overerving (inheritance) Constructors Overriding Inheritance demo Exceptions Zelf exceptions veroorzaken Overerving (inheritance) 2-dimensionaal
Nadere informatieVerder zijn er de nodige websites waarbij voorbeelden van objectgeoriënteerd PHP (of Objec Oriented PHP, OO PHP) te vinden zijn.
Objectgeoriënteerd PHP (versie 5) Kennisvereisten: Ervaring met programmeren in PHP met MySQL Je weet wat een class of klasse is Je weet wat een instantie van een klasse (een object) is Je weet wat een
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 13 december 2013 Terugblik Fibonacci public class Fibonacci { public static void main(string[] args) { // Print het vijfde Fibonaccigetal System.out.println(fib(5));
Nadere informatieProgrammeren 1 20 januari 2012 Prof. T. Schrijvers
Programmeren 1 20 januari 2012 Prof. T. Schrijvers Instructies Schrijf al je antwoorden op deze vragenbladen (op de plaats die daarvoor is voorzien). Geef ook je kladbladen af. Bij heel wat vragen moet
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 27 november 2015 Recursie Objecten Constructors Aanpassen variabelen this keyword Recursie Recursie Recursieve functie roept zichzelf (direct of indirect) aan
Nadere informatieNoties Informatica. In java fungeren objecten als een model voor de elementen waarin een probleem kan worden opgesplitst
s Informatica Hoofdstuk 1 Object Klasse Methode Parameters Type Velden Toestand Compiler Resultaten (returnwaarde) In java fungeren objecten als een model voor de elementen waarin een probleem kan worden
Nadere informatieHoofdstuk 1: Inleiding. Hoofdstuk 2: Klassen en objecten Datahiding: afschermen van implementatiedetails. Naar de buitenwereld toe enkel interfaces.
Hoofdstuk 1: Inleiding Objectoriëntatie: 1. Objecten & klassen: samenwerking van componenten om bepaald doel te bereiken; herbruikbaarheid. 2. Encapsulation: afschermen gedragingen en kenmerken van de
Nadere informatieIngebouwde klassen & methodes
Ingebouwde klassen & methodes Statische methodes Methodes die bij een klasse horen ipv. bij een object public class Docent { public static Docent departementshoofd() { return new Docent("Jan Ivens"); private
Nadere informatieStacks and queues. Introductie 45. Leerkern 45. Terugkoppeling 49. Uitwerking van de opgaven 49
Stacks and queues Introductie 45 Leerkern 45 6.1 Stacks 45 6.2 Queues 47 6.3 Double-ended queues 48 Terugkoppeling 49 Uitwerking van de opgaven 49 Bijlage: Diagrammen belangrijkste interfaces en klassen
Nadere informatie1 Ontwerppatronen. 1.1 Het Command patroon
1 Ontwerppatronen Software-ontwikkelaars worden geconfronteerd met ontwerpproblemen: de manier waarop ze hun programma gestructureerd hebben geeft aanleiding tot slechte eigenschappen zoals rigiteit, fragiliteit,....
Nadere informatieDeel 1 : Gesloten Boek
Naam : EXAMEN SOFTWAREONTWIKKELING 1STE PROEF BURG. IR. COMPUTERWETENSCHAPPEN EERSTE EXAMENPERIODE ACADEMIEJAAR 2004-2005 Deel 1 : Gesloten Boek 1. Testen Geef een overzicht van de verschillende testen
Nadere informatieDerde deeltentamen Gameprogrammeren Vrijdag 7 november 2014, uur
Naam: Derde deeltentamen Gameprogrammeren Vrijdag 7 november 2014, 11.00-13.00 uur Studentnummer: Het tentamen bestaat uit 3 opgaven. Opgaven 1 levert 20 punten op, opgave 2 levert 10 punten op, en opgave
Nadere informatieVakgroep CW KAHO Sint-Lieven
Vakgroep CW KAHO Sint-Lieven Objecten Programmeren voor de Sport: Een inleiding tot JAVA objecten Wetenschapsweek 20 November 2012 Tony Wauters en Tim Vermeulen tony.wauters@kahosl.be en tim.vermeulen@kahosl.be
Nadere informatieModeleren. Modelleren. Together UML. Waarvan maken we een model? overzicht les 14 t/m 18. ControlCenter 6.2
Modelleren Werkelijkheid Modelleren Modeleren Waarvan maken we een model?!analyse " Maak een model van de te automatiseren werkelijkheid of van het op te lossen probleem! Domeinkennis = structuur! Functionele
Nadere informatieMethods of Development
Methods of Development College 4 OO & Tentamenstof Arjan Scherpenisse arjan.scherpenisse@kmt.hku.nl @acscherp Deze week Object-oriëntatie Herhaling vorige week Compositie De Opdracht Tentamenstof overview
Nadere informatieTentamen Imperatief en Object-georiënteerd programmeren in Java voor CKI
Tentamen Imperatief en Object-georiënteerd programmeren in Java voor CKI Vrijdag 22 januari 2010 Toelichting Dit is een open boek tentamen. Communicatie en het gebruik van hulpmiddelen zijn niet toegestaan.
Nadere informatieVeel succes! 1. Gegeven is de volgende klasse:
Dit tentamen is in elektronische vorm beschikbaar gemaakt door de TBC van A Eskwadraat. A Eskwadraat kan niet aansprakelijk worden gesteld voor de gevolgen van eventuele fouten in dit tentamen. Derde deeltentamen
Nadere informatieKlassen & objecten, overerving, abstracte klassen, debuggen, interfaces, formulieren, polymorfie, statische methoden, event-handlers
1 Inhoud Klassen & objecten, overerving, abstracte klassen, debuggen, interfaces, formulieren, polymorfie, statische methoden, event-handlers 2 Geluidsbronnen simulator, deel 2 Inleiding De weergave versnellen
Nadere informatieSYNTRA-WEST. Cursus OOP. Deel
SYNTRA-WEST Cursus OOP Deel Syntra-West voorheen VORMINGSINSTITUUT VOOR KMO Syntra-West Doorniksesteenweg 220 8500 Kortrijk Tel. 056/26.02.00 Fax 056/22.81.07 i Inhoudsopgave SYNTRA-WEST... 0 CURSUS OOP...
Nadere informatieDIA Opdracht 4 (Arjan Dekker)
DIA Opdracht 4 (Arjan Dekker) Place klasse: #Deze klasse wordt gebruikt in zowel de client als de server #Daarom deze klasse in apart bestand gezet, die geinclude wordt #door zowel de server als client
Nadere informatieUitwerkingen Tweede deeltentamen Imperatief programmeren Vrijdag 15 oktober 2010, 11.00-13.00 uur
Uitwerkingen Tweede deeltentamen Imperatief programmeren Vrijdag 15 oktober 2010, 11.00-13.00 uur 1. (2 punten per deelvraag) Deze opgave bestaat uit een aantal tekstvragen. Houd het antwoord kort: een
Nadere informatieNAAM: Programmeren 1 Examen 21/01/2011
Programmeren 1 21 januari 2011 Prof. T. Schrijvers Instructies Schrijf al je antwoorden op deze vragenbladen (op de plaats die daarvoor is voorzien). Geef ook je kladbladen af. Bij heel wat vragen moet
Nadere informatiepublic Paneel() { knop = new JButton( Klik ); knop.addactionlistener( new KnopHandler() ); tekstvak = new JTextField(10); add(knop); add(tekstvak);
Vaknaam: Programmeren I (Java) - Tentamen Module: 2 Datum/Tijd: 17 mrt 2015 / 18.30 20:30 Richting: ICT Code: IC011 Docent: E. Lieuw Boeken en aantekeningen NIET toegestaan. Kladpapier is wel toegestaan.
Nadere informatieUitwerking Tweede deeltentamen Imperatief programmeren - versie 1 Vrijdag 21 oktober 2016, uur
Uitwerking Tweede deeltentamen Imperatief programmeren - versie 1 Vrijdag 21 oktober 2016, 13.00-15.00 uur 1. De situatie die ontstaat door class A : B C D; kan beschreven worden door (a) B is een A (b)
Nadere informatieVereiste kennis. 1 Java-editor. 2 Het compileren van een programma
3 Vereiste kennis Dit boek richt zich op het leren programmeren door het oefenen met programmeercodes. Veel theorie komt in het begin niet aan de orde. Dat is een grote uitdaging want het is niet makkelijk
Nadere informatieDesign principes.
Design principes joost.vennekens@kuleuven.be Motivatie Software projecten mislukken vaker Vaker dan bouwkunde Vaker dan EM Vaker dan Oorzaak? Omgaan met verandering Vereisten Technologie Externe systemen
Nadere informatieObjectgeoriënteerd programmeren in Java 1
Objectgeoriënteerd programmeren in Java 1 CPP Javaprogrammeur Bijeenkomst 3 Leereenheden 7, 8, 9 De Java API Java bevat een grote bibliotheek standaardklassen: de Java API Voorbeelden java.lang basisklassen
Nadere informatieEen topprogrammeur in het OO programmeren is Graig Larman. Hij bedacht de volgende zin:
Java Les 2 Theorie Beslissingen Algemeen Net als in het dagelijks leven worden in software programma s beslissingen genomen, naast het toekennen van waarden aan variabelen zijn beslissingen één van de
Nadere informatieIn een klassendiagram worden klassen beschreven in termen
Sander Hoogendoorn is Partner bij Ordina Patterns voor het gebruik van referenties in bedrijfsklassen G O E D G E B R U I K VA N R E F E R E N T I E S In de dagen dat applicaties voornamelijk bestonden
Nadere informatieDynamisch Programmeren. Het Rugzakprobleem
INLEIDING Dynamisch Programmeren 1 Dynamisch Programmeren Section Page Inleiding................................................. 1 1 Oplossing................................................ 2 2 Subprobleem.............................................
Nadere informatieNAAM: Programmeren 1 Examen 29/08/2012
Programmeren 29 augustus 202 Prof. T. Schrijvers Instructies Schrijf al je antwoorden op deze vragenbladen (op de plaats die daarvoor is voorzien). Geef ook je kladbladen af. Bij heel wat vragen moet je
Nadere informatieVersie 2: B C D D A C D A C C. Versie 3: C D A A B D A B D D. Versie 4: A D C C B D C B D D. Versie 5: B A D D C A D C A A
Uitwerking Tweede deeltentamen Mobiel programmeren - versie 1 Vrijdag 1 februari 2019, 11.00 13.00 uur Voor de meerkeuzevragen hebben we verschillende versies. Dit zijn de juiste antwoorden per versie.
Nadere informatieInhoudsopgave. Hoofdstuk 1.RMI...2
- CORBA Inhoudsopgave Hoofdstuk 1.RMI...2 1.1.Inleiding...2 1.2.De remote...4 1.3.Het remote...5 1.4.De server...6 1.5.De server opstarten...8 1.6.De client applicatie...8 1.7.De stub en skeleton en...10
Nadere informatieProgrammeren in Java les 3
4 september 2015 Deze les korte herhaling vorige week loops methodes Variabelen Soorten variabelen in Java: integer: een geheel getal, bijv. 1,2,3,4 float: een gebroken getal, bijv. 3.1415 double: een
Nadere informatieOmschrijf bij ieder onderdeel van de methode de betekenis ervan. Java kent twee groepen van klassen die een GUI kunnen maken: awt en swing.
irkel (met Jpanel) ij de onderstaande opdracht behoort het bestand Panels: JPanels_1.java (map Panel) in de map irkel. pplicaties in Java hebben altijd een publieke klasse waarin een methode main voorkomt.
Nadere informatieProgrammeren I. 26 augustus Algemene Richtlijnen. Richtlijnen Programmeren 1
Algemene Richtlijnen Programmeren I 26 augustus 2015 Schrijf je naam bovenaan elk antwoordblad en kladblad. Schrijf niet met potlood of in het rood op je antwoordbladen. Gebruik voor elke vraag een afzonderlijk
Nadere informatieDergelijke functionaliteit kunnen we zelf ook aan eigen code toevoegen.
Indexers in C#.Net In deze tutorial ga ik het hebben over indexers. Bij het gebruik van bijvoorbeeld een ArrayList object, kan je de gegevens uit deze collectie opvragen als ware het een array. // ArrayList
Nadere informatieIn BlueJ. Doe onderstaande met muis/menu s:
In BlueJ Doe onderstaande met muis/menu s: Download en unzip het bestand sklok-run.zip en open het in BlueJ Maak een Schaakklok-object Voer herstart() uit voor dit object Vraag de resterende tijd op voor
Nadere informatieElementary Data Structures 3
Elementary Data Structures 3 Ferd van Odenhoven Fontys Hogeschool voor Techniek en Logistiek Venlo Software Engineering 29 september 2014 ODE/FHTBM Elementary Data Structures 3 29 september 2014 1/14 Meer
Nadere informatieModelleren en Programmeren
Modelleren en Programmeren Jeroen Bransen 25 november 2015 Herhaling Meer herhaling Recursie Mutuele recursie Objecten Herhaling Fibonacci class Fibonacci { public static void fibonaccitot(int bovengrens)
Nadere informatieTentamen Object Georiënteerd Programmeren TI1200 30 januari 2013, 9.00-12.00 Afdeling SCT, Faculteit EWI, TU Delft
Tentamen Object Georiënteerd Programmeren TI1200 30 januari 2013, 9.00-12.00 Afdeling SCT, Faculteit EWI, TU Delft Bij dit tentamen mag je geen gebruik maken van hulpmiddelen zoals boek of slides. Dit
Nadere informatieEen gelinkte lijst in C#
Een gelinkte lijst in C# In deze tutorial ga demonstreren hoe je een gelinkte lijst kan opstellen in C#. We gaan een klasse schrijven, die een gelijkaardige functionaliteit heeft als een ArrayList, namelijk
Nadere informatieTentamen Objectgeorienteerd Programmeren TI februari Afdeling ST Faculteit EWI TU Delft
I ' Tentamen Objectgeorienteerd Programmeren TI 1200 1 februari 2012 9.00-12.00 Afdeling ST Faculteit EWI TU Delft Bij dit tentamen mag je geen gebruik maken van hulpmiddelen zoals boek of slides. Dit
Nadere informatieProject network. Gebaseerd op paragrafen , uit het boek. We simuleren een sociaal netwerk
Project network Gebaseerd op paragrafen 10.1-10.7, 11.1-11.6 uit het boek. We simuleren een sociaal netwerk Er zijn twee soorten berichten: tekstberichten en fotoberichten,... voorgesteld door de klassen
Nadere informatieHOGESCHOOL VAN AMSTERDAM Informatica Opleiding. CPP 1 van 10
CPP 1 van 10 ADSdt 1-2009 TENTAMENVOORBLAD Voor aanvang van het tentamen s.v.p. de tentamengegevens goed doorlezen om eventuele misverstanden te voorkomen!! Naam student : Studentnummer : Groep : Studieonderdeel
Nadere informatieDeel II: Modelleren en software ontwikkeling. Hoofdstuk 7 Software ontwikkeling - Overzicht. Naïeve benadering
Deel II: Modelleren en software ontwikkeling Hoofdstuk 7 Software ontwikkeling - Overzicht 2005 Prof Dr. O. De Troyer, pag. 1 Naïeve benadering De vereisten voor het systeem worden geformuleerd en op basis
Nadere informatieDerde deeltentamen Gameprogrammeren Vrijdag 9 november 2012, uur
Naam: Derde deeltentamen Gameprogrammeren Vrijdag 9 november 2012, 8.30-10.30 uur Studentnummer: Het tentamen bestaat uit 2 opgaven. Opgaven 1 levert 15 punten op. Opgave 2 levert 25 punten op. Je cijfer
Nadere informatieTentamen Inleiding Programmeren (IN1608WI), duur van de toets 2 uur Technische Universiteit Delft, Faculteit EWI, Afdeling 2.
Tentamen Inleiding Programmeren (IN1608WI), duur van de toets 2 uur Technische Universiteit Delft, Faculteit EWI, Afdeling 2. Gesloten boek examen: er mag geen gebruik worden gemaakt van het studieboek.
Nadere informatieProgrammeren in C# Interfaces. Hoofdstuk 23
Programmeren in C# Interfaces Hoofdstuk 23 Programmeren in C# 2 Gradaties overerving Klassieke overerving Iets functioneels uitbreiden Code duplicatie Niet teveel aanpassingen aan bestaande code Objecten
Nadere informatieASP.NET Test 2009-2010. Jan Van Ryckeghem
ASP.NET Test 2009-2010 Jan Van Ryckeghem Inhoud Exceptionhandling H4... 3 Try Catch slide 25... 3 Error pagina slide 29... 3 Error.aspx... 3 Error.aspx.cs... 4 Web.config... 4 Logbestand aanmaken... 4
Nadere informatieEen fragment wordt afgeleid van de basis klasse "Fragment".
Android fragmenten 1/5 Fragmenten Klasse Een fragment wordt afgeleid van de basis klasse "Fragment". package com.android.cursustekst; import java.text.simpledateformat; import java.util.arraylist; import
Nadere informatieInformatica. Deel II: les 1. Java versus Python. Jan Lemeire Informatica deel II februari mei 2015. Parallel Systems: Introduction
Informatica Deel II: les 1 Java versus Python Jan Lemeire Informatica deel II februari mei 2015 Parallel Systems: Introduction Arabidopsis (zandraket) Arabidopsis (zandraket) MMIQQA Multimodal Microscopic
Nadere informatieNAAM: Programmeren 1 Examen 31/08/2011
Programmeren augustus 0 Prof. T. Schrijvers Instructies Schrijf al je antwoorden op deze vragenbladen (op de plaats die daarvoor is voorzien). Geef ook je kladbladen af. Bij heel wat vragen moet je zelf
Nadere informatieHoofdstuk 0. Van Python tot Java.
Hoofdstuk 0. Van Python tot Java. In dit eerste hoofdstuk maken we de overstap van Python naar Java. We bespreken de verschillen en geven wat achtergrondinformatie. In het volgende hoofdstuk gaan we dieper
Nadere informatieINFORMATICA 1STE BACHELOR IN DE INGENIEURSWETENSCAPPEN
INFORMATICA 1STE BACHELOR IN DE INGENIEURSWETENSCAPPEN voorbeeldexamen NAAM :... OPMERKINGEN VOORAF Je krijgt 3 uur de tijd om de opdrachten voor dit examen uit te voeren. Verder werken aan je oplossing
Nadere informatieObject Oriented Ontwerp. Yannick Reekmans
Yannick Reekmans 2008-2009 22 september 2008 Head First Java (hfstk. 6 blz. 125-164): Arrays & ArrayList; DotComBust game code nakijken Head First Java (hfstk. 10 blz. 302-306): Working with dates Head
Nadere informatieDit document bevat informatie over make bij het eerstejaars college Programmeermethoden, Universiteit Leiden, najaar 2010, zie
Dit document bevat informatie over make bij het eerstejaars college Programmeermethoden, Universiteit Leiden, najaar 2010, zie www.liacs.nl/home/kosters/pm/ Met dank aan allen die aan deze tekst hebben
Nadere informatieDesign principes.
Design principes joost.vennekens@kuleuven.be Doelstelling Code die werkt doet wat klant wil betrouwbaar is gemakkelijk te veranderen is En dit ook blijft doen Software rot Rottende software geeft geurtjes
Nadere informatieDonderdag 9 juni, 2011, 8u30. a. Leg uit wat de Coupling Dependency Metric betekent, en waarom deze metriek belangrijk is.
EXAMEN SOFTWAREONTWIKKELING [II] 2 DE BA. INFORMATICA 3 DE BA. INGENIEURSWETENSCHAPPEN : COMPUTERWETENSCHAPPEN EERSTE EXAMENPERIODE ACADEMIEJAAR 2010 2011 Donderdag 9 juni, 2011, 8u30 Naam en richting
Nadere informatieProgrammeren in Java 3
7 maart 2010 Deze les Zelf componenten maken Concurrency (multithreading): werken met threads levenscyclus van een thread starten tijdelijk onderbreken wachten stoppen Zelf componenten maken Je eigen component:
Nadere informatieAan het eind van deze lesbrief wordt uitgelegd wat het nut van OOP is en vind je een aantal oefenopdrachten.
Doel van deze lesbrief Deze lesbrief is bedoeld om je op de hoogte te brengen van de basisbegrippen die gangbaar zijn bij object georiënteerd programmeren (OOP). In deze lesbrief kom je korte codefragmenten
Nadere informatieEen stoomcursus door Edgar de Graaf, november 2006
Programmeren in Java Een stoomcursus door Edgar de Graaf, november 2006 Deze tekst geeft een zeer korte inleiding in de programmeertaal Java, uitgaande van kennis van de taal C++. Daarnaast bestudere men
Nadere informatieDeeltentamen Grammatica s en ontleden 22 december 2005
Tentamen Grammatica s en ontleden 22 december 2005 1 Deeltentamen Grammatica s en ontleden 22 december 2005 Let op: opgave 1 t/m 4 tellen voor (slechts) 5 punten mee, opgave 5 voor maar liefst 50 punten,
Nadere informatieDe Vergeten Abstracties
De Vergeten Abstracties Cesario Ramos Senior Consultant bij Xebia B.V. 2009 Inleiding Rollen zijn een belangrijk concept in object georiënteerde software ontwikkeling dat vaak vergeten wordt. Het gebruik
Nadere informatieTechnisch Ontwerp W e b s i t e W O S I
Technisch Ontwerp W e b s i t e W O S I WOSI Ruud Jungbacker en Michael de Vries - Technisch ontwerp Website Document historie Versie(s) Versie Datum Status Omschrijving / wijzigingen 0.1 20 nov 2008 Concept
Nadere informatieIs het mogelijk een aparte categorie te maken waar allerlei vragen en antwoorden omtrent webdesign geplaatst kunnen worden?
Aparte categorie voor webdesign mogelijk? Geschreven door Eckie76-21/07/2008 16:17 Is het mogelijk een aparte categorie te maken waar allerlei vragen en antwoorden omtrent webdesign geplaatst kunnen worden?
Nadere informatieNHibernate als ORM oplossing
NHibernate als ORM oplossing Weg met de SQL Queries Wat is ORM? ORM staat in dit geval voor Object Relational Mapping, niet te verwarren met Object Role Modeling. ORM vertaalt een objectmodel naar een
Nadere informatieet Zend Framework bestaat volledig uit objectgeoriënteerde
et Zend Framework bestaat volledig uit objectgeoriënteerde PHP-code. Om het Zend Framework goed te kunnen begrijpen en te kunnen gebruiken, moet u minimaal de basis van objectgeoriënteerd programmeren
Nadere informatieProgrammeren in C# Klassen schrijven
Programmeren in C# Klassen schrijven In dit hoofdstuk Klassestructuur Private variabelen Publieke methoden (public) Properties Constructormethodes Private methodes (private) Static methodes en properties
Nadere informatieCorrespondentie inzake overnemen of reproductie kunt u richten aan:
Vrijwel alle namen van software- en hardwareproducten die in deze cursus worden genoemd, zijn tegelijkertijd ook handelsmerken en dienen dienovereenkomstig te worden behandeld. Alle rechten voorbehouden.
Nadere informatieProgrammeren (1) Examen NAAM:
Schrijf al je antwoorden op deze vragenbladen (op de plaats die daarvoor is voorzien) en geef zowel klad als net af. Bij heel wat vragen moet je zelf Java-code schrijven. Hou dit kort en bondig. Je hoeft
Nadere informatieJava spiekbrief. Commentaar. Definitie van een methode. Types. Variabelendeclaratie. Definitie van een klasse. Namen. Definitie van een veld
Java spiekbrief Commentaar Dient enkel voor de menselijke lezer. // tot het einde van de lijn /* Dit type commentaar kan gerust meerdere lijnen beslaan. */ /** En deze speciale vorm wordt gebruikt voor
Nadere informatie