Okay, let's build the foundation for a JavaFX-based banking system. This will include user login, viewing accounts, and basic transaction capabilities (deposit/withdraw). We'll structure the project with separate packages for the application, controllers, model, and services. package com.bank.model; public enum AccountType { CHECKING, SAVINGS } package com.bank.model; import java.util.UUID; import java.math.BigDecimal; public class Account { private final String accountId; private final String userId; private final AccountType accountType; private BigDecimal balance; public Account(String userId, AccountType accountType, BigDecimal initialBalance) { this.accountId = UUID.randomUUID().toString(); this.userId = userId; this.accountType = accountType; this.balance = initialBalance; } // Constructor for loading existing accounts (if needed later) public Account(String accountId, String userId, AccountType accountType, BigDecimal balance) { this.accountId = accountId; this.userId = userId; this.accountType = accountType; this.balance = balance; } public String getAccountId() { return accountId; } public String getUserId() { return userId; } public AccountType getAccountType() { return accountType; } public BigDecimal getBalance() { return balance; } public void deposit(BigDecimal amount) { if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) { throw new IllegalArgumentException("Deposit amount must be positive."); } this.balance = this.balance.add(amount); } public void withdraw(BigDecimal amount) { if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) { throw new IllegalArgumentException("Withdrawal amount must be positive."); } if (this.balance.compareTo(amount) < 0) { throw new IllegalArgumentException("Insufficient funds."); } this.balance = this.balance.subtract(amount); } @Override public String toString() { return String.format("%s Account [%s] - Balance: $%.2f", accountType, accountId.substring(0, 8) + "...", // Shortened ID for display balance); } } package com.bank.model; import java.util.UUID; public class User { private final String userId; private final String username; private final String password; // In a real app, hash this! public User(String username, String password) { this.userId = UUID.randomUUID().toString(); this.username = username; this.password = password; // Store hashed password } // Constructor for loading existing users public User(String userId, String username, String password) { this.userId = userId; this.username = username; this.password = password; } public String getUserId() { return userId; } public String getUsername() { return username; } // Used for authentication check public boolean checkPassword(String passwordAttempt) { // In a real app, compare hash(passwordAttempt) with stored hash return this.password.equals(passwordAttempt); } } package com.bank.service; import com.bank.model.Account; import com.bank.model.AccountType; import com.bank.model.User; import java.math.BigDecimal; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Optional; import java.util.stream.Collectors; // Simple in-memory data store public class DataStore { private final Map usersByUsername = new HashMap<>(); private final Map usersById = new HashMap<>(); private final Map accountsById = new HashMap<>(); private final Map> accountsByUserId = new HashMap<>(); public DataStore() { // Add some sample data User user1 = new User("john.doe", "password123"); User user2 = new User("jane.smith", "test"); addUser(user1); addUser(user2); Account acc1 = new Account(user1.getUserId(), AccountType.CHECKING, new BigDecimal("1500.75")); Account acc2 = new Account(user1.getUserId(), AccountType.SAVINGS, new BigDecimal("5200.00")); Account acc3 = new Account(user2.getUserId(), AccountType.CHECKING, new BigDecimal("850.20")); addAccount(acc1); addAccount(acc2); addAccount(acc3); } public void addUser(User user) { usersByUsername.put(user.getUsername(), user); usersById.put(user.getUserId(), user); accountsByUserId.putIfAbsent(user.getUserId(), new ArrayList<>()); } public Optional findUserByUsername(String username) { return Optional.ofNullable(usersByUsername.get(username)); } public Optional findUserById(String userId) { return Optional.ofNullable(usersById.get(userId)); } public void addAccount(Account account) { accountsById.put(account.getAccountId(), account); accountsByUserId.computeIfAbsent(account.getUserId(), k -> new ArrayList<>()).add(account); } public Optional findAccountById(String accountId) { return Optional.ofNullable(accountsById.get(accountId)); } public List findAccountsByUserId(String userId) { return accountsByUserId.getOrDefault(userId, List.of()); // Return immutable empty list if none } } package com.bank.service; import com.bank.model.Account; import com.bank.model.User; import java.math.BigDecimal; import java.util.List; import java.util.Optional; public class BankService { private final DataStore dataStore; public BankService(DataStore dataStore) { this.dataStore = dataStore; } public Optional authenticateUser(String username, String password) { Optional userOpt = dataStore.findUserByUsername(username); if (userOpt.isPresent() && userOpt.get().checkPassword(password)) { return userOpt; } return Optional.empty(); } public List getAccountsForUser(String userId) { return dataStore.findAccountsByUserId(userId); } public Optional getAccountById(String accountId) { return dataStore.findAccountById(accountId); } public boolean deposit(String accountId, BigDecimal amount) { Optional accountOpt = dataStore.findAccountById(accountId); if (accountOpt.isPresent()) { try { accountOpt.get().deposit(amount); // In a real app, persist change and log transaction return true; } catch (IllegalArgumentException e) { System.err.println("Deposit failed: " + e.getMessage()); return false; } } return false; } public boolean withdraw(String accountId, BigDecimal amount) { Optional accountOpt = dataStore.findAccountById(accountId); if (accountOpt.isPresent()) { try { accountOpt.get().withdraw(amount); // In a real app, persist change and log transaction return true; } catch (IllegalArgumentException e) { System.err.println("Withdrawal failed: " + e.getMessage()); return false; } } return false; } // Add transfer method later if needed } package com.bank.controllers; import com.bank.app.BankApp; import com.bank.model.User; import com.bank.service.BankService; import javafx.fxml.FXML; import javafx.scene.control.Label; import javafx.scene.control.PasswordField; import javafx.scene.control.TextField; import javafx.scene.paint.Color; import java.util.Optional; public class LoginController { @FXML private TextField usernameField; @FXML private PasswordField passwordField; @FXML private Label messageLabel; private BankService bankService; private BankApp bankApp; public void setBankService(BankService bankService) { this.bankService = bankService; } public void setBankApp(BankApp bankApp) { this.bankApp = bankApp; } @FXML private void handleLoginButtonAction() { String username = usernameField.getText(); String password = passwordField.getText(); if (username.isEmpty() || password.isEmpty()) { setMessage("Username and password cannot be empty.", Color.RED); return; } Optional authenticatedUser = bankService.authenticateUser(username, password); if (authenticatedUser.isPresent()) { setMessage("Login Successful!", Color.GREEN); // Navigate to the dashboard bankApp.showDashboard(authenticatedUser.get()); } else { setMessage("Invalid username or password.", Color.RED); passwordField.clear(); } } private void setMessage(String message, Color color) { messageLabel.setText(message); messageLabel.setTextFill(color); messageLabel.setVisible(true); } public void clearFields() { usernameField.clear(); passwordField.clear(); messageLabel.setVisible(false); } } package com.bank.controllers; import com.bank.app.BankApp; import com.bank.model.Account; import com.bank.model.User; import com.bank.service.BankService; import javafx.collections.FXCollections; import javafx.fxml.FXML; import javafx.scene.control.*; import javafx.scene.control.Alert.AlertType; import java.math.BigDecimal; import java.text.NumberFormat; import java.util.List; import java.util.Optional; public class DashboardController { @FXML private Label welcomeLabel; @FXML private ListView accountsListView; @FXML private TextField amountField; @FXML private Label selectedAccountLabel; // To show which account is selected private BankService bankService; private BankApp bankApp; private User currentUser; public void setBankService(BankService bankService) { this.bankService = bankService; } public void setBankApp(BankApp bankApp) { this.bankApp = bankApp; } public void setCurrentUser(User user) { this.currentUser = user; welcomeLabel.setText("Welcome, " + user.getUsername() + "!"); loadUserAccounts(); } @FXML private void initialize() { // Add listener to update selectedAccountLabel when selection changes accountsListView.getSelectionModel().selectedItemProperty().addListener( (observable, oldValue, newValue) -> { if (newValue != null) { selectedAccountLabel.setText(String.format("Selected: %s (%s)", newValue.getAccountType(), newValue.getAccountId().substring(0, 8))); } else { selectedAccountLabel.setText("No account selected"); } }); // Format amount field for currency? Maybe later. } private void loadUserAccounts() { if (currentUser != null) { List accounts = bankService.getAccountsForUser(currentUser.getUserId()); accountsListView.setItems(FXCollections.observableArrayList(accounts)); // Select the first account by default if available if (!accounts.isEmpty()) { accountsListView.getSelectionModel().selectFirst(); } else { selectedAccountLabel.setText("No accounts found."); } } } private Optional getSelectedAccount() { Account selected = accountsListView.getSelectionModel().getSelectedItem(); if (selected == null) { showAlert(AlertType.WARNING, "Selection Error", "Please select an account first."); return Optional.empty(); } // Re-fetch account from service to ensure latest balance (important in concurrent scenarios) // For this simple version, returning the list view's item is okay, but fetching is better practice. // return bankService.getAccountById(selected.getAccountId()); return Optional.of(selected); } private Optional getAmountFromField() { String amountText = amountField.getText(); if (amountText.isBlank()) { showAlert(AlertType.WARNING, "Input Error", "Please enter an amount."); return Optional.empty(); } try { BigDecimal amount = new BigDecimal(amountText); if (amount.compareTo(BigDecimal.ZERO) <= 0) { showAlert(AlertType.WARNING, "Input Error", "Amount must be positive."); return Optional.empty(); } return Optional.of(amount); } catch (NumberFormatException e) { showAlert(AlertType.WARNING, "Input Error", "Invalid amount format."); return Optional.empty(); } } @FXML private void handleDepositButtonAction() { Optional selectedAccountOpt = getSelectedAccount(); Optional amountOpt = getAmountFromField(); if (selectedAccountOpt.isPresent() && amountOpt.isPresent()) { Account account = selectedAccountOpt.get(); BigDecimal amount = amountOpt.get(); boolean success = bankService.deposit(account.getAccountId(), amount); if (success) { showAlert(AlertType.INFORMATION, "Success", "Deposit successful."); refreshAccountList(); amountField.clear(); } else { showAlert(AlertType.ERROR, "Error", "Deposit failed. Please check logs or try again."); } } } @FXML private void handleWithdrawButtonAction() { Optional selectedAccountOpt = getSelectedAccount(); Optional amountOpt = getAmountFromField(); if (selectedAccountOpt.isPresent() && amountOpt.isPresent()) { Account account = selectedAccountOpt.get(); BigDecimal amount = amountOpt.get(); // Check balance before attempting withdrawal via service if (account.getBalance().compareTo(amount) < 0) { showAlert(AlertType.WARNING, "Withdrawal Error", "Insufficient funds."); return; } boolean success = bankService.withdraw(account.getAccountId(), amount); if (success) { showAlert(AlertType.INFORMATION, "Success", "Withdrawal successful."); refreshAccountList(); amountField.clear(); } else { // Service layer might have caught other errors (e.g., negative amount already handled) // Or potentially a race condition if balance changed. The service's check is the final one. showAlert(AlertType.ERROR, "Error", "Withdrawal failed. Insufficient funds or other issue."); } } } @FXML private void handleRefreshButtonAction() { refreshAccountList(); } @FXML private void handleLogoutButtonAction() { bankApp.showLoginScreen(); } private void refreshAccountList() { // Remember selected index int selectedIndex = accountsListView.getSelectionModel().getSelectedIndex(); // Reload data loadUserAccounts(); // This re-fetches from the service // Try to re-select the previously selected item if (selectedIndex >= 0 && selectedIndex < accountsListView.getItems().size()) { accountsListView.getSelectionModel().select(selectedIndex); } else if (!accountsListView.getItems().isEmpty()) { accountsListView.getSelectionModel().selectFirst(); // Select first if previous is gone } accountsListView.refresh(); // Force UI update } private void showAlert(AlertType alertType, String title, String message) { Alert alert = new Alert(alertType); alert.setTitle(title); alert.setHeaderText(null); alert.setContentText(message); alert.showAndWait(); } } package com.bank.app; import com.bank.controllers.DashboardController; import com.bank.controllers.LoginController; import com.bank.model.User; import com.bank.service.BankService; import com.bank.service.DataStore; import javafx.application.Application; import javafx.fxml.FXMLLoader; import javafx.scene.Parent; import javafx.scene.Scene; import javafx.stage.Stage; import java.io.IOException; import java.net.URL; public class BankApp extends Application { private Stage primaryStage; private BankService bankService; private Scene loginScene; private Scene dashboardScene; private LoginController loginController; private DashboardController dashboardController; @Override public void init() throws Exception { // Initialize services and data store DataStore dataStore = new DataStore(); // In a real app, load from persistence bankService = new BankService(dataStore); // Load FXML and controllers ONCE loginScene = loadScene("/com/bank/views/login.fxml"); dashboardScene = loadScene("/com/bank/views/dashboard.fxml"); // Get controllers after loading loginController = (LoginController) loginScene.getUserData(); dashboardController = (DashboardController) dashboardScene.getUserData(); // Inject dependencies loginController.setBankService(bankService); loginController.setBankApp(this); dashboardController.setBankService(bankService); dashboardController.setBankApp(this); } private Scene loadScene(String fxmlPath) throws IOException { URL fxmlUrl = getClass().getResource(fxmlPath); if (fxmlUrl == null) { throw new IOException("Cannot load FXML file: " + fxmlPath); } FXMLLoader loader = new FXMLLoader(fxmlUrl); Parent root = loader.load(); Scene scene = new Scene(root); scene.setUserData(loader.getController()); // Store controller in scene's user data return scene; } @Override public void start(Stage primaryStage) { this.primaryStage = primaryStage; primaryStage.setTitle("Simple Bank App"); showLoginScreen(); // Start with the login screen primaryStage.show(); } public void showLoginScreen() { if (loginController != null) { loginController.clearFields(); // Clear fields before showing } primaryStage.setScene(loginScene); primaryStage.setTitle("Bank Login"); } public void showDashboard(User user) { dashboardController.setCurrentUser(user); // Set the logged-in user primaryStage.setScene(dashboardScene); primaryStage.setTitle("Account Dashboard"); } public static void main(String[] args) { launch(args); } }