Comparable interface sorting method not working

Question

I tried to implement the comparable interface on an array list of BankAccounts however, I got major errors,when trying to compile and run the main method of the tester class specifically about the Collection.sort(list) line. It's saying that it doesn't recognize the syntax..looked online and through javadoc and I can't find where I am wrong..

public class BankAccount implements Comparable { //QUESTION 2.1
  /**
  A bank account has a balance that can be changed by 
  deposits and withdrawals.
 */
  private int accountNumber;
   private double balance; 
  /**
  Constructs a bank account with a zero balance
  @param anAccountNumber the account number for this account
  */
  public BankAccount(int anAccountNumber)
  {   
  accountNumber = anAccountNumber;
  balance = 0;
  }

   /**
  Constructs a bank account with a given balance
  @param anAccountNumber the account number for this account
  @param initialBalance the initial balance

*/ public BankAccount(int anAccountNumber, double initialBalance) {
accountNumber = anAccountNumber; balance = initialBalance; }

  /**
  Gets the account number of this bank account.
  @return the account number
  */
  public int getAccountNumber()
  {   
   return accountNumber;
   } 

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

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

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


   public int compareTo (BankAccount temp) {


     if (balance<temp.balance) 
         return -1;
     if (balance==temp.balance) 
         return 0;
     return 1;
  }

}

 public class TestSortedBankAccounts {

    public static void main(String[] args) {
        // Put bank accounts into a list 
        ArrayList<BankAccount> list = new ArrayList<BankAccount>();

        BankAccount ba1 = new BankAccount(100, 500); //Constructor acctNumber and balance
        BankAccount ba2 = new BankAccount(200, 10000);
        BankAccount ba3 = new BankAccount(300, 400);
        BankAccount ba4 = new BankAccount(600, 0);
        BankAccount ba5 = new BankAccount(800, 50);

        list.add(ba1);
        list.add(ba2);
        list.add(ba3);
        list.add(ba4);
        list.add(ba5);

        // Call the library sort method
        Collections.sort(list);

        // Print out the sorted list 
        for (int i = 0; i < list.size(); i++) {
            BankAccount b = list.get(i);
            System.out.println(b.getBalance());
        }
    }
}

UPDATE: TestSortedBankAccounts.java:26: error: no suitable method found for sort(ArrayList) Collections.sort(list); ^ method Collections.sort(List,Comparator) is not applicable (cannot instantiate from arguments because actual and formal argument lists differ in length) method Collections.sort(List) is not applicable (inferred type does not conform to declared bound(s) inferred: BankAccount bound(s): Comparable) where T#1,T#2 are type-variables: T#1 extends Object declared in method sort(List,Comparator) T#2 extends Comparable declared in method sort(List) 1 error

Answer 1

You are implementing the raw version of Comparable . You should implement the generic form of Comparable :

public class BankAccount implements Comparable<BankAccount> {

If you implement the raw form, then the parameter type on compareTo would be Object . With the generic form, you can supply the generic type parameter as a parameter to compareTo as you already have.

Answer 2

My answer (that I've tried and it works):

public class BankAccount implements Comparable<Object> { // <-- 
  /**
  A bank account has a balance that can be changed by 
  deposits and withdrawals.
 */
  private int accountNumber;
   private double balance; 
  /**
  Constructs a bank account with a zero balance
  @param anAccountNumber the account number for this account
  */
  public BankAccount(int anAccountNumber)
  {   
  accountNumber = anAccountNumber;
  balance = 0;
  }

   /**
  Constructs a bank account with a given balance
  @param anAccountNumber the account number for this account
  @param initialBalance the initial balance
  */ 
  public BankAccount(int anAccountNumber, double initialBalance) {
      accountNumber = anAccountNumber; balance = initialBalance; }

  /**
  Gets the account number of this bank account.
  @return the account number
  */
  public int getAccountNumber()
  {   
   return accountNumber;
   } 

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

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

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


   // public int compareTo (BankAccount temp) { // <-- WRONG
   public int compareTo(Object temp){ // <-- RIGHT

     BankAccount other = (BankAccount)temp; // <-- Cast to BankAccount
     if (balance<other.balance) 
         return -1;
     if (balance==other.balance) 
         return 0;
     return 1;
  }

}