If you’re learning Java and want to build something fun and useful, a currency converter is a great idea. It’s one of those projects that feels like a real-world app, and it teaches you how to take user input, do some logic, and show results.
In this blog, I’ll Walk you through how a currency converter works, not the code itself, but the steps and logic behind it.
What This Converter Can Do
The goal of this project is to make a small app where a user can:
- Type an amount (like 100)
- Choose a currency to convert from
- Choose a currency to convert to
- Click a button to convert it
- See the result on the screen
So for example, if the user types “100”, selects “USD” as “From” and “INR” as “To”, the app should show something like:
Result: 8300.0 INR (assuming 1 USD = 83 INR)
How the App Is Built
This app is made using Java Swing, which helps us create windows, buttons, dropdowns, and labels. Swing is perfect for small desktop applications like this.
Logic Steps: Currency Converter in Java
Now, we’ll see total 5 steps to know how we can create our own app for Currency Converter
Step 1: Creating the Window
First, the app needs a window where everything will be shown. In Java, this is done by creating a frame. Think of it like a blank canvas.
We set the size of the window, its title, and we make sure it closes when the user clicks the “X” button.
Step 2: Making Input Fields
We ask the user to type in an amount. So we add a text field for that. It’s like a box where you can type a number (like 250 or 1000).
We also add labels so the user knows what to do. For example, “Enter amount:” is shown above the box.
Step 3: Adding Currency Options
We give the user two dropdown menus — one to select the currency they are converting from, and one for the currency they are converting to.
The currencies in this app are:
- USD (US Dollar)
- INR (Indian Rupee)
- EUR (Euro)
- GBP (British Pound)
So for example, the user might want to convert from EUR to INR, or from GBP to USD.
Step 4: Adding a Convert Button
This is the main logic part or step behind our currency converter app in Java.
We add a button labeled “Convert”. When the user clicks this button, the app should take the amount they entered, look at the selected currencies, and then do the conversion as per the given instructions.
Step 5: Showing the Result
Once the user clicks the button, we want to show the converted value on the screen. So we add a label at the bottom that will display the result like:
Result: 1050.0 EUR
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class CurrencyConverter extends JFrame implements ActionListener {
private JComboBox<String> fromCurrency, toCurrency;
private JTextField amountField;
private JLabel resultLabel;
// Example static exchange rates (1 unit of FROM = X units of TO)
private final double USD_TO_INR = 83.0;
private final double EUR_TO_INR = 90.0;
private final double GBP_TO_INR = 105.0;
public CurrencyConverter() {
setTitle("Currency Converter");
setSize(400, 250);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLocationRelativeTo(null);
setLayout(new GridLayout(6, 1, 10, 10));
String[] currencies = { "USD", "INR", "EUR", "GBP" };
add(new JLabel("Enter amount:"));
amountField = new JTextField();
add(amountField);
fromCurrency = new JComboBox<>(currencies);
toCurrency = new JComboBox<>(currencies);
add(new JLabel("From:"));
add(fromCurrency);
add(new JLabel("To:"));
add(toCurrency);
JButton convertBtn = new JButton("Convert");
convertBtn.addActionListener(this);
add(convertBtn);
resultLabel = new JLabel("Result: ", JLabel.CENTER);
resultLabel.setFont(new Font("Arial", Font.BOLD, 16));
add(resultLabel);
setVisible(true);
}
@Override
public void actionPerformed(ActionEvent e) {
try {
double amount = Double.parseDouble(amountField.getText());
String from = fromCurrency.getSelectedItem().toString();
String to = toCurrency.getSelectedItem().toString();
double converted = convertCurrency(from, to, amount);
resultLabel.setText("Result: " + converted + " " + to);
} catch (Exception ex) {
resultLabel.setText("Enter valid amount");
}
}
private double convertCurrency(String from, String to, double amount) {
// Convert FROM to INR
double inr;
switch (from) {
case "USD": inr = amount * USD_TO_INR; break;
case "EUR": inr = amount * EUR_TO_INR; break;
case "GBP": inr = amount * GBP_TO_INR; break;
case "INR": inr = amount; break;
default: return 0;
}
// Convert INR to TO
switch (to) {
case "USD": return inr / USD_TO_INR;
case "EUR": return inr / EUR_TO_INR;
case "GBP": return inr / GBP_TO_INR;
case "INR": return inr;
default: return 0;
}
}
public static void main(String[] args) {
new CurrencyConverter();
}
}
Why This Method Works
This two-step method (convert to INR, then convert to target) is easy and smart. It avoids writing separate formulas for every possible combination like USD → GBP, EUR → INR, and so on.
By using INR as a middle currency, we reduce the total logic needed. This is very helpful when working with many currencies.
Also, using fixed conversion rates makes it simple for practice. In real-world apps, we’d use live exchange rates from the internet.
What If the User Types Something Wrong?
The app is also smart enough to handle errors. If someone types “hello” or leaves the input blank, the app doesn’t crash. It shows a message like:
Enter valid amount
This is done using something called a try-catch block, which checks for mistakes and prevents the app from breaking.
Final Words
Making a currency converter in Java is a fun and useful way to learn Java GUI programming. You work with input, output, logic, and buttons, all in one small app.
It helps you become more confident with Java, and it’s super satisfying to see something you made actually work.
GitHub Link Code: Link