MASTERS OF JAVA - Walkthrough

Masters of Java -- de eerste Java wedstrijd die ook leuk is om te doen! Deze beschrijving leidt u door een van de cases -- de Haiku case -- van het prille begin tot het inleveren van de opdracht en het verkrijgen van de score.

OPSTARTEN VAN DE OMGEVING

De omgeving kan opgestart worden via de browser. De wedstrijdorganisatie zal op de dag zelf de URL bekendmaken. Zodra de omgeving opgestart is wordt het inlogscherm getoond. Met behulp van het door de organisatie uitgedeelde username/password.

Nadat het systeem de inloggegevens heeft geakkoordeerd wordt het wachtscherm getoond. Dit scherm geeft aan dat de wedstrijdklok voor de opdracht nog niet is gestart. Zorg dat u goed in de startblokken staat, want de wedstrijd kan ieder moment beginnen...

HET SPEL BEGINT

De klok loopt! U heeft nog een half uur om de opdracht uit te voeren en in te leveren. Laten we snel door de opdracht heen gaan en onze tijd nuttig benutten.

Eerst maar een beschrijving van de interface. Hier op het linker tabblad ziet u de opdrachtomschrijving. Lees deze opdracht aandachtig en let goed op hints en tips die gegeven worden.

Op de volgende drie tabbladen worden de Java klassen getoond. Een van deze klassen zal ingevuld worden. De eerste klasse is de interface die geimplementeerd dient te worden -- de HaikuChecker.

public interface HaikuChecker {
        public static final String[] SEASONS=
                      new String[] { "lente","zomer","herfst","winter" };
        public void check(String[] haiku) throws InvalidHaikuException;
} 

Listing I: de interface waar je tegenaan programmeert

Zoals u kunt zien bevat de klasse twee interessante zaken. Het eerste is een String array van seizoen omschrijvingen. Een Haiku is alleen dan een haiku indien er minstens 1 verwijzing naar een seizoen in staat. Het tweede is de methode check. Deze methode krijgt de haiku mee en gooit een exceptie indien de haiku fout is. Indien de haiku correct is gebeurt er niets. De uitvoer bestaat dus slechts uit twee mogelijkheden -- een exceptie of niets.

public class HaikuCheckerImpl implements HaikuChecker { 
        public void check(String[] haiku) throws InvalidHaikuException { 
                //
                // Implement Here
                //
        } 
} 

Listing II: de implementatie van de interface -- dit is wat je programmeert!

De klasse HaikuCheckerImpl is de implementatie van de hiervoor beschreven interface. In het kader van de opdracht wordt enkel deze klasse ingevuld. En wel de methode genaamd check.

public final class InvalidHaikuException extends Exception { 
        public InvalidHaikuException(String msg) { 
                super(msg);
        } 
} 

Listing III: de exceptie die je moet gebruiken indien je invalide input tegenkomt

De exceptie InvalidHaikuException wordt vanuit de methode check gegooid indien de haiku input niet correct blijkt. Officieel krijgt de constructor een string bericht mee -- voor de wedstrijd is het echter niet erg als dit een lege string blijkt te zijn!

Op het meest rechter tabblad staat een bijzonder handig hulpmiddel -- de testsets. Hier kan gezien worden welke testsets er door de server losgelaten worden op de ingediende klasse. Tijd om te kijken naar de kern van de wedstrijd -- het programmeren zelf.

HET PROGRAMMEREN BEGINT

We hebben de opdracht gekregen om de controleren of een haiku valide is. Het programma controleert of we dit goed hebben gedaan aan de hand van een vooraf gegeven testset. Door de aard van de opdracht (exceptie bij foute haiku, geen handeling bij goede haiku) hoeven we eigenlijk alleen maar de fouten eruit te halen.

Laten we beginnen met de overduidelijk foute invoer: null pointers. De methode check krijgt een String array genaamd haiku mee. Het argument haiku kan null zijn. Daarnaast kan het array intern ook null pointers bevatten. We voegen code toe om deze situaties uit te schakelen:

public class HaikuCheckerImpl implements HaikuChecker {
        public void check(String[] haiku) throws InvalidHaikuException {
                if (haiku == null) { 
                    throw new InvalidHaikuException("Null pointer"); 
                 } 
                 for(int pos = 0; pos < haiku.length; pos++) {
                        if (haiku[pos] == null) {
                                throw new InvalidHaikuException("Null pointer in array");
                        } 
                } 
                // ... 
        } 
} 

Listing IV: de null pointers worden tegengehouden

Laten we eerst kijken of de code compileert. Door op de knop "compile" te drukken wordt de code naar de server gestuurd waar de compilatie plaatsvindt. De resultaten van de compilatie worden in het console onder getoond. Dit is goed gegaan...

Nu is het interessant om te kijken wat er gebeurt indien we de testsets draaien. Door op de knop "test" te drukken, vragen we de server om de testsets te draaien tegen de tot nog toe gevulde klasse.

Zoals te zien is wordt de reeks "V V V V V X X X X X V V V X X" getoond. Een "V" geeft aan dat een test gelukt is. Bij een "X" is de test mislukt. Alle tests met null pointers zijn nu in ieder geval geslaagd. Op naar de volgende uitdaging.

In de opdrachtomschrijving wordt het volgende gezegd:
- een haiku bestaat uit drie regels
- de eerste regel bestaat uit vijf lettergrepen
- de tweede regel bestaat uit zeven lettergrepen
- de derde regel bestaat uit vijf lettergrepen
- een lettergreep is een kluster van klinkers (a,e,i,u,o,y)

Het controleren van het aantal haiku regels is eenvoudig. De lengte van het array wordt gecontroleerd op de waarde drie.

Een moeilijker stap is om lettergrepen te tellen. Hiertoe voegen we een methode toe waarmee deze telling mogelijk is. De methode heet countSyllables en zoekt naar klinkers in lower en uppercase. Het aantal groepen klinkers wordt teruggegeven aan de aanroepende partij. In de hoofdmethode wordt vervolgens gecontroleerd of regel 1 uit 5, regel 2 uit 7 en regel 3 uit 5 lettergrepen bestaat.

 
public class HaikuCheckerImpl implements HaikuChecker {
        public void check(String[] haiku) throws InvalidHaikuException {
                if (haiku == null) {
                        throw new InvalidHaikuException("Null pointer");
                }
                for (int pos = 0; pos < haiku.length; pos++) {
                        if (haiku[pos] == null) {
                                throw new InvalidHaikuException("Null pointer in array");
                        }
                        if (containsSeason(haiku[pos])) {
                        }
                }
                if (haiku.length != 3) {
                        throw new InvalidHaikuException("Haiku does not have three lines");
                }
                if (countSyllables(haiku[0]) != 
5) { throw new InvalidHaikuException("Line 1
        does not have 5 syllables"); } if
                (countSyllables(haiku[1]) ! = 
                        7) { throw new
                InvalidHaikuException("Line
                2 does not have 7 syllables"); } if
                        (countSyllables(haiku[2]) ! = 
                                     
                        
                          5)
                        {
                throw
                new InvalidHaikuException("Line 3 does not
                        have 5 syllables"); } } protected int countSyllables(String
                haikuLine)
                { if (haikuLine= 
                                
                
                  = 
                              null) { return
                0; 
                } int numberOfSyllables= 
                                
                       
                               
            0;
                boolean inSyllable = 
                         
                
                 false; for
                (int charPos = 
                  0; charPos < haikuLine.length; charPos++) {
                        char currentChar = haikuLine.charAt(charPos);
                        switch (currentChar) {
                                case 'a' :
                                case 'e' :
                                case 'i' :
                                case 'o' :
                                case 'u' :
                                case 'y' :
                                case 'A' :
                                case 'E' :
                                case 'I' :
                                case 'O' :
                                case 'U' :
                                case 'Y' :
                                        if (!inSyllable) {
                                                inSyllable = true;
                                                numberOfSyllables++;
                                        }
                                        break;
                                default :
                                        inSyllable = false;
                                        break;
                        }
                }
                return numberOfSyllables;
        }
}

Listing V: de eerste business logica -- aantal regels en lettergrepen

De testset toont aan dat nog een enkele test een fout geeft. Het betreft hier een legale haiku, op een detail na; de haiku bevat geen referentie naar een seizoen. Dit moet nog toegevoegd worden. De methode hasSeason controleert of een String een referentie naar een seizoen heeft. De namen van de seizoenen worden uit de interface gelezen.

 
public class HaikuCheckerImpl implements HaikuChecker {
        public void check(String[] haiku) throws InvalidHaikuException {
                if (haiku == null) {
                        throw new InvalidHaikuException("Null pointer");
                }
                if (haiku.length != 3) {
                        throw new InvalidHaikuException("Haiku does not have three lines");
                }
[> boolean hasSeason = false;
                for (int pos = 0; pos < haiku.length; pos++) {
                        if (haiku[pos] == null) {
                                throw new InvalidHaikuException("Null pointer in array");
                        }
[> if (containsSeason(haiku[pos])) {
[> hasSeason = 
     
          true; [> } } [>
                if (!hasSeason = 
                           
                
                  = 
                           true) { [> throw new
                InvalidHaikuException("The
haiku has no season");
                [> } if (countSyllables(haiku[0]) ! = 5) { throw
                        new InvalidHaikuException("Line 1 does
                                not have 5 syllables"); } if
                        (countSyllables(haiku[1])
!= 7) { throw
new InvalidHaikuException("Line 2
does not
                have
7 syllables"); } if (countSyllables(haiku[2])
!= 5) {
throw new
                InvalidHaikuException("Line 3 does not have
                        5 syllables"); } } [> protected boolean hasSeason(String haikuLine)
                {
                [> if (haikuLine= 
                                
                
                  = 
                         null) { [> return false; [> } [>
                for
        (int
seasonPos= 0; seasonPos < HaikuChecker.SEASONS.length; [>
seasonPos++) { [> if (haikuLine.toLowerCase().indexOf(HaikuChecker.SEASONS[seasonPos])
!= -1) {
[> return
true; [> } [> } [> return
false; [> }
protected int countSyllables(String haikuLine) { if
(haikuLine= 
= 0)
{ return
0; } int
numberOfSyllables= 
            0;
                boolean inSyllable = 
                         
                
                 false; for
                (int charPos = 
                  0; charPos < haikuLine.length; charPos++) {
                        char currentChar = haikuLine.charAt(charPos);
                        switch (currentChar) {
                                case 'a' :
                                case 'e' :
                                case 'i' :
                                case 'o' :
                                case 'u' :
                                case 'y' :
                                case 'A' :
                                case 'E' :
                                case 'I' :
                                case 'O' :
                                case 'U' :
                                case 'Y' :
                                        if (!inSyllable) {
                                                inSyllable = true;
                                                numberOfSyllables++;
                                        }
                                        break;
                                default :
                                        inSyllable = false;
                                        break;
                        }
                }
                return numberOfSyllables;
        }
}

Listing VI: nu ook seizoenen -- de applicatie is klaar!

Opnieuw draaien van de testset geeft een welkom resultaat -- alle tests zijn geslaagd. We zijn nu klaar om de opdracht in te dienen en de scoring te ondergaan.

HET INDIENEN VAN DE OPDRACHT

Na het drukken op de "submit" knop en het bevestigen van de indiening, wordt de server gevraagd om een score toe te kennen. De indiener zal allereerst alle testsets met succes moeten afronden. Als dat niet lukt worden 0 punten toegekend. Als dat wel is gelukt wordt daarna gekeken naar de verstreken tijd. Afhankelijk hiervan worden de punten toegekend.

En op het grote server board wordt de score van het team getoond naast de voortgang van de andere partijen.

U heeft geproefd van de Masters of Java demo. Uiteraard hopen wij dat dit naar meer smaakt. Aarzel niet en registreer nu voor het leukste programmeer event in Nederland !