De prof heeft dit jaar het volledige examen van vorig jaar (dus 09) online gezet
kga straks eens kijken om dat ook nog ergens online te smijten (nu staat het op minerva, maar mss dat hij dat volgende jaren niet meer doet)
Ik heb dat eens snel ingevuld daarnet, en er is mij gevraagd om mijn antwoorden eens door te spelen
ik beweer niet dat deze antwoorden correct zouden zijn, en soms heb ik maar heel kort iets opgeschreven en gedacht "op het echte examen zal ik dat wel wat verder uitschrijven"
als ge mij op fouten zou betrappen of uitbreidingen hebt moogt ge dat uiteraard altijd laten weten in deze thread (graag zelfs)
verder moogt ge deze antwoorden beschouwen als beerware
(i.e. als ge het nuttig vond moogt ge mij altijd eens trakteren
)
vraag 1 a : software proces : het hele proces dat leidt tot een werkend stuk software
b : vastleggen wat de te bouwen software exact dient te doen
c : fouten in de ontwerpstappen worden veel sneller gevonden en kunnen dus veel sneller en goedkoper opgelost worden
klanten krijgen veel vroeger een (gedeeltelijke) versie van de software, dus als er iets fout gecommuniceerd werd kan dat vroeger opgelost worden
[eigenlijk moet hier ook de "early return on investment" vermeld worden]
vraag 2a : de deelnemer heeft
- login
- start kwis
- beantwoord vraag
- vraag score op
de admin :
- defineer vraag
- stel kwis samen
- vraag score op
b :
- Code: Select all
-------------------
| Deelnemer
-------------------
| voornaam : String
| naam : String
| getal : int
| ingevuldeKwissen : Map<kwis, int>
-------------------
| startkwis()
-------------------
-------------------
| Kwis
-------------------
| vragen : Vraag[]
-------------------
-------------------
| Vraag
-------------------
| vraag : String
-------------------
| evalueer(antwoord : String) : int
-------------------
-------------------
| Pakket
-------------------
| deelnemers : Deelnemer[]
| kwissen : Kwis[]
| vragen : Vraag[]
| admin : Admin
-------------------
-------------------
| Admin
-------------------
waarbij dan uiteraard nog lijntjes getrokken kunnen worden
van vraag naar kwis, met een open ruitje tegen kwis
van kwis naar deelnemer, met een open ruitje tegen deelnemer
vraag 3a : hergebruik en encapsulatie
b : een opdeling in afzonderlijke delen, die apart ontwikkeld kunnen worden, die een vooraf afgesproken interface aanbieden
zo weinig mogelijk afhankelijkheden tussen partities
c : bij OOA stellen de klassen iets voor dat echt bestaat, bij OOD stellen de klassen iets voor dat geprogrammeerd zal worden
voorbeeld : bibliotheeksoftware : in OOA zal men doorhebben dat er boeken en CDs zijn, bij OOD kan men een overkoepelende klasse uitleenbaarObject maken bijvoorbeeld
vraag 4a : regels om het programmeren met verschillende mensen te vereenvoudigen, bijvoorbeeld dat codeblokken niet langer mogen zijn dan x regels
b : branch coverage : <0, 'A'> <1, 'A'> <1, 'B'>
path coverage : <2, 'A'> <2, 'B'> <3, 'A'> toevoegen
vraag 5 a i : collectiestructuren die collectiestructuren kunnen bevatten (bijvoorbeeld bomen)
ii :
- Code: Select all
-------------
| Composite |
-------------
/\
|
---------------------------------
| |
--------- --------------------------
|Object | |collectie |
--------- --------------------------
|elementen : Composite[] |
--------------------------
b i :
userNotAuthenticated
| authenticate
\/
addingToCart (met een lusje voor als er Input is)
| exit
\/
en eigenlijk is dat het, de rest van de code kan gewoon uitgevoerd worden bij de overgangen
ii : een klasse Context heeft een State (interface), en userNotAuthenticated en addingToCart implementeren die
iii :
- Code: Select all
process(User u) {
return new Context(u);
}
waarbij ik dus veronderstel dat de gebruiker verantwoordelijk is om boodschappen te versturen, ipv dat de process heel de tijd alles vraagt (ik ben niet 100% zeker dat dat mag, maar anders is het wel veel gepruts om dat goed te krijgen)
iv :
- Code: Select all
class userNotAuthenticated {
authenticate(Context c){
c.user.authenticate();
if(c.user.isAuthenticated())
c.setState(new addingToCart());
}
c : als er een klasse bijkomt die "extends A", dan gaat ge bij b.deepCopy() een nieuwe A opslaan, ipv een copy van het element uit de kinderklasse
mijn oplossing zou zijn om A ook deepCopy te laten implementeren
- Code: Select all
class A {
public A deepCopy(){
A copy = new A(this);
return copy;
}
}
class B {
public B deepCopy(){
B c=new B();
c.b=b;
c.a = a.deepCopy();
return c;
}
}
vraag 6a :
- Code: Select all
-------------------------
| BeperktI <<interface>>
-------------------------
| getSum() : int
| getLength() : int
-------------------------
---------------------------------------------- /\
| Series | |
---------------------------------------------- |
| r : int[] -------------
--------------------------------------------|Beperkt
| getBeperkt() : beperktI -------------
| (de andere functies van Series overnemen) |
----------------------------------------------
implementatie :
- Code: Select all
public BeperktI getBeperkt() {
return new Beperkt();
}
private class Beperkt implements BeperktI {
public int getSum(){
return Series.this.getSum();
}
public int getLength(){
return Series.this.getLength();
}
}
en uiteraard die interface
- Code: Select all
interface BeperktI {
public int getSum();
public int getLength();
}
b : code die bedoeld is voor hergebruik, en die gebruik maakt van klassen die door de hergebruiker gedefineerd zullen worden
vraag 7a : wanneer 2 threads een bepaalde variabele willen aanpassen en de volgorde ligt niet vast, kan dit leiden tot verloren updates, foute updates (die gebaseerd waren op een incorrecte tussenwaarde), en onlogische eindresultaten
b : Executors hebben een aantal threads die ze hergebruiken voor verschillende taken
Threads zijn duur om te maken, Executors hergebruiken ze dus kunnen een hele besparing opleveren
c i : om geen t++ updates kwijt te raken
ii : bij if(!proceed) wait() zou er één keer gewacht worden, en bij de eerste notify wordt er verdergegaan, ongeacht of proceed nu true of false is
(kvind het trouwens maar rare code, ge kunt de 2 overspringen voordat de waiter het doorheeft, en dan moet ge blijven gaan tot dat terugdraait, maargoed)
vraag 8a : serialisatie behoudt verwijzingen tussen objecten, zal een object maar 1 keer serializen, en bij standaardserializatie zal er geen constructor opgeroepen worden
b i : de output is 5
verklaring : a bevat 3 objecten die geserialized worden, l bevat er 2
ii : 4
het object a[1] werd twee keer geserialized, maar serializatie weet dat het hetzelfde object is, dus het wordt maar één keer aangemaakt.
vraag 9a : makkelijk hergebruik, snel de markt bereiken. Zo weinig mogelijk moeten programmeren, gewoon componenten aaneen plakken.
b : ik zou gaan voor :
- Code: Select all
------------------
|Component
------------------
| a : int
| b : int
| aSupport : PropertyChangeSupport
| bSupport : PropertyChangeSupport
------------------
| getA() : int
| setA(int)
| getB() : int
| setB(int)
| addAListener(l : PropertyChangeListener)
| removeAListener(l : PropertyChangeListener)
| addBListener(l : PropertyChangeListener)
| removeBListener(l : PropertyChangeListener)
| addPropertyChangeListener(l : PropertyChangeListener)
| removePropertyChangeListener(l : PropertyChangeListener)
------------------
waarbij de addPropertyChangeListener dus dient voor wie naar allebei zal luisteren, en die zijn argument gewoon aan beide PropertyChangeSupports zal toevoegen
[edit]
kga dat examen hier gewoon copypasten
dan blijft het zeker online staan
- Code: Select all
EXAMEN SOFTWAREONTWIKKELING [II]
2DE BA. INFORMATICA
3DE BA. INGENIEURSWETENSCHAPPEN :
COMPUTERWETENSCHAPPEN
EERSTE EXAMENPERIODE ACADEMIEJAAR 2008 – 2009
Vrijdag 5 juni, 2009, 8u30
Naam :
V1 :
V2 :
V3 :
V4 :
V5:
V6:
V7:
V8:
V9:
Vraag 1: Software Levenscyclus
a. Wat wordt bedoeld met de term “software proces” ?
b. Wat is het hoofddoel van de specificatie-fase in het ontwikkelproces ?
Examen Softwareontwikkeling (II) 1
c. Geef de voornaamste voordelen van incrementele processen in vergelijking met het klassieke
watervalproces.
Vraag 2: Object-georienteerde Analyse
Gegeven onderstaande probleem:
“Een kwispakket laat toe om een aantal deelnemers, geïdentificeerd via voornaam, naam en uniek
geheel getal, een reeks vragen te laten beantwoorden. Het pakket laat een administrator toe een reeks
vragen te definiëren, en uit deze vragen een kwis samen te stellen. De deelnemers zelf beantwoorden
alle vragen van een specifieke kwis, waarna hun score volgt. Een antwoord wordt geformuleerd in de
vorm van schrifttekst. Elke vraag beschikt over een methode “evalueer”, die voor een gegeven
antwoord een geheel getal als score berekent. De uiteindelijke score per deelnemer bestaat dan uit de
som van alle individuele vraagscores. Om fraude te vermijden, beschikt elke deelnemer over een
loginnaam en paswoord. Een deelnemer kan zijn individuele score opvragen voor een welbepaalde
kwis. De administrator kan alle scores van alle deelnemers bekijken.”
a. Teken een zo nauwkeurig en informatief mogelijk use-case diagram.
Examen Softwareontwikkeling (II) 2
b. Zet de tekst zo nauwkeurig mogelijk om in een UML klassendiagram.
Vraag 3: Object-georienteerd Ontwerp
a. Argumenteer het gebruik van gelaagde architecturen.
b. Wat bedoelt men met de term “partitioneren in subsystemen” ? Hoe gebeurt dit best (m.a.w. wat zijn
de kenmerken van een goede partitionering ?) ?
c. Een UML-klassendiagram kan zowel tijdens de OOA- als tijdens de OOD-fase gemaakt worden. Leg
het verschil tussen beide versies uit. Geef ook een duidelijk voorbeeld.
Examen Softwareontwikkeling (II) 3
Verschillen:
Voorbeeld:
Vraag 4: Object-georienteerd Programmeren
a. Wat zijn “coding standards” ? Geef enkele voorbeelden.
b. Gegeven onderstaande Java-code voor de methode f(int i, char c) :
public static String f(int i,char c) {
String r="";
if(i<=0) return r;
while(i<3) {
if(c>'A') r+=c;
else r=c+r;
i++;
}
return r;
}
Geef testvectorn <i,c> om takbedekking te realiseren (“branch coverage”).
Geef testvectoren <i,c> om padbedekking te realiseren (“path coverage”).
Examen Softwareontwikkeling (II) 4
Vraag 5 OntwerpSpatronen
a. Composite-patroon.
(i) Leg uit welk fundamenteel probleem het composite-patroon oplost.
(ii) Geef de algemene structuur van dit patroon.
b. Webshop
Gegeven onderstaande Java skelet-code, die Users toelaat in een Shop zaken te kopen, na authenticatie,
en daarna een rekening toegestuurd krijgen. De winkelwagen (shopping cart) wordt hier
geïmplementeerd als lijst van Strings.
class User {
protected String name;
protected String password;
public User(String n,String p) {
name=n;
password=p;
}
public boolean isAuthenticated() {
// ...
}
public void authenticate() {
// ...
Examen Softwareontwikkeling (II) 5
}
public String getInput() {
// ask input from user
// "exit" implies stopping the application
return input;
}
public void addToCart(String i) {
// add item i to shopping cart
}
public ArrayList<String> getCart() {
return cart;
}
public void sendBill(double p) {
// bill received ...
}
}
class Shop {
public void process(User u) {
boolean exit=false;
while(!(u.isAuthenticated())) {
u.authenticate();
}
while(!exit) {
String input=u.getInput();
if(input.equals("exit")) exit=true;
else u.addToCart(input);
}
ArrayList<String> cart=u.getCart();
if(cart.size()==0) {
return;
} else {
double price=calculatePrice(cart);
u.sendBill(price);
}
}
public double calculatePrice(ArrayList<String> c) {
// ...
}
}
We wensen de code van de klasse Shop te her-ontwerpen (i.h.b. de process()-methode) via het State-
patroon, waarbij de toestand van de Shop aangeeft in welk stadium de klant zich bevindt.
Examen Softwareontwikkeling (II) 6
i) Teken een toestandsdiagram voor dit systeem.
ii) Geef een UML klassediagram voor dit herontworpen systeem.
iii) Geef de implementatie van de nieuwe process()-methode van de klasse Shop.
iv) Geef de implementatie van 1 toestandsklasse.
c. Beschouw onderstaande Java-code. In welke zin stelt deze code een probleem i.v.m.
uitbreidbaarheir?
class A {
protected int a;
public A(int ia) {
a=ia;
}
public A(A i){
a=i.a;
}
public String toString() {
return "A:"+a;
}
}
class B {
protected int b;
Examen Softwareontwikkeling (II) 7
protected A a;
public B() {}
public B(int ib,A ia) {
b=ib;
a=ia;
}
public B deepCopy() {
B c=new B();
c.b=b;
c.a=new A(a);
return c;
}
public String toString() {
return "B:"+b+" : "+a;
}
}
Hoe zou je dit probleem oplossen ? Teken een aangepast UML klassendiagram.
Geef de code-wijzigingen die je de klasse(n) A en/of B zou aanbrengen.
Vraag 6: Raamwerken en inwendige klassen
NIET OP TE LOSSEN VOOR STUDENTEN BI.
Examen Softwareontwikkeling (II) 8
a. Beschouw onderstaande Java-code, waarin een rij gehelegetallen in een klasse Series geencapsuleerd
wordt.
class Series {
protected int[] r;
public Series(int s) {
r=new int[s];
}
public void set(int index,int value) {
r[index]=value;
}
public int get(int index) {
return r[index];
}
public int getSum() {
int sum=0;
for(int i:r) sum+=i;
return sum;
}
public int getLength() {
return r.length;
}
}
We wensen de toegang tot deze klasse voor sommige objecten te beperken tot de methoden getSum()
en getLength(). Hiertoe gebruiken we het concept “inwendige klasse”.
Teken een UML-diagram van de principiële oplossing.
Geef de Java-implementatie van de aangepaste klasse Series.
b. Wat wordt bedoeld met de term “raamwerk” (“framework”) ?
Examen Softwareontwikkeling (II) 9
Vraag 7: Multithreading
a. Wat is een “Race” ?
b. Leg de relatie uit tussen Java Executors en Threads. Motiveer het gebruik van Executors.
c. Beschouw onderstaande Java-code.
class Notifier extends Thread {
public static final int MAX=10;
private int goal;
private Waiter waiter;
public Notifier(int g,Waiter w) {
goal=g;
waiter=w;
start();
}
public void run() {
while(true) {
int r=(int)(10.0*Math.random());
System.out.print(" "+r);
if(r==goal) {
System.out.println("");
waiter.setProceed(true);
synchronized(waiter) {
waiter.notifyAll();
}
Examen Softwareontwikkeling (II) 10
return;
}
}
}
}
class Waiter extends Thread {
private boolean proceed=false;
private int t;
public Waiter() {
start();
}
public synchronized void setProceed(boolean p){
t++;
proceed=(t==2);
}
public void run() {
synchronized(this) {
try{
while(!proceed) wait();
} catch(InterruptedException e) {
System.err.println(e);
}
}
System.out.println("Can proceed now !");
}
}
public class TestMulti {
public static void main(String[] args) {
Waiter w=new Waiter();
Notifier n1=new Notifier(7,w);
Notifier n2=new Notifier(3,w);
}
}
i) Leg uit waarom de methode setProceed() in de klasse Waiter al dan gesynchoniseerd
moet zijn.
Examen Softwareontwikkeling (II) 11
ii) Leg uit waarom voor de constructie
while(!proceed) wait();
gekozen werd, i.p.v. if(!proceed) wait();
Vraag 8 : Serialisatie
a. Om een object te persisteren naar een bestand, kan met 2 mechanismen gebruiken: (i) het schrijven
van alle datavelden naar het bestand, (ii) gebruik maken van objectserialisatie. Waarin verschillen
deze opties fundamenteel ?
b. Beschouw onderstaande Java-code:
class A implements Serializable {
private char c;
public A(char cc) {
c=cc;
}
}
public class TestSimple {
public static void main(String[] args) throws Exception {
A[] a={new A('a'),new A('b'),new A('c')};
ArrayList<A> l=new ArrayList<A>();
Examen Softwareontwikkeling (II) 12
l.add(new A('b'));
l.add(a[1]);
ObjectOutputStream out=new ObjectOutputStream(new
BufferedOutputStream(new FileOutputStream("t.dat")));
for(A o:a)
out.writeObject(o);
for(A o:l)
out.writeObject(o);
out.close();
int n=0;
ObjectInputStream in=new ObjectInputStream(new
BufferedInputStream(new FileInputStream("t.dat")));
ArrayList<A> i=new ArrayList<A>();
try{
while(true) {
A o=((A)(in.readObject()));
if(!(i.contains(o))) i.add(o);
n++;
}
} catch(EOFException e) {
}
in.close();
System.out.println(n);
System.out.println(i.size());
}
}
i) Welke output genereert de regel : System.out.println(n); ? Verklaar.
Waarde :
Verklaring :
Examen Softwareontwikkeling (II) 13
ii) Welke output genereert de regel : System.out.println(i.size()); ? Verklaar.
Waarde :
Verklaring :
Vraag 9 : Componenten
a. Motiveer het gebruik van componenten.
b. We wensen een JavaBeans component te realiseren, die over 2 bound properties beschikt, namelijk
de properties a en b, beide van type int. We wensen ook dat luisteraars zich kunnen registreren om:
o Op de hoogte gebracht te worden van wijzigingen van property a (en niet van b)
o Idem voor wijzigingen van property b (en niet van a)
o Idem voor wijzigingen van beide properties.
Teken een zo volledig mogelijk UML klassendiagram van een systeem dat dit realiseert, zoveel
mogelijk gebruik makend van de door Java geboden functionaliteit.
Examen Softwareontwikkeling (II) 14
Examen Softwareontwikkeling (II) 15
[/edit]
The major difference between a thing that might go wrong and a thing that cannot possibly go wrong, is that when a thing that cannot possibly go wrong goes wrong it usually turns out to be impossible to get at or repair.
-- Douglas Adams, Mostly Harmless
