Swing calculator using GridLayout

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.Locale;

public class Main {

javax.swing supplies buttons, labels, panels and frames. java.awt supplies layouts, colours and fonts. java.awt.event supplies listener/event types. Locale is available where text formatting needs it. Main matches the source filename.

    static JPanel root(String title) {
        for(String key:new String[]{"Label.font","Button.font","RadioButton.font","CheckBox.font","TextField.font","TextArea.font","ComboBox.font"})UIManager.put(key,new Font(Font.SANS_SERIF,Font.PLAIN,18));

root configures the selected UIManager font keys to an 18-point sans-serif font before creating the form’s components. This affects the Java application, not the website’s CSS.

        JPanel panel=new JPanel(new BorderLayout(12,12));panel.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
        JLabel heading=new JLabel(title);heading.setFont(new Font(Font.SANS_SERIF,Font.BOLD,24));panel.add(heading,BorderLayout.NORTH);return panel;
    }

BorderLayout places the heading in NORTH and leaves CENTER for each experiment’s form. The empty border adds padding; the heading uses a larger bold font. Return the JPanel for further assembly.

    static void show(String title,JPanel panel) {
        JFrame frame=new JFrame(title);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.setContentPane(panel);frame.pack();frame.setLocationRelativeTo(null);frame.setVisible(true);
    }

show creates a JFrame, installs its content, packs it to component sizes, centres it and makes it visible. EXIT_ON_CLOSE ends this demonstration application when its window closes. The desktop main calls this helper on the event-dispatch thread.

    static double calculate(double a,double b,String operator){
        double result;
        switch(operator){case "+":result=a+b;break;case "-":result=a-b;break;case "*":result=a*b;break;case "/":if(b==0)throw new ArithmeticException("Division by zero");result=a/b;break;case "%":if(b==0)throw new ArithmeticException("Remainder by zero");result=a%b;break;default:throw new IllegalArgumentException("Choose an operation");}
        if(!Double.isFinite(result))throw new ArithmeticException("Non-finite result");return result;
    }

The switch handles +, -, *, / and %. The explicit zero checks turn invalid division/remainder into ArithmeticException. Reject a non-finite final result. This method uses double arithmetic, unlike the separate integer-division exercise.

    static class Calculator {
        final JTextField display=new JTextField("0",22);
        private double stored;private String operator="";private boolean fresh=true;
        Calculator(){display.setEditable(false);display.setHorizontalAlignment(JTextField.RIGHT);display.setName("display");}

Calculator owns a read-only display, stored first operand, pending operator and fresh flag. fresh indicates whether the next digit should begin a new entry rather than append to the current one.

        void press(String key){
            try{
                if(key.equals("C")){stored=0;operator="";fresh=true;display.setText("0");return;}

press receives the key label. C resets stored value, pending operation, entry state and display, then returns so the remaining cases do not run.

                if(key.matches("[0-9.]")){
                    String current=fresh?"":display.getText();if(key.equals(".")&&current.contains("."))return;
                    if(current.length()>=16)return;if(key.equals(".")&&current.isEmpty())current="0";
                    display.setText(current+key);fresh=false;return;
                }

For digits or a decimal point, start blank when fresh. Ignore a second decimal point and entries beyond 16 characters. Prefix a leading dot with zero. Update display, mark entry active and return.

                double value=Double.parseDouble(display.getText());
                if(key.equals("=")){
                    if(operator.isEmpty()||fresh)throw new IllegalArgumentException("Enter both operands");
                    display.setText(Double.toString(calculate(stored,value,operator)));operator="";fresh=true;

Parse the displayed value. Equals requires a pending operator and a completed second entry. Calculate using stored and value, display the result, clear the pending operator and mark the next entry fresh.

                }else{
                    if(!operator.isEmpty()&&!fresh)value=calculate(stored,value,operator);
                    stored=value;operator=key;display.setText(Double.toString(value));fresh=true;
                }

If a previous operator and second entry are ready, calculate that pending operation first. Then save the resulting value and new operator. This state machine evaluates button sequences, not a full expression parser with precedence.

            }catch(IllegalArgumentException|ArithmeticException e){display.setText("Error");operator="";fresh=true;}
        }
    }

Catch the two runtime exception types, show Error and reset the operator/fresh state. The next numeric entry can start a new value. These braces close press and Calculator.

    public static JPanel createPanel(){
        JPanel panel=root("Simple Calculator");Calculator calculator=new Calculator();calculator.display.setFont(new Font(Font.MONOSPACED,Font.PLAIN,24));
        JPanel center=new JPanel(new BorderLayout(10,10));center.add(calculator.display,BorderLayout.NORTH);JPanel keys=new JPanel(new GridLayout(4,4,8,8));

Create the shared root, one Calculator object, a larger monospaced display and a BorderLayout center. A 4-by-4 grid holds the main keys.

        for(String key:new String[]{"7","8","9","/","4","5","6","*","1","2","3","-","0",".","=","+"}){JButton button=new JButton(key);button.addActionListener(e->calculator.press(key));keys.add(button);}center.add(keys,BorderLayout.CENTER);panel.add(center,BorderLayout.CENTER);
        JPanel extras=new JPanel();for(String key:new String[]{"%","C"}){JButton button=new JButton(key);button.addActionListener(e->calculator.press(key));extras.add(button);}panel.add(extras,BorderLayout.SOUTH);return panel;
    }

Each button listener calls calculator.press with its label. Add % and C separately below. Returning the panel preserves the listener references to calculator for later events.

    public static void main(String[] args){SwingUtilities.invokeLater(()->show("Simple Calculator",createPanel()));}

}

SwingUtilities.invokeLater schedules the lambda on Swing’s event-dispatch thread. The lambda creates the panel and calls show. This main needs a graphical desktop; the panel and its event handlers are separate from console input.