Unable to add object to array.

[Edward Strife]

When trying to add person to my list I get the cannot find symbol.

import java.util.Scanner;
import java.io.*;
import list.*;

public class TestSalesReport 
{
	SortedList list = new SortedList();
	
	static int salesTotal;
   static float expensesTotal;
	
	// Scanner based constructor.
	public TestSalesReport(Scanner inFile) 
	{
		SalesPerson person;
		String name;
		int sales;
		float expenses;
  	
		while(inFile.hasNext())
		{
			name = inFile.nextLine();
			sales = inFile.nextInt();
			expenses = inFile.nextFloat();
			person = new SalesPerson(name, sales, expenses);
			list.add(person);
			salesTotal = salesTotal + sales;
			expensesTotal = expensesTotal + expenses;
		}
   
	}
}

My sorted list class:

package list;

//------------------------------------------------------------------------//
// class SortedList                                                       //
// Implements a sorted list                                               //
//------------------------------------------------------------------------//
public class SortedList extends List
{

//------------------------------------------------------------------------//
// SortedList()                                                           //
// Defalut Constructor. Calls parent class                                //
//------------------------------------------------------------------------//
  public SortedList()
  {
    super();
  }

//------------------------------------------------------------------------//
//  public SortedList(int)                                                //
//  Constructor. Calls corresponding constructor in parent class          //
//------------------------------------------------------------------------//
  public SortedList(int maxItems)
  {
    super(maxItems);
  }

//------------------------------------------------------------------------//
// boolean isThere(Comparable)                                            //
// Returns true if the specified item is in the list...otherwise false    //
//------------------------------------------------------------------------//
  public boolean isThere(Comparable item)
  {
    int first = 0;
    int last = numItems-1;
    int middle;
    boolean found = false;
    while (last >= first && !found)
    {
      middle = (first + last)/2;
      if (item.compareTo(listItems[middle])==0)
        found = true;
      else if (item.compareTo(listItems[middle])<0)
        last = middle -1;
      else
        first = middle + 1;
    }
    return found;
  }

//------------------------------------------------------------------------//
// void delete(Comparable)                                                //
// Removes the specified item from the list                               //
//------------------------------------------------------------------------//
  public void delete(Comparable item)
  {
    int index = 0;
    boolean found = false;
    while (index < numItems && !found)
    {
      if (listItems[index].compareTo(item) == 0)
        found = true;
      else
        index++;
    }
    if (found)
    {
      for (int count = index; count < numItems - 1;count++)
        listItems[count] = listItems[count+1];
      numItems--;
    }
  }

//------------------------------------------------------------------------//
// void insert(Comparable)                                                //
// Inserts the specified item into the list                               //
//------------------------------------------------------------------------//
  public void insert(Comparable item)
  {
    if (!isFull())
    {
      int index = numItems - 1;
      while (index >= 0 && (item.compareTo(listItems[index]) < 0))
      {
        listItems[index+1] = listItems[index];
        index--;
      }
      listItems[index+1] = item;
      numItems++;
    }
  }
}

My initial list class:

package list;

//------------------------------------------------------------------------//
// class List                                                             //
// Provides routines needed for implementing a generic list               //
//------------------------------------------------------------------------//
public abstract class List
{
  protected Comparable[] listItems;
  protected int numItems;
  protected int currentPos;

//------------------------------------------------------------------------//
// List()                                                                 //
// Default Constructor. Creates an empty list of size 100                 //
//------------------------------------------------------------------------//
  public List()
  {
    numItems = 0;
    listItems = new Comparable[100];
    currentPos = 0;
  }

//------------------------------------------------------------------------//
// List(int)                                                              //
// Constructor. Creates an empty list of the specified size               //
//------------------------------------------------------------------------//
  public List(int maxItem)
  {
    numItems = 0;
    listItems = new Comparable[maxItem];
    currentPos = 0;
  }

//------------------------------------------------------------------------//
// boolean isFull()                                                       //
// Returns true if the list is full...otherwise false                     //
//------------------------------------------------------------------------//
  public boolean isFull()
  {
    return (listItems.length == numItems);
  }

//------------------------------------------------------------------------//
// boolean isEmpty                                                        //
// Returns true if the list is empty...otherwise false                    //
//------------------------------------------------------------------------//
  public boolean isEmpty()
  {
    return (numItems == 0);
  }

//------------------------------------------------------------------------//
// int length()                                                           //
// Returns the number of items in the list                                //
//------------------------------------------------------------------------//
  public int length()
  {
    return numItems;
  }

//------------------------------------------------------------------------//
// void resetList()                                                       //
// Sets the position of the list to the beginning for use with the        //
// getNextItem() function                                                 //
//------------------------------------------------------------------------//
  public void resetList()
  {
    currentPos = 0;
  }

//------------------------------------------------------------------------//
// Comparable getNextItem()                                               //
// Returns the item pointed to by currentPos...increments currentPos when //
// done                                                                   //
//------------------------------------------------------------------------//
  public Comparable getNextItem()
  {
    Comparable next = listItems[currentPos];
    if (currentPos == numItems -1)
      currentPos = 0;
    else
      currentPos++;
    return next;
  }

//------------------------------------------------------------------------//
// void delete(Comparable)                                                //
// Removes the specified item from the list                               //
//------------------------------------------------------------------------//
  public abstract void delete(Comparable item);

//------------------------------------------------------------------------//
// void insert(Comparable)                                                //
// Inserts the specified item into the list                               //
//------------------------------------------------------------------------//
  public abstract void insert(Comparable item);

//------------------------------------------------------------------------//
// isThere(Comparable)                                                    //
// Returns true if the specified item is in the list otherwise returns    //
// false                                                                  //
//------------------------------------------------------------------------//
  public abstract boolean isThere(Comparable item);
}

[E Armitage]

I don't see a method called add in your list class.
Did you want to call the method called insert instead?

[Matthew Brown]

It's a really bad idea to name your classes after classes in the standard Java libraries - expecially ones that are commonly used. It just leads to confusion. So don't call your own class List. If you want to implement java.util.List, do that. If you don't, use a different name.