java 类和对象的小练习,银行存取钱数。

public class Account 
{
    String zhanghu;
    double cunkuanyue;
    //先初始化
    Account(String zhanghu,double cunkuanyue)
    {
        this.zhanghu=zhanghu;
        this.cunkuanyue=cunkuanyue;
    }
    //存款
    double cunkuan(double qianshu)
    {
        if(qianshu<0)
        {
            System.out.println("钱数错误");
            
        }
        else
        {
        
        System.out.println("您存了"+qianshu);
        this.cunkuanyue+=qianshu;
        
        }
        return this.cunkuanyue;
    }
    
    /*
    void cunkuan(double qianshu)
    {
        //验证
        if(qianshu<0)
        {
            System.out.println("钱数错误");
            return;
        }
        System.out.println("我存了"+qianshu);
        this.cunkuanyue+=qianshu;
    }
    
    */
    
    
    //取款
    
    void qukuan(double qianshu)
    {
        if(qianshu>this.cunkuanyue)
        {
            System.out.println("余额不足");
            return;
        }
        System.out.println("我取了"+qianshu);
        this.cunkuanyue-=qianshu;
    }
    
    
    
    
    //查询余额
    double getyue()
    {
        return this.cunkuanyue;
    }
    

    
    public static void main(String[] args)
    { 
        Account a=new Account("123456",1000);
        a.cunkuan(100);
        System.out.println("查询余额="+a.getyue());
        a.qukuan(200);
        System.out.println("查询余额= "+a.getyue());

    }

}

转载于:https://www.cnblogs.com/zhailiming/p/5505130.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 好的,我可以为您讲解一下Java多线程下的银行存取钱的问题。 在银行存取钱的场景中,存在多个用户同时读取或修改同一个账户的情况。为了保证账户的正确性,需要使用多线程技术来解决这个问题。 下面是一个简单的Java多线程银行存取钱的示例: ```java public class BankAccount { private int balance; // 账户余额 public BankAccount(int balance) { this.balance = balance; } // 存钱 public synchronized void deposit(int amount) { balance += amount; System.out.println("存入:" + amount + ",余额为:" + balance); } // 取钱 public synchronized void withdraw(int amount) { if (balance >= amount) { balance -= amount; System.out.println("取出:" + amount + ",余额为:" + balance); } else { System.out.println("余额不足!"); } } } public class BankDemo { public static void main(String[] args) { BankAccount account = new BankAccount(1000); // 创建两个线程,一个存钱,一个取钱 Thread depositThread = new Thread(() -> { for (int i = 0; i < 5; i++) { account.deposit(100); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); Thread withdrawThread = new Thread(() -> { for (int i = 0; i < 5; i++) { account.withdraw(200); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }); // 启动线程 depositThread.start(); withdrawThread.start(); } } ``` 在上面的示例中,BankAccount类表示银行账户,包含了存钱和取钱的方法。这两个方法都使用了synchronized关键字来保证并发访问时的同步性。 在BankDemo类中,创建了两个线程来模拟存钱和取钱的过程。启动这两个线程之后,它们会同时对同一个账户进行操作,但是由于使用了synchronized关键字,所以不会出现数据不一致的情况。 当然,这只是一个简单的示例,实际应用中还需要考虑更多的情况,比如死锁、线程安全性等问题。 ### 回答2: Java 多线程可以用于实现银行存取钱系统。在这个系统中,我们可以创建一个银行类(Bank),该类包含一个用于存储账户余额的变量(balance),以及提供存款(deposit)和取款(withdraw)方法。 在多线程环境下,每个用户(User)可以是一个线程。用户可以通过调用Bank类的存款和取款方法来存取钱。为了保证多个用户同时访问银行对象时的线程安全性,可以使用synchronized关键字对存款和取款方法进行同步。 下面是一个简单的示例代码: ```java public class Bank { private int balance; public Bank(int initialBalance) { this.balance = initialBalance; } public synchronized void deposit(int amount) { balance += amount; } public synchronized void withdraw(int amount) { if (balance >= amount) { balance -= amount; } else { System.out.println("余额不足"); } } public int getBalance() { return balance; } } public class User implements Runnable { private Bank bank; private String name; private boolean isDeposit; // 标记是否存款 public User(Bank bank, String name, boolean isDeposit) { this.bank = bank; this.name = name; this.isDeposit = isDeposit; } @Override public void run() { if (isDeposit) { bank.deposit(100); // 存款 System.out.println(name + " 存款后余额为:" + bank.getBalance()); } else { bank.withdraw(50); // 取款 System.out.println(name + " 取款后余额为:" + bank.getBalance()); } } } public class Main { public static void main(String[] args) { Bank bank = new Bank(0); User user1 = new User(bank, "用户1", true); User user2 = new User(bank, "用户2", false); Thread thread1 = new Thread(user1); Thread thread2 = new Thread(user2); thread1.start(); thread2.start(); } } ``` 在上述示例中,我们创建了一个银行对象bank,并使用两个用户(user1和user2)作为线程,一个存款,一个取款。通过Thread类的start方法,我们启动了这两个用户的线程,他们可以并发地操作银行对象。 当程序运行时,可能会出现以下结果的任何一种: ``` 用户1 存款后余额为:100 用户2 取款后余额为:50 ``` 或者 ``` 用户2 取款后余额为:0 用户1 存款后余额为:100 ``` 这是由于线程的执行顺序是不确定的,因此每次运行的结果可能会有所不同。 ### 回答3: Java多线程银行存取钱的实现可以通过以下方式: 1. 创建一个银行账户类BankAccount,包含账户余额属性和相关的操作方法,例如存款deposit()和取款withdraw()。 2. 创建一个银行类Bank,该类维护一个存储银行账户对象的列表,并提供操作方法,例如创建账户createAccount()和获取账户getAccount()等。 3. 创建一个多线程类ThreadBank,该类继承Thread类,重写run()方法,实现多个线程同时执行存取款操作。 4. 在run()方法中,使用synchronized关键字对BankAccount的存取款方法进行同步,以保证线程安全,并使用随机数生成器生成随机的存取款金额。 5. 在主函数中,创建Bank对象和一定数量的账户,然后创建一定数量的ThreadBank线程对象,并启动线程。 6. 主线程等待所有的线程执行完毕后,输出每个账户的最终余额信息。 具体的步骤如下: ```java // 银行账户类 class BankAccount { private double balance; public BankAccount(double balance) { this.balance = balance; } public double getBalance() { return balance; } public synchronized void deposit(double amount) { balance += amount; } public synchronized void withdraw(double amount) { if (balance >= amount) { balance -= amount; } else { System.out.println("余额不足"); } } } // 银行类 class Bank { private List<BankAccount> accounts; public Bank() { accounts = new ArrayList<>(); } public BankAccount createAccount(double balance) { BankAccount account = new BankAccount(balance); accounts.add(account); return account; } public List<BankAccount> getAccounts() { return accounts; } } // 多线程类 class ThreadBank extends Thread { private Bank bank; public ThreadBank(Bank bank) { this.bank = bank; } @Override public void run() { Random random = new Random(); List<BankAccount> accounts = bank.getAccounts(); for (int i = 0; i < 100; i++) { int accountIndex = random.nextInt(accounts.size()); BankAccount account = accounts.get(accountIndex); double amount = random.nextDouble() * 100; // 生成0-100之间的随机存取款金额 if (random.nextBoolean()) { account.deposit(amount); } else { account.withdraw(amount); } } } } public class Main { public static void main(String[] args) { Bank bank = new Bank(); BankAccount account1 = bank.createAccount(1000); BankAccount account2 = bank.createAccount(2000); List<ThreadBank> threads = new ArrayList<>(); for (int i = 0; i < 10; i++) { threads.add(new ThreadBank(bank)); } for (ThreadBank thread : threads) { thread.start(); } for (ThreadBank thread : threads) { try { thread.join(); } catch (InterruptedException e) { e.printStackTrace(); } } // 输出最终余额 System.out.println("账户1余额:" + account1.getBalance()); System.out.println("账户2余额:" + account2.getBalance()); } } ``` 通过运行上述代码,就可以模拟多个线程同时对银行账户进行存取款操作,并确保线程安全。最终输出每个账户的最终余额信息。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值