Deploy MATLAB Class that Inherits from MATLAB Handle Class

import com.mathworks.runtime.*;
import com.mathworks.matlab.types.*;

/**
 * Java wrapper for the packaged MATLAB BankAccount class.
 * This class provides a Java interface to interact with the MATLAB BankAccount object.
 */
public class BankAccount implements AutoCloseable {
    /**
     * Reference to MATLAB runtime environment.
     * This is needed to execute MATLAB functions and methods.
     */
    private final MatlabRuntime runtime;

    /**
     * Reference to the MATLAB BankAccount object.
     * HandleObject is a special interface that represents a MATLAB handle class instance.
     * It allows us to call methods on the MATLAB object from Java.
     */
    private final HandleObject accountObject;

    /**
     * Constructor to initialize the account with a balance
     *
     * @param runtime MATLAB Runtime environment
     * @param initialBalance The initial balance for the account
     * @throws Exception If there's an error creating the MATLAB object
     */
    public BankAccount(MatlabRuntime runtime, double initialBalance) throws Exception {
    		this.runtime = runtime;

		try {
            // Create a new MATLAB BankAccount object by calling the MATLAB constructor
            // The feval method executes a MATLAB class and returns the result
            this.accountObject = runtime.feval("BankAccount", initialBalance);

            if (this.accountObject == null) {
                throw new Exception("Failed to create MATLAB BankAccount object");
            }
        } catch (Exception e) {
            throw new Exception("Error creating BankAccount: " + e.getMessage(), e);
        }
    }

    /**
     * Method to deposit money into the account
     *
     * @param amount The amount to deposit
     * @throws Exception If there's an error with the deposit
     */
    public void deposit(double amount) throws Exception {
        try {
            // Call the deposit method on the MATLAB object
            // The first parameter (0) indicates we don't expect a return value
            runtime.feval(0, "deposit", this.accountObject, amount);
        } catch (Exception e) {
            throw new Exception("Error depositing funds: " + e.getMessage(), e);
        }
    }

    /**
     * Method to withdraw money from the account
     *
     * @param amount The amount to withdraw
     * @throws Exception If there's an error with the withdrawal
     */
    public void withdraw(double amount) throws Exception {
        try {
            // Call the withdraw method on the MATLAB object
            runtime.feval(0, "withdraw", this.accountObject, amount);
        } catch (Exception e) {
            throw new Exception("Error withdrawing funds: " + e.getMessage(), e);
        }
    }

    /**
     * Method to check the balance of the account
     *
     * @return The current balance
     * @throws Exception If there's an error checking the balance
     */
    public double checkBalance() throws Exception {
        try {
            // Call the checkBalance method on the MATLAB object
            // The first parameter (1) indicates we expect a single return value
            // The <Double> specifies the expected return type
            return runtime.<Double>feval(1, "checkBalance", this.accountObject);
        } catch (Exception e) {
            throw new Exception("Error checking balance: " + e.getMessage(), e);
        }
    }

    /**
     * Closes resources associated with this BankAccount.
     * In this implementation, we don't need to do anything specific as MATLAB Runtime
     * will be closed separately, and the MATLAB object will be garbage collected.
     */
    @Override
    public void close() {
        // No specific cleanup needed for individual accounts
        // MATLAB runtime will be closed by the main application
    }
}

import com.mathworks.runtime.*;

/**
 * Example application demonstrating the use of the BankAccount class
 * with the MATLAB Runtime.
 */
public class BankAccountExample {
    public static void main(String[] args) {
        
    		System.out.println("Starting BankAccountExample ...");
    		
    		// Path to the packaged MATLAB CTF file
        String ctfPath = "Banking.ctf";
        
        // Use try-with-resources to ensure proper cleanup of MATLAB Runtime
        try (MatlabRuntime runtime = MatlabRuntime.startMatlab(ctfPath)) {
            System.out.println("MATLAB Runtime started successfully");

            // Execute the banking operations
            performBankingOperations(runtime);
            
            // Terminate MATLAB Runtime client infrastructure.
            MatlabRuntime.terminateMatlabClient();
            
        } catch (Exception e) {
            System.err.println("An error occurred with MATLAB Runtime: " + e.getMessage());
            e.printStackTrace();
        } 
    }

    /**
     * Performs a series of banking operations to demonstrate the BankAccount class
     *
     * @param runtime MATLAB runtime environment
     */
    private static void performBankingOperations(MatlabRuntime runtime) {
        try {
            // Create a new bank account with an initial balance of 100
            System.out.println("Creating bank account...");
            try (BankAccount account = new BankAccount(runtime, 100)) {
                System.out.println("Bank account created successfully");

                // Deposit 50 into the account
                System.out.println("Depositing 50...");
                account.deposit(50);
                displayBalance(account, "Balance after deposit: ");

                // Withdraw 30 from the account
                System.out.println("Withdrawing 30...");
                account.withdraw(30);
                displayBalance(account, "Balance after withdrawal: ");

                // Create a joint account that references the same existing account
                // Note: This doesn't create a new MATLAB object, just a new Java reference
                System.out.println("Creating joint account reference...");
                BankAccount jointAccount = account;

                // Deposit 20 using the shared reference
                System.out.println("Depositing 20 using joint account...");
                jointAccount.deposit(20);
                displayBalance(jointAccount, "Balance from joint account: ");
                displayBalance(account, "Balance from original account: ");
            }
        } catch (Exception e) {
            System.err.println("Error in bank operations: " + e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * Helper method to display the account balance with a message
     *
     * @param account The bank account
     * @param message The message to display before the balance
     */
    private static void displayBalance(BankAccount account, String message) {
        try {
            double balance = account.checkBalance();
            System.out.println(message + balance);
        } catch (Exception e) {
            System.err.println("Error checking balance: " + e.getMessage());
            e.printStackTrace();
        }
    }
}