Question

Declare an interface Filter as follows:

public interface Filter {boolean accept (Object x); }

Modify the implementation of the DataSet class in Section 10.4 to use both a Measurer and a Filter object. Only objects that the filter accepts should be processed. Demonstrate your modification by processing a collection of bank accounts, filtering out all accounts with balances less than $1,000. Please use the code provided and fill in what is needed.

BankAccount.java

/**
   A bank account has a balance that can be changed by
   deposits and withdrawals.
*/
public class BankAccount
{
   private double balance;

   /**
Constructs a bank account with a zero balance.
   */
   public BankAccount()
   {
balance = 0;
   }

   /**
Constructs a bank account with a given balance.
@param initialBalance the initial balance
   */
   public BankAccount(double initialBalance)
   {
balance = initialBalance;
   }

   /**
Deposits money into the bank account.
@param amount the amount to deposit
   */
   public void deposit(double amount)
   {
balance = balance + amount;
   }

   /**
Withdraws money from the bank account.
@param amount the amount to withdraw
   */
   public void withdraw(double amount)
   {
balance = balance - amount;
   }

   /**
Gets the current balance of the bank account.
@return the current balance
   */
   public double getBalance()
   {
return balance;
   }

   /**
Adds interest to the bank account.
@param rate The percentage rate of interest gained.
   */
   public void addInterest(double rate)
   {
balance = balance + balance * rate / 100;
   }
}

BalanceFilter.java

/**
   Filter out balance less than $1,000.
*/
public class BalanceFilter implements Filter
{
   /**
Accept balances no less than $1,000
@param object bank account
@return true if balance is no less than $1,000
   */
   public boolean accept(Object object)
   {
...
   }
}

BalanceMeasurer.java

/**
   Measure bank account balance
*/
public class BalanceMeasurer implements Measurer
{
   /**
Measure bank account balance
@param object bank account
@return balance
   */
   public double measure(Object object)
   {
return ((BankAccount) object).getBalance();
   }
}

Filter.java

/**
   Describes any class whose objects can filter other objects.
*/
public interface Filter
{
   /**
Filters or accepts an object.
@param anObject the object to potentially be filtered
@return accept or reject
   */
   boolean accept(Object anObject);
}

Measurer.java

/**
   Describes any class whose objects can measure other objects.
*/
public interface Measurer
{
   /**
Computes the measure of an object.
@param anObject the object to be measured
@return the measure
   */
   double measure(Object anObject);
}

DataSet.java

public class DataSet
{
   /**
Computes the average of the measures of the given objects.
@param objects an array of objects
@param meas the measurer for the objects
@param filt the filter for the objects
@return the average of the measures
   */
   public static double average(Object[] objects, Measurer meas, Filter filt)
   {
...
   }
}

Answer 1

Here is the completed code for this problem. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. Thanks

Note: Only BalanceFilter.java and DataSet.java files are attached. Other files are not modified (no modifications needed).

// BalanceFilter.java

/**

* Filter out balance less than $1,000.

*/

public class BalanceFilter implements Filter {

      /**

      * Accept balances no less than $1,000

      *

      * @param object

      *            bank account

      * @return true if balance is no less than $1,000

      */

      public boolean accept(Object object) {

            return ((BankAccount) object).getBalance() >= 1000;

      }

}

// DataSet.java

public class DataSet {

      /**

      * Computes the average of the measures of the given objects.

      *

      * @param objects

      *            an array of objects

      * @param meas

      *            the measurer for the objects

      * @param filt

      *            the filter for the objects

      * @return the average of the measures

      */

      public static double average(Object[] objects, Measurer meas, Filter filt) {

            // initializing sum, average and count to 0

            double sum = 0, avg = 0;

            int count = 0;

            // looping through each object in objects array

            for (Object ob : objects) {

                  // using filter object, checking if ob can be accepted

                  if (filt.accept(ob)) {

                        // acceptable, so adding balance of ob to sum, getting balance

                        // using Measurer object

                        sum += meas.measure(ob);

                        // updating count

                        count++;

                  }

            }

            // finding average if count>0 to prevent division by zero.

            if (count > 0) {

                  avg = (double) sum / count;

            }

            return avg;

      }

      // code for testing

      public static void main(String[] args) {

            //creating a BankAccounts array containing different BankAccount objects

            //having balances less than 1000, equal to 1000 and greater than 1000

            BankAccount accounts[] = new BankAccount[] {

                        new BankAccount(200),

                        new BankAccount(1500),

                        new BankAccount(1000),

                        new BankAccount(2000),

                        new BankAccount(3000),

                        new BankAccount(0),

                        new BankAccount(50),

            };

            //creating a BalanceMeasurer and BalanceFilter

            BalanceMeasurer measurer=new BalanceMeasurer();

            BalanceFilter filter=new BalanceFilter();

            //finding average, it will be (1500+1000+2000+3000)/4 = 1875.0

            double avg=average(accounts, measurer, filter);

            //displaying average

            System.out.println("Average is "+avg);

      }

}

/*OUTPUT*/

Average is 1875.0