Module A2 Java, code indelen

Studieonderdelen

Gebruik van een methode

Tot nu toe heb je in Java alleen een stukje code geschreven in de main-methode. Dit is de methode die in Java het startpunt van een programma aangeeft. In een Java-project is er een klasse die wordt gestart, daarin wordt gezocht naar de methode zoals hieronder: Als je programma uitgebreider wordt en je zou alle code in de methode main zetten wordt dit een heel lange en onoverzichtelijke code. Het eerste wat je gaat doen om dit op te lossen is aparte methoden maken voor stukken code.

Voorbeeld

public class ConsoleApp {

  	public static void main(String[] args) {
  		int dobbel;
  		dobbel = gooiDobbelsteen();
  		System.out.println(dobbel);
  	}

  	private static int gooiDobbelsteen() {
  		return (int)(1 + 6 *  Math.random());
  	}

}
    

Uitleg code

Binnen de klasse ConsoleApp wordt een tweede methode geplaatst die een worp met een dobbelsteen nadoet en het resultaat van de worp teruggeeft.

• De Math.random() geeft een willekeurig kommagetal tussen 0 en 1.
• Door dit getal te vermenigvuldigen met 6 en te verhogen met 1 krijg je een getal van 1 tot 7 (maar niet 7 zelf)
• Daarna wordt het resultaat getypecast naar een integer waardoor je alleen het getal voor de komma (1 tot en met 6) overhoudt.
• Met de opdracht return wordt dit getal teruggegeven als resultaat van de functie.

In de definitie van de methode staat private static int:

• private betekent dat de methode alleen bestaat binnen de klasse waarin hij staat. Dus gooiDobbelsteen mag alleen gebruikt worden binnen de klasse ConsoleApp.
• static geeft aan dat deze methode gebruikt mag worden zonder eerst een object te maken van de klasse waarin de methode staat. Deze methode moet static zijn omdat de methode die hem gebruikt, de main-methode, ook static is. Later gaan we dat aanpassen door meerdere klassen te gebruiken.
• int geeft het returntype van de methode aan. In dit geval is het resultaat van de methode een integer dus een geheel getal. De methode mag daardoor met return alleen een integer waarde teruggeven, en de methode moet een waarde van het type integer teruggeven. Zonder het juiste return statement zie je foutmelding en kun je je code niet compileren. Als je wilt dat een methode is doet maar geen resultaat teruggeeft, gebruik je als returntype void Engels voor leegte (niets).

Oefeningen

Voor de volgende oefeningen kan je een video bekijken:

Argumenten

Het voorbeeld van de dobbelsteen voert de code uit en geeft het resultaat terug. Hierbij wordt bij de aanroep van de methode geen informatie meegeven, maar dat wil je vaak wel. Dit kun je doen door argumenten te gebruiken.

Voorbeeld 1

public class ConsoleApp {

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

    private static int verhoogMetEen(int invoer) {
    	return ++invoer;
    }

}
    

Uitleg code

De methode verhoogMetEen gebruikt de waarde die wordt meegegeven en verhoogt deze met 1, daarna wordt het resultaat weer teruggegeven.

• ++invoer verhoogt de waarde in invoer met 1 voor dat de waarde wordt gebruikt. Dit is wat anders dan invoer++, want daar wordt de waarde van invoer eerst gebruikt en daar pas verhoogt met 1. In dit voorbeeld zou invoer++ er voor zorgen dat de methode als resultaat de waarde teruggeeft dit in het argument invoer is meegegeven. Probeer dat zelf maar eens.
• (int invoer) geeft aan dat deze methode bij de aanroep gewacht dat er een integer waarde wordt meegegeven. Deze waarde wordt binnen de methode opgeslagen in de variabele invoer. Deze variabele kun je alleen binnen de methode gebruiken.

Voorbeeld 2

public class ConsoleApp {
    public static void main(String[] args) {
    	int a = 10;
    	int b = 5;
    	int som = telOp(a,b);
     System.out.println(som);
    }

    private static int telOp(int getal1, int getal2) {
    	return getal1 + getal2;
    }
}
    

Uitleg code

De methode telOp tel de twee argumenten bij elkaar op en geeft het resultaat (de som) terug.

• (int getal1, int getal2) de argumenten worden gescheiden door een komma. Elk argument wordt voorafgegaan door het type, in dit geval allebei int.

Oefeningen

Static

Voorbeeld

// ConsoleApp.java
public class ConsoleApp {

	public static void main(String[] args) {
		Dobbelsteen dobbelsteen = new Dobbelsteen();
		int dobbel;
		dobbel = dobbelsteen.gooi();
		System.out.println(dobbel);
	}
}
    

// Dobbelsteen.java
public class Dobbelsteen {

	public int gooi() {
		return (int)(1 + 6 * Math.random());
	}
}
    

Uitleg code

Er wordt nu een twee bronbestand binnen het project gemaakt voor de klasse Dobbelsteen. Het bestand moet dezelfde naam hebben als de publieke klasse die er in staat. Dus in dit geval heet het bronbestand Dobbelsteen.java (let op de hoofdletters).

In de klasse Dobbelsteen maken we de methode gooi met de code die een dobbelsteen worp nadoet. Deze methode hoeft niet static te zijn, omdat we eerst een object gaan maken van de klasse Dobbelsteen. Dat gebeurt in de main methode van de ConsoleApp klasse. Een object gemaakt op basis van een klasse heet een instantie van de klasse.

Code in main

• Dobbelsteen dobbelsteen = new Dobbelsteen();

  Op deze regel worden drie dingen tegelijk gedaan:

  1. Dobbelsteen dobbelsteen - Er wordt een variabele met de naam dobbelsteen gemaakt van het type Dobbelsteen (kan een Dobbelsteen object bevatten).
  2. new Dobbelsteen() - Er wordt een nieuwe instantie van de klasse Dobbelsteen gemaakt, het resultaat is een Dobbelsteen-object.
  3. ... = ... - Het nieuwe Dobbelsteen-object wordt opgeslagen in de dobbelsteen variabele
• int dobbel maakt een integer variabele met de naam dobbel waar we later de waarde van de gegooide dobbelsteen in kunnen opslaan.
• dobbel = dobbelsteen.gooi() roept de methode gooi van het object dobbelsteen aan en zet het resultaat in de variabele dobbel.

Oefeningen

Voor oefening 8, 9 en 10 is een video:

Scope van een variabele/methode

Bij het maken van een variabele of een methode geef je aan wat de scope is. De scope bepaald waar je de variabele of methode kunt gebruiken. Dit doe je door de gereserveerde woorden public, private of protected er voor te zetten. Wat protected betekent komt later als je meer leert over klassen en objecten.

Behalve de declaratie met public of private wordt de scope van een variabele ook bepaald door de plek waar je de variabele maakt.

public class Main {
	public static void main(String[] args) {
		Scope scope = new Scope();
		System.out.println(scope.string1);
		System.out.println();
		System.out.println(scope.getStringsFromVariables());
		System.out.println();
		System.out.println(scope.getStringsFromMethods());
		System.out.println();
		System.out.println(scope.getOtherString());
	}
}
    

public class Scope {

	public String string1 = "Een tekenreeks in scope";
	private String string2 = "Nog een  tekenreeks in scope";

	private String getString(int i) {
		if(i == 1) {
			return string1;
		} else {
			return string2;
		}
	}

	public String getStringsFromVariables() {
		return string1 + "\n" + string2;
	}

	public String getStringsFromMethods() {
		return getString(1) + "\n" + getString(2);
	}

	public String getOtherString() {
		String other = "Een andere tekenreeks";
		return other;
	}

}
    

Uitleg

• De variabele string1 is public gedeclareerd en mag binnen de klasse gebruikt worden maar ook in Main waar een object van de klasse Scope is gemaakt.
• De variabele string2 is private gedeclareerd en mag binnen de klasse gebruikt worden, in de klasse Main is deze variabele niet beschikbaar.
• De variabele other is gedeclareerd binnen het blok van de methode getOtherString() en is alleen daar te gebruiken. Voor elke variabele binnen een methode geldt dat hij alleen te gebruiken is binnen het eerste blok waar hij in staat, dus binnen de accolades die de variabele als eerste omsluiten.
• De methode getString(int i) is private gedeclareerd en mag binnen de klasse gebruikt worden, daar buiten, bijvoorbeeld in Main is deze methode niet beschikbaar.
• De methoden getStringsFromVariables() en getStringsFromMethods() zijn public gedeclareerd en kunnen binnen de klasse gebruikt worden en zijn ook in Main beschikbaar via het object scope van de klasse Scope.

Regels

• Over het algemeen geldt; maak de scope van een variabele zo klein mogelijk.
• Geef een variabele met een grotere scope een langere beschrijvende naam.

Recursie

Recursie is een truc om code van met name problemen met een wiskundige achtergrond simpeler te maken. Bij recursie wordt in een methode dezelfde methode weer aangeroepen, maar dan met een andere parameter. Dit klinkt ingewikkeld, dus bespreken we een voorbeeld.

Voorbeeld: vermenigvuldigen van twee getallen

Vermenigvuldigen is iets wat je al op de basisschool hebt geleerd. Nu gaan we er iets wiskundiger naar kijken. We stappen even bewust er over heen, dat vermenigvuldigen in een programmeertaal heel gemakkelijk is (er zijn trouwens nog steeds programmeertalen die niet kunnen vermenigvuldigen, dit heeft meestal met de simpelheid van het platform te maken)

Stel je voor: je wilt 4*3 berekenen, we weten allemaal dat de uitkomst 12 is, maar bereken je dat?

Uitkomst = 4 + 4 + 4

Dus: je neemt 4 (1e keer) en dan tel je daar 4 bij op (2e keer) en daar bij tel je nog een keer 4 op. Je hebt dus 3 vieren bij elkaar opgeteld. Hieronder vind je de voorbeeld code:

public class Vermenigvuldiging {

    public int vermenigvuldig(int aantalkeer, int getal) {
        if (aantalkeer == 0) {
            return 0;
        } else if (aantalkeer == 1) {
            return getal;
        } else {
            return vermenigvuldig(aantalkeer-1, getal) + getal;
        }
    }
}
    

Uitleg

Stel je roept deze methode aan met vermenigvuldig(0, 3):

1. aantalkeer is dan 0.
2. De methode keert dan terug met 0. Immers 0*3= 0

Daarna proberen we een aanroep met vermenigvuldig(1, 3):

1. aantalkeer is 1
2. De methode keert dan terug met 3, zoals we geleerd hebben bij rekenen: 1*3= 3

Tot slot de laatste mogelijkheid, de aanroep met vermenigvuldig(2, 3):

1. aantalkeer is 2
2. De methode roept zichzelf aan met aantalkeer – 1 (2-1=1)
3. In de tweede ronde geldt dus aantalkeer is 1
4. De tweede aanroep keert terug met antwoord 3
5. Daar tellen we 3 bij op (3 + 3 = 6)
6. De eerste aanroep keert terug met antwoord 6

Niet oneindig doorgaan

Een van de belangrijkste eigenschappen van een recursieve methode is dat er ook een stop-conditie in zit. Want anders zou het kunnen zijn dat je oneindig doorgaat, omdat je steeds weer dezelfde methode aanroept die zichzelf aanroept die zichzelf aanroept….

Uiteindelijk het programma of erger je computer vastloopt. In bovenstaande code wordt dit geregeld door de regels

if (aantalkeer == 0) {
    return 0;
} else if (aantalkeer == 1) {
    return getal;
}
    

We weten dat er elke keer -1 gedaan wordt, en dus zul je een keer bij aantalkeer = 1 aankomen, en dan springt de methode weer terug naar buiten. En aantalkeer = 0 zorgt ervoor dat het goed gaat als je met 0 begint.

Schematisch gezien loopt het programma als volgt:

public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Vermenigvuldiging v = new Vermenigvuldiging();

        System.out.println("4 * 3 = "+Integer.toString(v.vermenigvuldig(4, 3)));
        System.out.println("6 * 5 = "+Integer.toString(v.vermenigvuldig(6, 5)));
    }

}
      

Voorbeeld 2: Faculteit berekenen

Met dezelfde manier kun je ook een faculteit berekenen (zie ook de bronnen)

• 0! = 1
• 1! = 1
• 2! = 1 *2
• 3! = 1 * 2 *3
• 4!= 1 * 2 * 3 *4
• Enzovoort

Eindopdrachten

Je kunt de code voor de eindopdrachten ophalen op https://github.com/DrentheCollege/A2Eindopdrachten.git met een git clone opdracht.

Er is een video met uitleg over de eindopdrachten:

Opdracht 1: Formules uitrekenen

Maak een recursieve functie die berekeningen kan doen.

De eisen:

• We volgen de standaard rekenregels
• Dus binnen de haakjes eerst uitrekenen
• Eerst vermenigvuldigen en daarna pas optellen en aftrekken
• We gebruiken gehele getallen (int)

Dus bijvoorbeeld:

4 + 3 =7

4 *3 + 2 = 12 + 2 = 14

(3+4)*3 = 7 * 3 = 21

( ( 2 +1) * 4) + (2 * 3) = ( 3 * 4) + (2 * 3) = 12 + 6 = 18

Dat moet je oplossen met een recursieve methode (definitie: public int bereken(String input), en vergeet niet om het resultaat steeds terug te geven (return).

Je kunt dit controleren met bovenstaande sommen (gebruik die bijvoorbeeld in je code), maar bedenk er zelf ook 3 en controleer het resultaat.

Opdracht 2: String van karakters opruimen

In deze opdracht krijg je een stuk code dat niet af is. Bedenk hier een manier om alle niet wenselijke karakters uit de string te halen. Maak een nieuwe klasse die dit gaat doen, en gebruik zoveel mogelijk methodes.

Tekst.replaceAll is niet toegestaan, het is de bedoeling dat je zelf het programma bedenkt en schrijft.