Java-methoden en programmadecompositie

Een methode is een benoemd blok instructies dat een taak uitvoert. Door een methode te definiëren maak je die taak beschikbaar; door haar aan te roepen laat je de taak uitvoeren.

Lees de methodekop en methodebody

public static void printLine() {
    System.out.println("----------");
}

De eerste regel is de methodekop. Lees de onderdelen van links naar rechts:

• public staat toe dat code in andere klassen de methode aanroept.
• static zorgt ervoor dat de methode bij de klasse hoort. Er is geen object nodig om haar aan te roepen.
• void geeft aan dat de methode geen waarde teruggeeft.
• printLine geeft de taak een naam.
• () is de lege parameterlijst: deze methode heeft geen invoer nodig.

De accolades omsluiten de methodebody, de instructies die bij een aanroep worden uitgevoerd. Tussen deze methodekop en de openingsaccolade staat geen puntkomma.

Zet de definitie in de klasse

public class Main {
    public static void main(String[] args) {
        System.out.println("Start");
        printLine();
        System.out.println("Middle");
        printLine();
    }

    public static void printLine() {
        System.out.println("----------");
    }
}

main en printLine zijn afzonderlijke methoden binnen Main. De sluitaccolade van main staat vóór de definitie van printLine. Je kunt een methode niet binnen een andere methode definiëren; een verkeerd geplaatste accolade kan “illegal start of expression” opleveren.

De definities mogen in beide volgorden staan. Als je printLine boven main zet, verandert dat niet wanneer de methode wordt uitgevoerd. Een methode die nooit wordt aangeroepen, wordt niet uitgevoerd alleen omdat haar definitie in het bestand staat.

Volg een aanroep en de terugkeer naar de aanroepende code

De aanroep printLine(); bestaat uit de naam, ronde haakjes en een puntkomma, omdat de aanroep op zichzelf een instructie is. De uitvoering begint in main:

1. Druk “Start” af.
2. Ga naar printLine, druk tien streepjes af en ga dan verder na de aanroep.
3. Druk “Middle” af.
4. Ga opnieuw naar printLine en druk opnieuw tien streepjes af.

De uitvoer is:

Start
----------
Middle
----------

Beide aanroepen gebruiken dezelfde definitie. Als je de afgedrukte regel daarin wijzigt, verandert die op beide plaatsen waar de methode wordt gebruikt.

Geef methoden een duidelijke naam en roep ze nauwkeurig aan

Gebruik een werkwoord of werkwoordgroep in camelCase, beginnend met een kleine letter: printReceipt, calculateAverage of isValidCode. Java maakt onderscheid tussen hoofdletters en kleine letters: PrintLine() kan geen methode met de naam printLine vinden. Ook printLine; schrijven mislukt; de ronde haakjes maken deel uit van de aanroep.

Schrijf voor een statische methode in een andere klasse eerst de klassenaam. Math.max(3, 8) geeft 8, Math.abs(-4) geeft 4 en Math.sqrt(16.0) geeft 4.0. Je eigen methoden in dezelfde klasse kun je alleen met hun naam aanroepen.

Deze voorbeelden gebruiken de klassieke vorm met een klasse en public static void main(String[] args). Java 25 ondersteunt ook compacte bronbestanden met void main() en zonder omringende klasse. Gebruik bij het uitvoeren van deze voorbeelden de klassieke vorm; de hulpmethoden zijn gedeclareerd met static. Methoden zoals System.out.println die je uit de Java-bibliotheek aanroept, hoeven zelf niet statisch te zijn.

Met een parameter kan één methode waarden verwerken die per aanroep veranderen. Een argument is de waarde die bij de aanroep voor die parameter wordt opgegeven.

Geef elke invoer een type en een naam

public static void printStars(int count) {
    for (int i = 0; i < count; i++) {
        System.out.print("*");
    }
    System.out.println();
}

int count declareert één parameter. In printStars(3); wordt het argument 3 de beginwaarde van count. De lus wordt drie keer uitgevoerd en drukt dus *** af, waarna println() de regel beëindigt. printStars(8); gebruikt dezelfde methodebody met count gelijk aan 8.

Het type schrijf je in de definitie, niet in de aanroep. Schrijf printStars(5);, niet printStars(int 5);.

Bereken argumenten voordat je de methodebody binnengaat

Een argument kan een literal, een variabele of een expressie zijn:

int n = 4;
printStars(n * 2);

Java berekent eerst n * 2. Het geeft de resulterende waarde 8 door, dus de methodebody begint met count gelijk aan 8. De naam van de variabele in de aanroepende code hoeft niet overeen te komen met de naam van de parameter.

Koppel meerdere parameters op positie

Elke parameter heeft een eigen type nodig. Een methode voor een rechthoek kan met deze methodekop beginnen:

public static void printRectangle(int width, int height)

De aanroep printRectangle(5, 2); geeft width de waarde 5 en height de waarde 2. Als je de argumenten omdraait, krijg je een rechthoek die 2 breed en 5 hoog is. Beide aanroepen compileren omdat beide argumenten ints zijn; alleen de bedoelde vorm vertelt je welke volgorde juist is. Als je (int width, height) in de methodekop schrijft, mislukt dat omdat voor height geen type is gedeclareerd.

Bij verschillende typen zijn sommige volgordefouten gemakkelijker te vinden:

public static void printRepeated(String text, int times) {
    for (int i = 0; i < times; i++) {
        System.out.print(text);
    }
    System.out.println();
}

printRepeated("ab", 3); drukt “ababab” af. printRepeated(3, "ab"); kan niet worden gekoppeld aan een String gevolgd door een int. Ook het aantal argumenten moet kloppen: bij printRectangle(5); krijgt één parameter geen waarde.

Controleer of numerieke typen passen

Java zet een int automatisch om naar een double met een verbredende typeconversie. Een methode met parameters (double km, double hours) accepteert de argumenten (150, 2) en krijgt daarmee 150.0 en 2.0. Elke int-waarde kan exact als double worden weergegeven.

Java zet een double-argument niet automatisch met een versmallende typeconversie om naar een int-parameter. printStars(2.9); mislukt omdat bij de omzetting het deel achter de komma verloren zou gaan. De expliciete typeconversie in printStars((int) 2.9); levert 2 op, zodat twee sterren worden afgedrukt. Gebruik zo’n typeconversie alleen als het de bedoeling is dat dat deel wordt afgekapt.

Kies een parameter voor elk gegeven dat de taak nodig heeft. Doordat printRepeated tekst en een aantal ontvangt, kun je de methode gebruiken met toetsenbordinvoer, een vaste testaanroep of een andere methode. De methodebody hoeft niet te bepalen waar die waarden vandaan komen.

Een retourwaarde is een resultaat dat een methode naar de aanroepende code stuurt. Zodra een aanroep klaar is, kan die worden gebruikt als een expressie met het type van dat resultaat.

Declareer wat wordt teruggegeven

public static int sum(int a, int b) {
    return a + b;
}

int vervangt void in de methodekop omdat deze methode een geheel getal teruggeeft. De return-instructie berekent a + b en stuurt de waarde naar de plaats van de aanroep. Voor sum(4, 7) is die waarde 11.

De aanroepende code bepaalt wat er daarna gebeurt:

int total = sum(4, 7);
System.out.println(sum(4, 7));
int doubled = sum(2, 3) * 2;

De eerste regel slaat 11 op; de tweede drukt 11 af; de derde slaat 10 op. Een retourwaarde kun je ook in een voorwaarde gebruiken, zoals if (sum(a, b) > 10).

Een passend int-resultaat kan met een verbredende typeconversie worden omgezet wanneer het uit een double-methode wordt teruggegeven. Een double-resultaat kan niet zonder een geschikte expliciete typeconversie uit een int-methode worden teruggegeven.

Bereken de expressie voordat je het resultaat omzet

public static double average(int a, int b) {
    return (a + b) / 2.0;
}

Voor average(3, 4) is de teller 7. Delen door de double-literal 2.0 geeft 3.5. Als de expressie (a + b) / 2 was, zou Java eerst twee ints delen en 3 krijgen. Pas daarna zou Java die waarde met een verbredende typeconversie omzetten naar de teruggegeven waarde 3.0. Een retourtype double herstelt geen geheeltallige deling die al binnen de methodebody is uitgevoerd.

Houd teruggeven en afdrukken gescheiden

Een void-aanroep kan geen waarde leveren voor een toewijzing of een andere aanroep. Als printSum void is, mislukt int total = printSum(1, 2); ook al drukt printSum een getal af. Gebruik voor berekeningen een methode die een waarde teruggeeft en laat de aanroepende code kiezen of die wordt afgedrukt.

Geef tekst en ja-neeresultaten terug

Retourtypen omvatten ook String en boolean. Een begroetingsmethode kan "Hello, " + name + "!" teruggeven, wat “Hello, Ana!” oplevert voor het argument "Ana". Een methode isEven(int n) kan n % 2 == 0 teruggeven.

Een opmaakmethode zet een getal om in herbruikbare tekst:

public static String formatDuration(int minutes) {
    return minutes / 60 + " h " + minutes % 60 + " min";
}

Voor 135 geeft geheeltallige deling 2 hele uren en geeft de rest 15 minuten. Het resultaat is “2 h 15 min”; voor 60 is het “1 h 0 min”.

Bewaar of combineer het resultaat

Een aanroep zoals sum(4, 7); compileert, maar gooit het resultaat weg. Als square(x) een nieuwe waarde teruggeeft, gebruik dan x = square(x); om die in x op te slaan.

Een resultaat kan ook direct een argument worden. In Math.max(sum(1, 2), 4) geeft sum(1, 2) eerst 3, waarna Math.max(3, 4) de waarde 4 geeft. Bereken de binnenste aanroep voordat je het resultaat in de buitenste gebruikt.

Een return-instructie beëindigt de huidige methodeaanroep onmiddellijk. Ook binnen een voorwaarde of een lus verlaat je daarmee de hele methode, niet alleen dat blok.

Geef elk pad een antwoord

public static int larger(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

larger(9, 4) geeft 9 terug vanuit de if-instructie. Bij larger(2, 6) wordt de if-body overgeslagen en geeft de laatste return 6 terug. Gelijke invoer zoals (5, 5) bereikt ook de laatste return en levert 5 op. Na de eerste return is geen else nodig, omdat dat pad de methode al heeft verlaten.

In een gewone methode die een waarde teruggeeft, mag geen enkel mogelijk pad de sluitaccolade bereiken zonder een waarde te leveren. Een methode voor het teken van een getal die alleen bij positieve en negatieve invoer een waarde teruggeeft, laat nul zonder antwoord:

public static String sign(int n) {
    if (n > 0) {
        return "positive";
    } else if (n < 0) {
        return "negative";
    }
    return "zero";
}

De laatste return maakt de methode compleet. Twee afzonderlijke if-instructies, één die n > 0 test en één die n <= 0 test, hebben nog steeds een laatste return of een duidelijke if/else-structuur nodig. De returncontrole van Java leidt niet af dat die twee vergelijkingen alle gehele getallen dekken. Een instructie direct na een onvoorwaardelijke return in hetzelfde blok is onbereikbaar en wordt afgewezen.

Beëindig een zoekactie op het juiste moment

public static int firstMultipleOf7(int start, int end) {
    for (int i = start; i <= end; i++) {
        if (i % 7 == 0) {
            return i;
        }
    }
    return -1;
}

Voor (10, 20) wijst de lus 10, 11, 12 en 13 af en geeft daarna 14 terug. De aanroep eindigt zonder 15 tot en met 20 te controleren. Voor (15, 20) eindigt de lus zonder overeenkomst, dus geeft de return erna -1 terug, het afgesproken signaal voor “niet gevonden”.

Als je else { return -1; } binnen de lus zet, stopt de methode na de eerste kandidaat die niet voldoet. De zoekactie vanaf 10 zou dan melden dat niets is gevonden voordat 14 wordt bereikt. De return voor een mislukte zoekactie hoort na het uitproberen van alle kandidaten.

Geef de voorwaarde zelf terug

Een vergelijking levert al een boolean op. Schrijf return n % 2 == 0; in plaats van een if/else die afzonderlijk true en false teruggeeft. De naam van een booleaanse methode begint vaak met is of has, zodat een aanroep binnen een if-instructie natuurlijk leest.

public static boolean isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;
}

Dit geeft true terug voor 2024 en 2000, maar false voor 1900 en 2023. Gebruik if (isLeapYear(y)) rechtstreeks.

Verlaat een void-methode voortijdig

Een void-methode gebruikt return; zonder waarde. Zo kan printSquareRoot(double x) bij negatieve invoer “No real square root” afdrukken en onmiddellijk terugkeren. Voor andere invoer kan de methode Math.sqrt(x) afdrukken, wat 1.5 oplevert voor 2.25. return 5; schrijven in een void-methode mislukt omdat de methodekop belooft geen waarde terug te geven.

Het bereik van een variabele is het deel van de code waar haar naam kan worden gebruikt. Begin bij de accolades rond de declaratie: een lokale naam hoort bij een bepaalde methode of een bepaald blok.

Lokale variabelen van de aanroepende methode blijven daar

public static void main(String[] args) {
    int price = 20;
    printDouble(price);
}

public static void printDouble(int price) {
    System.out.println(price * 2);
}

De price in main en de parameter price in printDouble zijn afzonderlijke variabelen. Het argument levert de waarde die de hulpmethode nodig heeft, zodat de hulpmethode 40 afdrukt.

Als je de parameter verwijdert en printDouble() aanroept, kan de hulpmethode de lokale variabele price van main niet lezen. De methodebody zou mislukken met “cannot find symbol”. Als je de ene methode vanuit de andere aanroept, worden hun bereiken niet samengevoegd. Verschillende methoden mogen elk de naam count gebruiken zonder hun variabelen aan elkaar te koppelen.

Een genest blok maakt een kleiner bereik

Een lokale variabele kan worden gebruikt vanaf haar declaratie tot en met de sluitaccolade van haar blok. Een parameter is beschikbaar in de hele methodebody. Een teller die in for (int i = 0; i < 3; i++) is gedeclareerd, hoort bij die lus; i kan daarna niet meer worden gelezen.

Om een resultaat na een lus te bewaren, declareer je het vóór de lus:

int sum = 0;
for (int i = 1; i <= 5; i++) {
    sum += i;
}
System.out.println(sum);

Door het optellen krijgt sum achtereenvolgens de waarden 1, 3, 6, 10 en 15. De laatste afdrukinstructie kan sum lezen omdat het omringende blok nog niet is geëindigd. i is alleen nodig voor de lus en blijft binnen het bereik daarvan.

Als je int sum = 0; naar de lusbody verplaatst, ontstaat bij elke herhaling een nieuwe sum. Elke variabele begint bij nul en verdwijnt aan het einde van die herhaling. De variabele kan geen lopend totaal bijhouden en kan na de lus niet worden afgedrukt.

Controleer namen en beginwaarden afzonderlijk

Twee lokale variabelen met dezelfde naam kunnen binnen één methode geen overlappend bereik hebben. Een methode met een parameter x kan niet nog een lokale variabele x declareren; een lus die i declareert, kan niet nog een i in haar body declareren. Geef de tweede variabele een andere naam of gebruik de bestaande.

Twee opeenvolgende lussen mogen elk int i declareren. Het bereik van de eerste lus is geëindigd vóór de tweede declaratie. Accolades, niet het hele bestand, bepalen of je de naam opnieuw kunt gebruiken.

Een toegestane naam heeft ook een waarde nodig voordat die wordt gelezen. int total; total++; mislukt omdat ++ de oude waarde moet lezen en een lokale variabele niet automatisch een beginwaarde krijgt. Gebruik int total = 0; voor een lopend totaal.

Houd een lokale variabele in het kleinste blok dat die nodig heeft. Als een methode informatie van de aanroepende code nodig heeft, maak die informatie dan tot een parameter. Als de aanroepende code een resultaat nodig heeft, geef dat dan terug. Zo laten de methodekop en methodebody zien waar de gegevens vandaan komen.

Java geeft argumenten op waarde door. Aan het begin van een aanroep ontvangt elke parameter een kopie van de waarde van het argument. Een toewijzing aan de parameter verandert die lokale variabele.

Volg de kopie afzonderlijk

public static void main(String[] args) {
    int score = 10;
    addBonus(score);
    System.out.println(score);
}

public static void addBonus(int score) {
    score = score + 5;
    System.out.println(score);
}

Er zijn twee variabelen met de naam score. Volg hun waarden op elk moment:

De hulpmethode drukt 15 af, daarna drukt main 10 af. Een gedeelde naam betekent niet dat de twee variabelen dezelfde opslagruimte delen. Als je de parameter een andere naam geeft, verandert dit gedrag niet.

Geef de nieuwe waarde terug en sla die op

public static int addBonus(int score) {
    return score + 5;
}

Schrijf bij deze versie score = addBonus(score);. Java kopieert de oude waarde naar de parameter, berekent 15, geeft die waarde terug en wijst die toe aan de variabele van de aanroepende code. De toewijzing in de aanroepende code is de stap die die variabele verandert.

Een resultaat kan ook ergens anders worden opgeslagen. Als triple(int n) zijn lokale variabele n met 3 vermenigvuldigt en die teruggeeft, blijft na int a = 4; int b = triple(a); de waarde van a gelijk aan 4 en krijgt b de waarde 12. Als je a + " " + b afdrukt, verschijnt “4 12”.

Pas dezelfde regel toe op String-referenties

Een String-variabele bevat een referentie naar een String-object. Java kopieert die referentie naar een String-parameter:

public static void exclaim(String text) {
    text = text + "!";
}

Als word in de aanroepende code naar “hi” verwijst, blijft word na exclaim(word); naar “hi” verwijzen. Concatenatie maakt een nieuwe String en de toewijzing verandert alleen waarnaar de parameter verwijst. De bestaande inhoud van strings kan niet worden gewijzigd.

Om de nieuwe tekst te bewaren, geef je text + "!" terug vanuit een String-methode zoals exclaimed en schrijf je daarna word = exclaimed(word);.

Bij veranderlijke objecten, zoals lijsten, kan een gekopieerde referentie nog steeds naar hetzelfde object wijzen. Een methode kan via de gekopieerde referentie de inhoud van dat object wijzigen. Door de parameter een nieuwe waarde te geven, kan de variabele van de aanroepende code nog steeds niet naar een ander object gaan verwijzen. Zowel de regel voor gekopieerde referenties als die voor gekopieerde getallen valt onder waardeoverdracht.

Je mag een parameter een nieuwe waarde geven, maar een afzonderlijke lokale variabele zoals result kan een langere berekening gemakkelijker leesbaar maken: de oorspronkelijke invoer blijft beschikbaar en je ziet welke waarde wordt teruggegeven.

De aanroepstack houdt aanroepen bij die zijn begonnen maar nog niet zijn voltooid. Elke aanroep krijgt een stackframe met zijn parameters, lokale variabelen en de plaats waar de aanroepende code verdergaat.

Plaats een frame, voltooi het en verwijder het

De stack werkt volgens laatst erin, eerst eruit. De nieuwste aanroep staat bovenaan en wordt uitgevoerd terwijl de aanroepende code eronder wacht. Wanneer de aanroep terugkeert, verwijdert Java het frame en hervat de aanroepende code.

public static void main(String[] args) {
    int total = totalSeconds(2, 30);
    System.out.println(total);
}

public static int totalSeconds(int minutes, int seconds) {
    int fromMinutes = toSeconds(minutes);
    return fromMinutes + seconds;
}

public static int toSeconds(int minutes) {
    return minutes * 60;
}

Volg het onafgemaakte werk:

1. main start en roept totalSeconds(2, 30) aan. De toewijzing aan total moet wachten.
2. Het nieuwe frame heeft minutes = 2 en seconds = 30. Het roept toSeconds(minutes) aan en wacht op fromMinutes.
3. toSeconds krijgt zijn eigen minutes = 2. De methode geeft 120 terug en haar frame wordt verwijderd.
4. totalSeconds slaat fromMinutes = 120 op, telt 30 erbij op en geeft 150 terug. Haar frame wordt verwijderd.
5. main slaat total = 150 op en drukt 150 af.

Op het diepste punt zijn de frames van onder naar boven main, totalSeconds en toSeconds. Beide hulpmethoden hebben een parameter met de naam minutes, maar die parameters staan in verschillende frames. De lokale variabelen van de wachtende aanroepende code worden niet zichtbaar voor de methode erboven.

Een latere aanroep krijgt een nieuw frame. Een lokale teller onthoudt zijn vorige waarde niet nadat zijn aanroep is beëindigd; de retourwaarde kan een resultaat teruggeven.

Lees een stacktrace vanaf de fout naar buiten

Bij een niet-afgehandelde exceptie drukt Java een stacktrace af die laat zien waar de fout optrad en welke aanroepen daartoe leidden. Hier is een volledig bestand:

public class Main {
    public static void main(String[] args) {
        report(300, 0);
    }

    public static void report(int meters, int minutes) {
        int speed = perMinute(meters, minutes);
        System.out.println(speed + " m per minute");
    }

    public static int perMinute(int meters, int minutes) {
        return meters / minutes;
    }
}

De eerste uitvoerregel is Exception in thread "main" java.lang.ArithmeticException: / by zero. De frames daaronder zijn:

at Main.perMinute(Main.java:12)
at Main.report(Main.java:7)
at Main.main(Main.java:3)

Het bovenste frame toont waar de geheeltallige deling door nul plaatsvindt. De volgende twee geven de plaatsen aan van de aanroepen die daartoe leidden. De regelnummers horen bij precies deze bestandsindeling; als je een regel toevoegt, veranderen ze.

De stack heeft een beperkte ruimte. Een keten die aanroepen blijft toevoegen zonder ze te laten eindigen, kan een StackOverflowError veroorzaken. In de stackweergave van een debugger kun je dezelfde keten bekijken terwijl de uitvoering bij een onderbrekingspunt is gepauzeerd, inclusief de afzonderlijke variabelen van elke wachtende aanroep.

Overladen geeft methoden dezelfde naam met verschillende parameterlijsten. Het is nuttig wanneer de methoden dezelfde taak uitvoeren voor verschillende aantallen of typen invoer.

Vergelijk signaturen

Voor deze methoden bestaat een signatuur uit de naam en de geordende parametertypen. Het aantal parameters volgt uit die lijst.

public static int max(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

public static int max(int a, int b, int c) {
    return max(max(a, b), c);
}

public static double max(double a, double b) {
    if (a > b) {
        return a;
    }
    return b;
}

De signaturen zijn max(int, int), max(int, int, int) en max(double, double). max(3, 9) gebruikt de eerste en geeft 9 terug. max(3, 9, 5) roept de tweede aan: de binnenste aanroep met twee ints geeft 9 terug, waarna de buitenste aanroep met twee ints 9 en 5 vergelijkt en ook 9 teruggeeft. max(2.5, 1.0) gebruikt de double-versie en geeft 2.5 terug.

Weet welke wijzigingen niet meetellen

Als je alleen een retourtype verandert, ontstaat geen overladen methodevariant. Deze methodekoppen zijn met elkaar in conflict:

public static int area(int w, int h)
public static double area(int w, int h)

Beide hebben de signatuur area(int, int). Java wijst de dubbele declaratie af. Ook als je de parameters hernoemt naar width en height, blijft de signatuur gelijk: de aanroepende code geeft waarden door op positie, niet op parameternaam.

De volgorde van verschillende typen telt wel mee. describe(String s, int n) en describe(int n, String s) zijn verschillende signaturen. Ze compileren samen, maar je moet bij een aanroep een gemakkelijk te verwarren volgorde onthouden, dus gebruik zo’n paar alleen als het het ontwerp helpt.

Laat een kortere methodevariant een standaardwaarde leveren

Java biedt geen standaardwaarden voor parameters in methodedeclaraties. Een kortere overladen methodevariant kan een langere aanroepen met een vast argument:

public static void printLine(int length, char symbol) {
    for (int i = 0; i < length; i++) {
        System.out.print(symbol);
    }
    System.out.println();
}

public static void printLine(int length) {
    printLine(length, '-');
}

printLine(5, '*'); drukt ***** af. printLine(4); gaat naar de kortere methode, die de langere aanroept met 4 en '-', en drukt ---- af. De lus staat op één plaats, dus wijzigingen in de afdruktaak gelden voor beide vormen.

De Java-bibliotheek gebruikt ook overladen methodevarianten. System.out.println accepteert een int, een double, een char, een boolean of een String via verschillende versies. Math.abs en Math.max bieden versies voor int, long, float en double.

Geef de gedeelde naam één betekenis. Een bon afdrukken en een etiket afdrukken zijn verschillende taken; duidelijke namen zoals printReceipt en printLabel vertellen de aanroepende code welke taak wordt uitgevoerd.

De compiler kiest een overladen methodevariant op basis van het aantal en de typen argumenten. Bepaal die keuze voordat je kijkt hoe de retourwaarde wordt gebruikt.

Begin met exacte overeenkomsten

Stel dat een klasse show(int x) en show(double x) definieert. show(5) gebruikt de int-versie omdat de literal 5 een int is. show(5.0) gebruikt de double-versie. Een geheelgetalswaarde die als 5.0 is geschreven, is nog steeds een double-expressie.

Vergelijk bij een aanroep met meerdere argumenten het type op elke positie. Een mogelijke methodevariant met het verkeerde aantal argumenten kan niet passen.

Sta zo nodig verbredende typeconversie toe

Als alleen show(double x) bestaat, is show(5) geldig: de int wordt met een verbredende typeconversie omgezet naar 5.0. De mogelijke verbredende typeconversies voor primitieve typen omvatten:

byte → short → int → long → float → double
char → int → long → float → double

Als zowel show(long x) als show(double x) bestaat, kiest een int-argument voor long. Dat is het specifiekere passende parametertype: een long kan met een verbredende typeconversie naar double worden omgezet, terwijl een double niet op die manier terug kan naar long.

Een verbredende typeconversie is een toegestane numerieke omzetting; dat betekent niet dat bij elke omzetting elk cijfer behouden blijft. Met name kan de omzetting van een voldoende grote long naar double de waarde afronden. De omzetting van int naar double in de eerdere voorbeelden behoudt alle int-waarden exact.

Een char heeft ook een numerieke waarde. Bij letter(int code) en letter(String text) roept letter('A') de int-versie aan met 65. Een teken wordt geen String om bij een parameter te passen. Dubbele aanhalingstekens in "A" zouden er daarentegen een String-argument van maken.

Wijs automatische versmallende typeconversie af

Met alleen show(int x) mislukt show(5.0). Java zet een double-argument niet met een versmallende typeconversie om alleen omdat de waarde toevallig een geheel getal is. show((int) 5.0) geeft na een expliciete typeconversie een int door.

Evenzo kunnen versies van max voor twee en drie ints max(1) niet accepteren. Geen enkele mogelijke methodevariant heeft het vereiste aantal parameters, dus meldt de compiler “no suitable method found”. Vergelijk de lijst met mogelijke methoden met de opgegeven argumenten.

Houd de selectie van de overladen methodevariant gescheiden van de omzetting van het resultaat

Bekijk int twice(int n) en double twice(double x). In double d = twice(3); kiest het argument de int-versie. Die aanroep geeft 6 terug, waarna de toewijzing die met een verbredende typeconversie omzet naar 6.0. De doelvariabele d kiest niet de double-versie.

Herken een dubbelzinnige aanroep

public static void combine(int a, double b) { }
public static void combine(double a, int b) { }

combine(1, 2) past bij de eerste na een verbredende typeconversie van het tweede argument en bij de tweede na zo’n conversie van het eerste. Geen van beide signaturen is over beide posities genomen specifieker. Java meldt “reference to combine is ambiguous”; het kiest niet de definitie die als eerste is geschreven.

combine(1, 2.0) past alleen bij (int, double), omdat de andere signatuur een versmallende typeconversie van 2.0 nodig zou hebben. Een duidelijk argumenttype of een betere verzameling overladen methodevarianten neemt de dubbelzinnigheid weg.

Decompositie betekent dat je een probleem in kleinere taken verdeelt en elke taak in een eigen methode oplost. Kies taken waarvan de namen iemand helpen het plan van het programma te lezen.

Houd berekeningen gescheiden van invoer en uitvoer

Een programma over een fietstocht heeft een snelheidsberekening en een rapport nodig. Die gebruiken dezelfde gegevens, maar hebben verschillende taken:

public static double kilometersPerHour(double km, double hours) {
    return km / hours;
}

public static void printRideReport(double speed) {
    System.out.println("Speed: " + speed + " km/h");
}

Voor een tocht van 150 km in 2 uur geeft de berekening 75.0 terug. De rapportagemethode ontvangt die waarde en geeft die weer. Aanroepende code verbindt de stappen:

double speed = kilometersPerHour(150, 2);
printRideReport(speed);

De berekening leest geen toetsenbordinvoer en drukt geen rapport af. Een ander programma kan de methode gebruiken om fietstochten te vergelijken of snelheden op te slaan zonder haar methodebody te wijzigen. Om de methode te testen, roep je haar aan met bekende invoer en vergelijk je het teruggegeven getal met het verwachte getal.

Herken een methode met te veel taken

Een naam zoals readAndCheckAndPrint wijst op meerdere handelingen. Andere aanwijzingen zijn onderdelen die door commentaar worden afgebakend, een methodebody die langer is dan één scherm en groepen variabelen die doelen dienen die niets met elkaar te maken hebben. Dit zijn redenen om de methode te bekijken, geen mechanische grenzen aan het toegestane aantal regels.

Splits op een betekenisvolle grens. Invoercode kan een waarde ophalen, een booleaanse hulpmethode kan die controleren, een berekening kan een resultaat teruggeven en een rapportagemethode kan dat resultaat weergeven. Dan leest main als een kort verslag van hoe die taken samenhangen.

Gerichte methoden kun je gemakkelijker afzonderlijk lezen, hergebruiken en testen. Als een rapportagevorm verandert, pas je de rapportagemethode aan. Als een berekening fout is, test je die berekening zonder een hele reeks invoer te hoeven typen.

Laat de methodekop de gegevensstroom uitleggen

In kilometersPerHour(double km, double hours) geeft de naam het resultaat aan, geven de parameternamen de grootheden aan en geeft het retourtype double aan om wat voor antwoord het gaat. Een kort Javadoc-commentaar kan de betekenis van de invoer en het resultaat toevoegen:

/**
 * Calculates a ride's average speed.
 * @param km distance in kilometers
 * @param hours elapsed time in hours, greater than zero
 * @return speed in kilometers per hour
 */

Plaats dat commentaar direct boven de methodekop. Nuttig commentaar voegt informatie toe, zoals eenheden of een eis aan de invoer; het hoeft niet elke regel van de methodebody te beschrijven.

Een hulpmethode die alleen binnen haar eigen klasse nodig is, kan private static zijn. private voorkomt dat andere klassen de methode aanroepen, terwijl code in dezelfde klasse haar nog wel kan gebruiken. Met public static is de hulpmethode beschikbaar voor andere klassen.

Als je elke vanzelfsprekende instructie in een eigen methode onderbrengt, kan ook dat het plan onduidelijk maken. Behoud een methode wanneer haar naam voor een betekenisvolle stap of herbruikbare berekening staat. Een keten van hulpmethoden die alleen dezelfde aanroep doorgeven, voegt plaatsen toe die je moet bekijken zonder meer van de taak uit te leggen.

Dubbele code herhaalt dezelfde taak op meerdere plaatsen. Als alleen de invoerwaarden verschillen, kan één methode met parameters het gemeenschappelijke werk bij elkaar houden.

Zoek de gemeenschappelijke berekening

Stel dat een programma de getallen van 1 tot en met 10 optelt en daarna die van 1 tot en met 50:

int total1 = 0;
for (int i = 1; i <= 10; i++) {
    total1 += i;
}
System.out.println("Sum 1 to 10: " + total1);
int total2 = 0;
for (int i = 1; i <= 50; i++) {
    total2 += i;
}
System.out.println("Sum 1 to 50: " + total2);

Beide lussen beginnen bij 1, tellen op bij een totaal en stoppen bij een bovengrens. Alleen die grens verandert. Een parameter n kan die doorgeven aan een gemeenschappelijke berekening.

Breng de code onder in een methode

public static int sumUpTo(int n) {
    int total = 0;
    for (int i = 1; i <= n; i++) {
        total += i;
    }
    return total;
}

n is de wisselende invoer. total en i zijn werkvariabelen die binnen de hulpmethode horen. De aanroepende code heeft de uiteindelijke som nodig, dus geeft de hulpmethode een int terug.

Vervang beide herhaalde delen:

System.out.println("Sum 1 to 10: " + sumUpTo(10));
System.out.println("Sum 1 to 50: " + sumUpTo(50));

sumUpTo(10) geeft 55 terug en sumUpTo(50) geeft 1275 terug. De afgedrukte regels zijn “Sum 1 to 10: 55” en “Sum 1 to 50: 1275”, net als voorheen. De beschrijvingen blijven in de aanroepende code; de lus voert alleen de berekening uit.

Controleer de methode-extractie in een vaste volgorde

1. Markeer de instructies die de herhaalde taak uitvoeren.
2. Bepaal elke waarde die tussen de kopieën verschilt.
3. Maak van die waarden parameters met passende typen en geef elk resultaat terug dat buiten de methode nodig is.
4. Vervang elke kopie door een aanroep met de oorspronkelijke invoer.
5. Voer het programma vóór en na de wijziging uit met dezelfde invoer en vergelijk het gedrag.

De structuur van code wijzigen terwijl het gedrag behouden blijft, heet refactoring. Als je één oorspronkelijke kopie laat staan, moet je bij een latere correctie nog steeds twee plaatsen aanpassen. Een afdrukinstructie naar een lus verplaatsen of een eindpunt van een lus veranderen, wijzigt het gedrag, ook als de code nu korter is.

Als twee verschillen verschillende typen hebben, gebruik je passende parameters. Verschillende teksten een verschillend aantal keren herhalen wijst op printRepeated(String text, int times); het woord is een String en het aantal is een int.

Code die op elkaar lijkt, voert niet altijd dezelfde taak uit. Een booleanparameter die een methode tussen verschillende berekeningen laat schakelen, kan haar aanroepen moeilijk te begrijpen maken. Geef verschillende taken verschillende namen. Breng de herhaalde bewerking alleen onder in een methode als die bij wisselende invoer één duidelijke betekenis behoudt.

Top-downontwerp begint met de hele taak en verfijnt die tot kleinere methodeaanroepen. Bepaal wat elke aanroep nodig heeft en teruggeeft voordat je elk detail invult.

Plan de stappen en methodekoppen

Een programma voor wekelijkse beweging leest 7 dagelijkse tijdsduren, telt die op en drukt een rapport af. De hulpmethoden kun je als volgt plannen:

• readMinutes(Scanner scanner, int day) geeft een geldig aantal minuten voor één dag terug.
• isValidMinutes(int minutes) geeft aan of de invoer van 0 tot en met 1440 loopt.
• formatDuration(int minutes) geeft tekst met hele uren en resterende minuten terug.
• averagePerDay(int total, int days) geeft een gemiddelde als double terug.
• printSummary(int totalMinutes, int days) drukt het rapport af.

Dezelfde Scanner wordt aan elke invoeraanroep doorgegeven. Een hulpmethode zoals isValidMinutes hoeft niet zelf invoer te lezen.

Gebruik stubs tijdens het bouwen

Een stub heeft de definitieve methodekop, maar een tijdelijke minimale methodebody, zoals return 0;. Daarmee kan het programma compileren voordat een hulpmethode is geïmplementeerd. Vervang één stub, compileer en controleer die methode voordat je de volgende vervangt. Een stub die compileert is nog steeds onaf werk; het vaste antwoord kan een echte berekening niet controleren.

Hier is het voltooide programma:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int total = 0;
        for (int day = 1; day <= 7; day++) {
            total += readMinutes(scanner, day);
        }
        printSummary(total, 7);
    }

    public static int readMinutes(Scanner scanner, int day) {
        System.out.println("Minutes for day " + day + ":");
        int minutes = scanner.nextInt();
        while (!isValidMinutes(minutes)) {
            System.out.println("Enter minutes from 0 to 1440:");
            minutes = scanner.nextInt();
        }
        return minutes;
    }

    public static boolean isValidMinutes(int minutes) {
        return minutes >= 0 && minutes <= 1440;
    }

    public static String formatDuration(int minutes) {
        return minutes / 60 + " h " + minutes % 60 + " min";
    }

    public static double averagePerDay(int total, int days) {
        return (double) total / days;
    }

    public static void printSummary(int totalMinutes, int days) {
        System.out.println("Total: " + formatDuration(totalMinutes));
        System.out.println("Daily average: "
            + averagePerDay(totalMinutes, days) + " min");
        if (totalMinutes >= 150) {
            System.out.println("Weekly goal reached");
        }
    }
}

Bij gehele invoer herhaalt readMinutes de controle van het bereik totdat het getal geldig is. Met de dagelijkse invoer 30, 45, 0, 60, 90, 45 en 45 is het totaal 315. De opmaak levert “5 h 15 min” op, het gemiddelde is 45.0 minuten en het programma meldt dat het weekdoel van 150 minuten is bereikt.

Controleer kleine methoden en hun grenzen

Roep elke berekening aan met bekende resultaten. formatDuration(0) moet “0 h 0 min” opleveren, 59 geeft “0 h 59 min”, 60 geeft “1 h 0 min” en 135 geeft “2 h 15 min”. De invoer net onder en op 60 controleert de overgang van minuten naar een heel uur.

Test voor isValidMinutes de waarden -1, 0, 1440 en 1441. De verwachte resultaten zijn false, true, true en false. Door verwachte en werkelijke waarden naast elkaar af te drukken, maak je een fout zichtbaar. JUnit automatiseert dit soort controles.

Bottom-upontwikkeling begint met het schrijven en testen van kleine hulpmethoden en voegt die daarna samen tot grotere stappen. Je kunt top-down plannen en bottom-up bouwen: bepaal eerst de gegevensstroom, toon aan dat de kleine berekeningen werken en controleer dan het samengevoegde programma.