Projeto final JAVA 25

Ola amigo.
Muito legal seu código e sem medo de fazer alterações.
Continue a explorar todos os recursos de java.
Bons estudos.

Belo código, amigo! Uma dica para você nos próximos códigos: quando for trabalhar com algo que exija precisão — como no caso do seu código, que lida com valores monetários — é melhor representá-los usando BigDecimal em vez de double, pois double não tem o mesmo nível de precisão (assim como float).

Isso acontece porque ambos trabalham com base 2, e não com base 10. Isso é problemático, pois os bits não conseguem se ajustar bem para representar números decimais corretamente, gerando valores imprecisos.

Um teste simples é somar 0.1 com 0.2 — tanto faz se for double ou float — o resultado será 0.30000000000000004, e não 0.3. Isso ocorre porque a máquina trabalha com bits, que só comportam dois valores, e não se dão bem com números decimais.

E isso, em sistemas monetários, é muito ruim. Já imaginou se, ao sacar dinheiro no banco, você perdesse alguns centavos só porque alguém usou um double ou float?
Ia ser engraçado e triste ao mesmo tempo.

Aqui, fiz uma refatoracao simples no seu codigo. Contudo, o recomendado seria separar o codigo por responsabilidades, criar classes proprias para tratar da parte de Management do dinheiro uma para Clients e uma classe simples para Menus.

Resultado:

package test;

import com.github.rickmvi.jtoolbox.console.IO;
import com.github.rickmvi.jtoolbox.util.Try;
import org.jetbrains.annotations.NotNull;

import java.math.BigDecimal;
import java.text.NumberFormat;
import java.util.Scanner;

public class Refactor {
    public static void main(String[] args) {
        String nome = "Fellipe Filgueiras";
        String tipoConta =  "Corrente";
        BigDecimal saldo = new BigDecimal("2500");
        BigDecimal result = new BigDecimal("0");

        info(nome, tipoConta, saldo);

        Scanner scan = new Scanner(System.in);
        int opcao = 0;
        while (opcao != 4) {
            displayMenu();

            IO.print("Digite a opção desejada: ");
            opcao = Try.of(scan::nextInt).orThrow();

            result = manageAccount(opcao, result, saldo, scan);
        }
        scan.close();
    }

    private static BigDecimal manageAccount(
            int opcao,
            BigDecimal result,
            BigDecimal saldo,
            Scanner scan
    ) {
         switch (opcao) {
            case 1 -> IO.println("Saldo atual: " + getFormat(result));
            case 2 -> {
                getUserInput();
                result = saldo.add(scan.nextBigDecimal());
            }
            case 3 -> {
                getUserInput();
                BigDecimal valor = scan.nextBigDecimal();
                if(valor.doubleValue() < saldo.doubleValue()) {
                    result = saldo.subtract(valor);
                    return result;
                }
                IO.print("Saldo insuficiente");
            }
            case 4 -> IO.println("Até a próxima");
            default -> IO.println("Opção inválida");
        }
        return result;
    }

    private static void getUserInput() {
        IO.print("Digite o valor: ");
    }

    private static void info(String nome, String tipoConta, BigDecimal saldo) {
        IO.println("""
            \n**********************************************
            Dados iniciais do cliente:
            
            Nome: %s
            Tipo de conta: %s
            Saldo inicial: %s
            
            **********************************************
            """.formatted(nome, tipoConta, getFormat(saldo)));
    }

    private static void displayMenu() {
        IO.println("""
            \nOperações
            
            1 - Consultar saldos
            2 - Receber valor
            3 - Transferir valor
            4 - Sair
            
            """);
    }

    private static @NotNull String getFormat(BigDecimal result) {
        return NumberFormat.getCurrencyInstance().format(result);
    }
}

Espero tê-lo ajudado com isso.

Ola Rick...
Interessante observacao.
Outra alternativa para quem esta comecando é converter tudo para centavos e na hora de mostrar os resultados converter para casas decimais podendo criar uma funcao especifica para isso.
Valeu pela dica.
Bons estudos.

Sim, pode fazer isso também, mas, na minha concepção, acho bem mais prático e fácil usar diretamente algo que a linguagem nos oferece para solucionar esse tipo de problema de forma rápida e eficiente. Do contrário, ter de criar toda uma função, por mais simples que seja, para casos tão específicos como esse, não me apetece muito kkkk.

Sem nada para fazer, entao refiz o codigo dele, so que em Go. Tentei separar melhor as responsabilidades, o codigo nao esta muito bom, isso porque estou vendo Golang a pouco, entao e algo novo e sintaxe nova tambem. O resultado foi este:

Customer file

package entity

import (
    "go-init/manager"
)

type Customer struct {
    Name    string
    Balance float64
    manager.Account
}

Account file

package manager

type Account struct {
    Type string
}

Menu file

package menu

import "fmt"

func Info(name, account string, balance float64) {
    fmt.Printf(`
**********************************************
Dados iniciais do cliente:

Nome: %s
Tipo de conta: %s
Saldo inicial: %.2f

**********************************************
`, name, account, balance)
}

func Menu() {
    fmt.Println(
        `Operações
            
            1 - Consultar saldos
            2 - Receber valor
            3 - Transferir valor
            4 - Sair
        `)
}

Account Manager file

package manager

import (
    "fmt"
)

type AccountManager struct {
}

func ProcessTransaction(value int8, balance *float64) (result float64) {

    switch value {
    case 1:
        fmt.Printf("Saldo atual: %.2f\n", *balance)
        break
    case 2:
        {
            var deposit float64

            fmt.Println("Digite o valor a ser depositado: ")
            _, err := fmt.Scanf("%f", &deposit)

            if err != nil {
                fmt.Println("Error: ", err.Error())
                return
            }

            result = deposit + *balance
            break
        }
    case 3:
        {
            fmt.Println("Digite o valor a ser sacado: ")
            var sacar float64
            _, err := fmt.Scanf("%f", &sacar)

            if err != nil {
                fmt.Println("Error: ", err.Error())
                return
            }

            if *balance < sacar {
                fmt.Println("Saldo insuficiente")
                return
            }

            result = *balance - sacar
            break
        }
    case 4:
        fmt.Println("Saindo...")
        break
    default:
        fmt.Println("Opcao invalida")
    }

    return
}

Main file

package main

import (
    "fmt"
    "go-init/entity"
    "go-init/manager"
    "go-init/menu"
)

func main() {
    customer := &entity.Customer{
        Name:    "Fellipe Filgueiras",
        Balance: 1000,
        Account: manager.Account{
            Type: "Conta Corrente",
        },
    }

    menu.Info(customer.Name, customer.Account.Type, customer.Balance)

    display(0, customer)

}

func display(value int8, customer *entity.Customer) {
    for value != 4 {
        menu.Menu()

        fmt.Println("Digite a opção desejada: ")
        _, err := fmt.Scanf("%d", &value)

        if err != nil {
            fmt.Println("Error: ", err.Error())
            return
        }

        customer.Balance = manager.ProcessTransaction(value, &customer.Balance)
    }
}

Como ficou no Terminal:

Excelente trabalho amigo.
Ficou otimo.
Parabéns.

Ótimas dicas pessoal, obrigado, eu pensei até em utilizar o BigDecimal e método para formatar o valor monetário, mas como não fazia parte do curso, decidi não usar justamente para não confundir o pessoal que está começando, mas obrigado pelas ótimas dicas!