Natuurlijk! Hier is een stapsgewijze gids voor het bouwen van een Java-toepassing die principes van contractontwerp integreert, inclusief voorbeelden en tips voor validatie: ### 1. Begrijp het contractontwerpprincipe Contractontwerp (ook wel Design by Contract genoemd) richt zich op het expliciet maken van de verwachte voorwaarden en garanties tussen methoden en klassen: - **Precondities:** Wat moet waar zijn voordat een methode wordt uitgevoerd. - **Postcondities:** Wat moet waar zijn nadat de methode is uitgevoerd. - **Invarianten:** Fundamentele voorwaarden die altijd waar moeten zijn voor een object. ### 2. Structuur van je klassen en methoden Gebruik expliciete controles binnen je methoden om deze voorwaarden te valideren. Dit kan met behulp van `assert`, `if`-controles of speciale validatiemethoden. --- ### 3. Voorbeeld: Een eenvoudige `Bankrekening` klasse ```java public class Bankrekening { private double saldo; private final double limiet; // bijvoorbeeld een negatieve limiet voor rood staan public Bankrekening(double initSaldo, double limiet) { // Invariant: saldo >= limiet validateInvariants(); if (initSaldo < limiet) { throw new IllegalArgumentException("Init saldo mag niet lager zijn dan limiet"); } this.saldo = initSaldo; this.limiet = limiet; // Invariant check na constructie validateInvariants(); } public void storten(double bedrag) { // Preconditie: bedrag > 0 if (bedrag <= 0) { throw new IllegalArgumentException("Stortingsbedrag moet positief zijn"); } double oudSaldo = saldo; saldo += bedrag; // Postconditie: nieuw saldo = oudSaldo + bedrag assert saldo == oudSaldo + bedrag : "Postconditie niet voldaan"; validateInvariants(); } public void opnemen(double bedrag) { // Precondities if (bedrag <= 0) { throw new IllegalArgumentException("Opnamebedrag moet positief zijn"); } if (saldo - bedrag < limiet) { throw new IllegalArgumentException("Saldo mag niet onder limiet komen"); } double oudSaldo = saldo; saldo -= bedrag; // Postconditie assert saldo == oudSaldo - bedrag : "Postconditie niet voldaan"; validateInvariants(); } private void validateInvariants() { // Invariant: saldo >= limiet if (saldo < limiet) { throw new IllegalStateException("Invariante overtreding: saldo onder limiet"); } } public double getSaldo() { return saldo; } } ``` --- ### 4. Validatie van precondities, postcondities en invarianten - **Precondities:** Controleer direct aan het begin van de methode met `if`-uitspraken en gooi `IllegalArgumentException` als ze niet voldaan worden. - **Postcondities:** Controleer na de uitvoering met `assert` of expliciete controle of de verwachte toestand is bereikt. - **Invarianten:** Controleer via een aparte methode (`validateInvariants`) die je na elke muterende operatie aanroept. ### 5. Validatie van geldige invoerwaarden - Gebruik expliciete controles: ```java if (bedrag <= 0) { throw new IllegalArgumentException("Bedrag moet positief zijn"); } ``` - Overweeg het gebruik van Java's `Objects.requireNonNull()` voor objecten. - Documenteer duidelijk de verwachte invoerwaarden in je methoden (JavaDoc). --- ### 6. Extra tips - Gebruik `assert` voor interne debug-controles (optioneel, want `assert` kan uitgeschakeld worden). - Voor productiecode: gebruik expliciete controles en uitzonderingen. - Overweeg het gebruik van contractbibliotheken zoals [Java Modeling Language (JML)](https://www.ejml.org/) of externe validatieframeworks voor meer geavanceerde contractondersteuning. --- ### Samenvatting - Definieer vooraf condities (precondities) met controles aan het begin van methoden. - Controleer na uitvoering of de garanties (postcondities) worden gehaald. - Houd de invarianten van je klasse consistent en valideer ze na elke muterende operatie. - Gebruik duidelijke exception handling en documentatie voor invoervalidatie. Wil je meer voorbeelden voor specifieke gebieden of een uitgebreide aanpak voor complexere klassen?

Zeker, ik help je graag met het integreren van contractontwerp in je Java-toepassing. Hier is een stapsgewijze handleiding met concrete voorbeelden: ## Stap 1: Basisprincipes van Contractontwerp Contractontwerp (Design by Contract) omvat: - **Precondities**: Vereisten die vóór methode-uitvoering moeten gelden - **Postcondities**: Garanties die na methode-uitvoering gelden - **Invarianten**: Condities die altijd waar moeten blijven voor een klasse ## Stap 2: Implementatie met Java Assertions ```java public class BankRekening { private double saldo; private final String rekeningNummer; // Klasse-invariant private void checkInvariant() { assert saldo >= 0 : "Saldo mag niet negatief zijn"; assert rekeningNummer != null && !rekeningNummer.isEmpty() : "Ongeldig rekeningnummer"; } public BankRekening(String rekeningNummer, double startsaldo) { // Precondities assert rekeningNummer != null && !rekeningNummer.isEmpty() : "Rekeningnummer is verplicht"; assert startsaldo >= 0 : "Startsaldo mag niet negatief zijn"; this.rekeningNummer = rekeningNummer; this.saldo = startsaldo; checkInvariant(); // Postconditie constructor } public void stort(double bedrag) { checkInvariant(); // Preconditie // Precondities methode assert bedrag > 0 : "Stortbedrag moet positief zijn"; double oudSaldo = saldo; // Voor postconditie controle saldo += bedrag; // Postcondities assert saldo == oudSaldo + bedrag : "Saldo niet correct bijgewerkt"; assert saldo >= 0 : "Saldo negatief geworden"; checkInvariant(); // Postconditie } public void neemOp(double bedrag) { checkInvariant(); // Preconditie // Precondities methode assert bedrag > 0 : "Opnamebedrag moet positief zijn"; assert saldo >= bedrag : "Onvoldoende saldo"; double oudSaldo = saldo; saldo -= bedrag; // Postcondities assert saldo == oudSaldo - bedrag : "Saldo niet correct bijgewerkt"; assert saldo >= 0 : "Saldo negatief geworden"; checkInvariant(); // Postconditie } public double getSaldo() { checkInvariant(); return saldo; } } ``` ## Stap 3: Geavanceerde Validatie met Custom Checks ```java import java.util.Objects; public class GebruikersValidator { public static class Gebruiker { private final String naam; private final int leeftijd; private final String email; public Gebruiker(String naam, int leeftijd, String email) { // Precondities met duidelijke foutmeldingen valideerNaam(naam); valideerLeeftijd(leeftijd); valideerEmail(email); this.naam = naam; this.leeftijd = leeftijd; this.email = email; checkInvariant(); } private void checkInvariant() { assert naam != null && naam.length() >= 2 : "Naam moet minimaal 2 karakters bevatten"; assert leeftijd >= 0 && leeftijd <= 150 : "Leeftijd moet tussen 0 en 150 zijn"; assert email != null && email.contains("@") : "Ongeldig e-mailformaat"; } private void valideerNaam(String naam) { Objects.requireNonNull(naam, "Naam mag niet null zijn"); assert naam.length() >= 2 : "Naam moet minimaal 2 karakters bevatten"; assert naam.matches("[a-zA-Z\\s]+") : "Naam mag alleen letters en spaties bevatten"; } private void valideerLeeftijd(int leeftijd) { assert leeftijd >= 0 : "Leeftijd mag niet negatief zijn"; assert leeftijd <= 150 : "Leeftijd mag niet groter zijn dan 150"; } private void valideerEmail(String email) { Objects.requireNonNull(email, "E-mail mag niet null zijn"); assert email.contains("@") : "E-mail moet een @ bevatten"; assert email.length() >= 5 : "E-mail moet minimaal 5 karakters bevatten"; } public void wijzigEmail(String nieuweEmail) { checkInvariant(); // Preconditie valideerEmail(nieuweEmail); String oudeEmail = this.email; // Simulatie van email wijziging // this.email = nieuweEmail; // In echte implementatie // Postconditie assert !nieuweEmail.equals(oudeEmail) || nieuweEmail.equals(oudeEmail) : "Email wijziging niet consistent"; checkInvariant(); // Postconditie } } } ``` ## Stap 4: Gebruik van Java's Built-in Validatie ```java import java.util.Objects; public class Product { private final String naam; private final double prijs; private final int voorraad; public Product(String naam, double prijs, int voorraad) { // Precondities met Objects.requireNonNull this.naam = Objects.requireNonNull(naam, "Productnaam mag niet null zijn"); // Precondities met assertions assert prijs >= 0 : "Prijs mag niet negatief zijn"; assert voorraad >= 0 : "Voorraad mag niet negatief zijn"; assert naam.length() >= 2 : "Productnaam moet minimaal 2 karakters bevatten"; this.prijs = prijs; this.voorraad = voorraad; checkInvariant(); } private void checkInvariant() { assert naam != null && !naam.trim().isEmpty() : "Productnaam mag niet leeg zijn"; assert prijs >= 0 : "Prijs invariant geschonden"; assert voorraad >= 0 : "Voorraad invariant geschonden"; } public void verhoogPrijs(double percentage) { checkInvariant(); // Precondities assert percentage > 0 : "Percentage moet positief zijn"; assert percentage <= 100 : "Percentage mag niet meer dan 100 zijn"; double oudePrijs = this.prijs; // double nieuwePrijs = this.prijs * (1 + percentage/100); // Postconditie // assert nieuwePrijs > oudePrijs : "Prijs moet verhoogd zijn"; checkInvariant(); } } ``` ## Stap 5: Testen van de Contracten ```java public class ContractTest { public static void main(String[] args) { // Schakel assertions in (standaard uit in productie) // Voer uit met: java -ea ContractTest testBankRekening(); testGebruiker(); testProduct(); } private static void testBankRekening() { try { BankRekening rekening = new BankRekening("NL123456789", 100.0); rekening.stort(50.0); rekening.neemOp(30.0); // Deze zouden assertions moeten triggeren: // new BankRekening("", 100.0); // Ongeldig rekeningnummer // new BankRekening("NL123", -50.0); // Negatief startsaldo // rekening.neemOp(200.0); // Onvoldoende saldo } catch (AssertionError e) { System.out.println("Contract geschonden: " + e.getMessage()); } } private static void testGebruiker() { try { GebruikersValidator.Gebruiker gebruiker = new GebruikersValidator.Gebruiker("Jan Jansen", 25, "jan@example.com"); gebruiker.wijzigEmail("nieuw@example.com"); } catch (AssertionError | NullPointerException e) { System.out.println("Validatie gefaald: " + e.getMessage()); } } private static void testProduct() { try { Product product = new Product("Laptop", 999.99, 10); product.verhoogPrijs(10.0); } catch (AssertionError e) { System.out.println("Product contract geschonden: " + e.getMessage()); } } } ``` ## Stap 6: Best Practices voor Effectieve Validatie 1. **Schakel assertions in tijdens ontwikkeling**: ```bash java -ea YourApplication ``` 2. **Gebruik betekenisvolle foutmeldingen** in assertions 3. **Combineer verschillende validatietechnieken**: - `Objects.requireNonNull()` voor null checks - Assertions voor complexe bedrijfsregels - Custom exception handling voor productiecode 4. **Documenteer contracten duidelijk** in Javadoc: ```java /** * Stort geld op de rekening. * * @param bedrag het te storten bedrag * @pre bedrag > 0 "Bedrag moet positief zijn" * @post saldo == old(saldo) + bedrag * @inv saldo >= 0 */ public void stort(double bedrag) { // implementatie } ``` ## Belangrijke Opmerkingen: - Assertions zijn standaard **uitgeschakeld** in Java - Gebruik assertions vooral tijdens **ontwikkeling en testen** - Voor productiecode: overweeg een library zoals **Valid4j** of **Apache Commons Validator** - Always validate input at the **boundaries** of your system Deze aanpak zorgt voor robuuste, betrouwbare code die duidelijk aangeeft wanneer contracten worden geschonden!