1 
/**
 *
 * 
 * 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()

}

/*
 * 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 类。我也不确定如何使用计时器类，我希望每一秒代表一周。任何帮助将非常感激。

4

1 回答 1

0

这是一个简单的例子。

你有一个Balance持有AtomicInteger当前余额的类。

你有三种可运行文件Income，Expenditure和Statement- 这些是不言自明的。

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

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

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

此实现没有错误处理 - 任务将静默失败；但考虑到它们的简单性，不应该有任何理由让任务公平。

如果您想引入非整数值，您可能需要使用 a 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);

}
于 2013-04-25T23:51:38.650 回答