Java Eenvoudige Rekenmachine Maken

Java Eenvoudige Rekenmachine

Hoe maak je een eenvoudige rekenmachine in Java: Complete Gids

Het maken van een eenvoudige rekenmachine in Java is een uitstekende oefening voor beginnende programmeurs om vertrouwd te raken met basisconcepten zoals:

  • Gebruikersinvoer verwerken met Scanner
  • Conditionele logica met if-else of switch statements
  • Basis wiskundige bewerkingen
  • Foutafhandeling met try-catch blokken
  • Methoden en klassen structureren

Stap 1: Project opzetten

Voordat je begint met coderen, moet je je ontwikkelomgeving gereedmaken:

  1. Installeer de Java Development Kit (JDK) (versie 11 of hoger)
  2. Kies een IDE:
  3. Maak een nieuw Java-project aan met een hoofdklasse (bijv. Calculator.java)

Stap 2: Basisstructuur van de rekenmachine

Hier is een minimale implementatie die de vier basisbewerkingen ondersteunt:

import java.util.Scanner; public class Calculator { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println(“Eenvoudige Java Rekenmachine”); System.out.println(“—————————-“); // Invoer eerste getal System.out.print(“Voer eerste getal in: “); double num1 = scanner.nextDouble(); // Invoer bewerking System.out.print(“Kies bewerking (+, -, *, /): “); char operator = scanner.next().charAt(0); // Invoer tweede getal System.out.print(“Voer tweede getal in: “); double num2 = scanner.nextDouble(); double result; // Bewerking uitvoeren switch(operator) { case ‘+’: result = num1 + num2; break; case ‘-‘: result = num1 – num2; break; case ‘*’: result = num1 * num2; break; case ‘/’: if (num2 != 0) { result = num1 / num2; } else { System.out.println(“Fout: Deling door nul is niet toegestaan!”); return; } break; default: System.out.println(“Ongeldige bewerking!”); return; } // Resultaat tonen System.out.printf(“Resultaat: %.2f %c %.2f = %.2f”, num1, operator, num2, result); scanner.close(); } }

Stap 3: Geavanceerde functionaliteit toevoegen

Om je rekenmachine professioneler te maken, kun je de volgende verbeteringen implementeren:

Functie Implementatie Voorbeeldcode
Herhaalde berekeningen Gebruik een while-lus om de rekenmachine draaiende te houden tot de gebruiker stopt while (true) {
  // berekeningslogica
  System.out.print("Nog een berekening? (j/n): ");
  if (scanner.next().equalsIgnoreCase("n")) break;
}
Foutafhandeling Gebruik try-catch voor ongeldige invoer try {
  num1 = scanner.nextDouble();
} catch (Exception e) {
  System.out.println("Ongeldige invoer!");
  return;
}
Geschiedenis bijhouden Sla berekeningen op in een ArrayList List<String> history = new ArrayList<>();
history.add(num1 + " " + operator + " " + num2 + " = " + result);
Wetenschappelijke functies Gebruik Math-klasse voor sin, cos, sqrt, etc. case 's': // vierkantswortel
  result = Math.sqrt(num1);
  break;

Stap 4: Object-georiënteerde benadering

Voor betere code-organisatie kun je de rekenmachine opsplitsen in meerdere klassen:

// CalculatorEngine.java public class CalculatorEngine { public double calculate(double num1, double num2, char operator) { switch(operator) { case ‘+’: return num1 + num2; case ‘-‘: return num1 – num2; case ‘*’: return num1 * num2; case ‘/’: if (num2 == 0) throw new ArithmeticException(“Deling door nul”); return num1 / num2; default: throw new IllegalArgumentException(“Ongeldige operator”); } } } // Main.java public class Main { public static void main(String[] args) { CalculatorEngine engine = new CalculatorEngine(); Scanner scanner = new Scanner(System.in); // Invoer logica… double result = engine.calculate(num1, num2, operator); System.out.println(“Resultaat: ” + result); } }

Stap 5: Grafische gebruikersinterface (GUI)

Voor een gebruiksvriendelijkere ervaring kun je JavaFX of Swing gebruiken:

import javax.swing.*; import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; public class CalculatorGUI { public static void main(String[] args) { JFrame frame = new JFrame(“Java Rekenmachine”); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(300, 400); JPanel panel = new JPanel(); panel.setLayout(new GridLayout(5, 4)); JTextField display = new JTextField(); display.setEditable(false); String[] buttons = { “7”, “8”, “9”, “/”, “4”, “5”, “6”, “*”, “1”, “2”, “3”, “-“, “0”, “.”, “=”, “+”, “C” }; for (String text : buttons) { JButton button = new JButton(text); button.addActionListener(new ButtonClickListener(display)); panel.add(button); } frame.add(display, BorderLayout.NORTH); frame.add(panel, BorderLayout.CENTER); frame.setVisible(true); } } class ButtonClickListener implements ActionListener { private JTextField display; public ButtonClickListener(JTextField display) { this.display = display; } public void actionPerformed(ActionEvent e) { String command = e.getActionCommand(); if (command.equals(“=”)) { // Bereken resultaat String expression = display.getText(); // Implementatie van berekeningslogica… } else if (command.equals(“C”)) { display.setText(“”); } else { display.setText(display.getText() + command); } } }

Veelgemaakte fouten en oplossingen

Fout Oorzaak Oplossing
Deling door nul Gebruiker voert 0 in als tweede getal bij deling Voeg een controle toe: if (num2 == 0) { /* foutmelding */ }
Ongeldige invoer Gebruiker voert tekst in waar een getal verwacht wordt Gebruik try-catch met InputMismatchException
Oneindige lus Verkeerde voorwaarde in while-lus Zorg voor een duidelijke exit-voorwaarde (bijv. “exit” commando)
Verkeerde berekening Operator niet correct verwerkt in switch Controleer alle case-statements en voeg een default toe
Afrundingsfouten Drijvende-komma berekeningen zijn niet precies Gebruik BigDecimal voor financiële berekeningen

Prestatieoptimalisaties

Voor complexe rekenmachines zijn er verschillende manieren om de prestaties te verbeteren:

  1. Caching: Sla veelgebruikte resultaten op in een cache (bijv. vierkantswortels van perfecte kwadraten)
  2. Parallelle verwerking: Voor wetenschappelijke berekeningen kun je ExecutorService gebruiken om berekeningen in parallelle threads uit te voeren
  3. Memoization: Sla tussentijdse resultaten op om herberekening te voorkomen (nuttig voor recursieve functies)
  4. JIT-compilatie: De Java JIT-compiler optimaliseert automatisch vaak gebruikte codepaden
  5. Primitive types: Gebruik double in plaats van BigDecimal als precisie niet kritiek is

Veelgestelde vragen

1. Welke Java-versie moet ik gebruiken?

Voor beginners wordt Java 11 of 17 aanbevolen omdat:

  • Ze LTS (Long-Term Support) versies zijn
  • Ze stabiel en goed gedocumenteerd zijn
  • De meeste tutorials en boeken deze versies gebruiken

2. Hoe kan ik mijn rekenmachine uitbreiden met geheugenfuncties?

Voeg deze variabelen en methoden toe aan je CalculatorEngine:

private double memory = 0; public void memoryAdd(double value) { memory += value; } public void memorySubtract(double value) { memory -= value; } public void memoryClear() { memory = 0; } public double memoryRecall() { return memory; }

3. Hoe implementeren andere programmeertalen rekenmachines?

Ter vergelijking hieronder hoe je een eenvoudige rekenmachine zou implementeren in andere populaire talen:

Taal Voorbeeldcode Opmerkingen
Python num1 = float(input("Eerste getal: "))
operator = input("Bewerking: ")
num2 = float(input("Tweede getal: "))

if operator == "+":
  result = num1 + num2
elif operator == "-":
  result = num1 - num2
# ... andere bewerkingen
print("Resultaat:", result) 		Dynamisch getypt, eenvoudige syntax
JavaScript function calculate() {
  let num1 = parseFloat(document.getElementById('num1').value);
  let operator = document.getElementById('operator').value;
  let num2 = parseFloat(document.getElementById('num2').value);
  let result;

  switch(operator) {
    case '+': result = num1 + num2; break;
    // andere cases
  }
  document.getElementById('result').textContent = result;
} 		Werkt in browsers, event-driven
C# using System;

class Calculator {
  static void Main() {
    Console.Write("Eerste getal: ");
    double num1 = Convert.ToDouble(Console.ReadLine());
    // ... andere invoer
    double result = operator switch {
      '+' => num1 + num2,
      '-' => num1 - num2,
      // andere cases
      _ => throw new InvalidOperationException()
    };
    Console.WriteLine($"Resultaat: {result}");
  }
} 		Vergelijkbaar met Java, met moderne switch-expressies

Autoritatieve bronnen en verdere lezing

Voor diepgaandere kennis over Java-programmering en rekenmachine-implementaties:

  1. Officiële Java Documentatie (Oracle) – De meest betrouwbare bron voor Java-syntax en API-referenties
  2. NPTEL Java Programming Course (IIT Kharagpur) – Gratis universiteitscursus over Java-fundamentals
  3. GeeksforGeeks Java Tutorials – Praktische voorbeelden en uitleg
  4. Baeldung Java Guides – Diepgaande artikelen over geavanceerde Java-concepten

Voor wiskundige algoritmen die je in je rekenmachine kunt implementeren:

  1. Richland Community College – Matrix Calculations – Toepassingen van matrixbewerkingen
  2. Wolfram MathWorld – Uitgebreide wiskundige formules en algoritmen

Conclusie

Het bouwen van een eenvoudige rekenmachine in Java is een uitstekende manier om vertrouwd te raken met:

  • Basis I/O-operaties
  • Controlestructuren (if-else, switch)
  • Foutafhandeling
  • Object-georiënteerd ontwerp
  • Gebruikersinterface-ontwikkeling

Begin met de basisversie en breid vervolgens stap voor stap functionaliteit uit. Experimenteer met:

  • Wetenschappelijke functies (sin, cos, log, etc.)
  • Geschiedenisfunctionaliteit
  • Thema’s voor je GUI
  • Unit tests met JUnit
  • Internationalisering (meerdere talen)

Onthoud dat het belangrijkste doel is om te leren en plezier te hebben tijdens het programmeren!

Leave a Reply

Your email address will not be published. Required fields are marked *