我创建它模拟一个人的消费模式

Question

/** 
* 
* 
* A small class to handle deposits and withdrawls from a bank account 
* 
*/ 
package spendingsimulation; 

//import java.util.Random; 

public class BankAccount 
{ 
    public int accountBalance; 
    public int incomeAmt; 
    public BankAccount() 
    { 
     accountBalance = 0 ; 
     //incomeAmt = 0; 
    } 

    public void deposit(int addAmount, String name) 
    { 
     // the 'name' argument holds the name of the source of this credit 

     accountBalance+=addAmount ; 
     System.out.println(name + " added " + addAmount) ; 
     System.out.println("Account balance is now standing at " + accountBalance); 
    } 

    public void withdraw(int takeAmount, String name) 
    { 
     // the 'name' argument holds the name of the bill being paid 

     accountBalance-=takeAmount ; 
     System.out.println(name + " took " + takeAmount) ; 
     System.out.println("Account balance is now standing at " + accountBalance); 
    } 

    public int getBalance() 
    { 
     return accountBalance ; 
    } 

    //@Override 
    /*public void run() 
    { 
     try 
     { 
      deposit(incomeAmt, incomeS1); 
      getBalance(); 
      Thread.sleep(100) ; 
     } // End of try block 
     catch(InterruptedException ex) 
     { 
      System.out.println(typeOfUtility + " Terminated early") ; 
     } // End of Catch clause 

     System.out.println(typeOfUtility + " has finished") ; 
    } // End of method run() 
    */ 


} // End of class BankAccount 

---

package spendingsimulation; 

import java.lang.Thread ; 

public class SpendMain { 

    /** 
    * @param args the command line arguments 
    */ 
    public static void main(String[] args) { 
     // TODO code application logic here 
     System.out.println("Viewing expenditure"); 

     // Incoming payments 
     Thread incomeS1 = new Thread(new Incomming("Wage Recieved", 2000, 1000)); 
     Thread incomeS2 = new Thread(new Incomming("Interest Recieved", 10, 4000)); 

     // Outgoing costs 
     Thread outgoingS1 = new Thread(new Consumables("Oil Bill", 250, 3000)) ; 
     Thread outgoingS2 = new Thread(new Consumables("Food Bill", 600, 1000)) ; 
     Thread outgoingS3 = new Thread(new Consumables("Electricity Bill", 50, 1000)) ; 
     Thread outgoingS4 = new Thread(new Consumables("Entertrainment Bill", 400, 1000)) ; 
     Thread outgoingS5 = new Thread(new Consumables("Shopping Bill", 200, 1000)) ; 

     System.out.println("Expenditure commencing") ; 


     // Get the threads going 
     //Incomming 
     incomeS1.start(); 
     incomeS2.start(); 

     // Outgoing 
     outgoingS1.start(); 
     outgoingS2.start(); 
     outgoingS3.start(); 
     outgoingS4.start(); 
     outgoingS5.start(); 


     System.out.println("Expenditure is now underway.") ; 


    } 
} 

---

/* 
* To change this template, choose Tools | Templates 
* and open the template in the editor. 
*/ 
package spendingsimulation; 

import java.util.Random; 

/** 
* 
* @author B00533474 
*/ 
public class Incomming implements Runnable { 

    //private int workingTime ; 
    private String typeOfUtility ; 
    // private Random randGen ; 
    //private int incomingAmt; 

    public Incomming(String name, int addAmount, int time){ 
     typeOfUtility = name ; 

     // randGen = new Random(); 
     //workingTime = randGen.nextInt(10000) ; // Up to 10 seconds 

     // outgoingAmt = amt; 
    } 

    //@Override 
    public void run() 
    { 
     try 
     { 
      System.out.println(typeOfUtility + " has come into the account"); 
      System.out.println(" The balance on the account is now: "); 
      //this.getBalance(); 
      Thread.sleep(1000) ; 
     } // End of try block 
     catch(InterruptedException ex) 
     { 
      System.out.println(typeOfUtility + " Terminated early") ; 
     } // End of Catch clause 

     System.out.println(typeOfUtility + " has finished") ; 
    } // End of method run() 

} 

---

多线程Java应用程序

/* 
* To change this template, choose Tools | Templates 
* and open the template in the editor. 
*/ 
package spendingsimulation; 

import java.util.Random; 
import java.util.Timer; 

/** 
* 
* @author B00533474 
*/ 
public class Consumables implements Runnable { 

    private int workingTime ; 
    private String typeOfUtility ; 
    private Random randGen ; 
    private int incomeAmt; 


    Consumables(String name, int amt, int time) { 
     typeOfUtility = name ; 
     randGen = new Random(); 
     workingTime = randGen.nextInt(10000) ; // Up to 10 seconds 
     incomeAmt = amt; 
    } 

    @Override 
    public void run() { 
     Timer myTimer = new Timer(); 

    } 

} 

我的问题是，我不知道有多少，或run（）方法应该在什么类以及如何正确访问和使用Bank Account类。我也不确定如何使用定时器课程，我希望每一秒都能代表一周。任何帮助将非常感激。

Answer 1

这是一个简单的例子。

您有一个Balance类，其中包含当前余额AtomicInteger。

你有三种runnables，Income,Expenditure和Statement - 这些都是不言自明的。

该方法的肉是main方法。这使用ScheduledExectorService来安排不同的收入事件以不同的费率发生。评论解释了什么是什么。

最后，我们有一项任务在一年后关闭了整件事 - 这可以很容易地更改或删除，在这种情况下，它将永远运行。

您有一些间隔期间重复任务和延迟后运行一次的任务（关机任务）的示例。

此实现没有错误处理 - 任务将无提示失败;但考虑到简单性，任务不应该公平。

如果您想要引入非整数值，您可能需要使用BigDecimal，这会更复杂，因为您需要手动输入synchronize。

static final class Balance { 

    private final AtomicInteger balance; 

    public Balance(int initalBalance) { 
     this.balance = new AtomicInteger(initalBalance); 
    } 

    public void debit(final int amount) { 
     balance.addAndGet(-amount); 
    } 

    public void credit(final int amount) { 
     balance.addAndGet(amount); 
    } 

    public int balance() { 
     return balance.get(); 
    } 

    @Override 
    public String toString() { 
     return "£" + balance.get(); 
    } 
} 

static final class Income implements Runnable { 

    private final Balance balance; 
    private final int income; 

    public Income(Balance balance, int income) { 
     this.balance = balance; 
     this.income = income; 
    } 

    @Override 
    public void run() { 
     balance.credit(income); 
    } 
} 

static final class Expenditure implements Runnable { 

    private final Balance balance; 
    private final int cost; 

    public Expenditure(Balance balance, int cost) { 
     this.balance = balance; 
     this.cost = cost; 
    } 

    @Override 
    public void run() { 
     balance.debit(cost); 
    } 
} 

static final class Statement implements Runnable { 

    private final Balance balance; 

    public Statement(Balance balance) { 
     this.balance = balance; 
    } 

    @Override 
    public void run() { 
     System.out.println("Your balance this month is " + balance.toString()); 
    } 
} 

public static void main(String[] args) throws ParseException { 
    final Balance balance = new Balance(1000); 
    final ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor(); 
    //print balance - monthly 
    executorService.scheduleAtFixedRate(new Statement(balance), 0, 4, TimeUnit.SECONDS); 
    //income - monthly 
    executorService.scheduleAtFixedRate(new Income(balance, 1000), 0, 4, TimeUnit.SECONDS); 
    //rent - monthly 
    executorService.scheduleAtFixedRate(new Expenditure(balance, 500), 4, 4, TimeUnit.SECONDS); 
    //food - weekly 
    executorService.scheduleAtFixedRate(new Expenditure(balance, 50), 1, 1, TimeUnit.SECONDS); 
    //shutdown after a year 
    executorService.schedule(new Runnable() { 
     @Override 
     public void run() { 
      executorService.shutdown(); 
     } 
    }, 52, TimeUnit.SECONDS); 

}