need help with java

[Harry Smith]

hello everyone, i trying to run this program it is giving me error. i think i typed it something wrong in main. i don't see it. can some please take a look and give me some suggestion.

here is my code:
import java.io.*;
// File: DoubleArraySeq.java
 
 
public class DoubleArraySeq implements Cloneable
 
{
   // Invariant of the DoubleArraySeq class:
   //   1. The number of elements in the seqeunces is in the instance variable 
   //      manyItems.
   //   2. For an empty sequence (with no elements), we do not care what is 
   //      stored in any of data; for a non-empty sequence, the elements of the
   //      sequence are stored in data[0] through data[manyItems-1], and we
   //      don�t care what�s in the rest of data.
   //   3. If there is a current element, then it lies in data[currentIndex];
   //      if there is no current element, then currentIndex equals manyItems. 
 
   private double[ ] data;
 
   private int manyItems;
 
   private int currentIndex; 
 
   
 
   /**
   * Initialize an empty sequence with an initial capacity of 10.  Note that
   * the addAfter and addBefore methods work
   * efficiently (without needing more memory) until this capacity is reached.
   * @param - none
   * Postcondition:
   *   This sequence is empty and has an initial capacity of 10.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for: 
   *   new double[10].
   **/   
 
   public DoubleArraySeq( )
   {
      // Implemented by student.
           final int INITIAL_CAPACITY = 10;
           manyItems = 0;
           data = new double[INITIAL_CAPACITY];
           currentIndex = -1; //0
           System.out.println("initialized");
 
   }
 
   /**
   * Initialize an empty sequence with a specified initial capacity. Note that
   * the addAfter and addBefore methods work
   * efficiently (without needing more memory) until this capacity is reached.
   * @param initialCapacity
   *   the initial capacity of this sequence
   * Precondition:
   *   initialCapacity is non-negative.
   * Postcondition:
   *   This sequence is empty and has the given initial capacity.
   * @exception IllegalArgumentException
   *   Indicates that initialCapacity is negative.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for: 
   *   new double[initialCapacity].
   **/   
 
   public DoubleArraySeq(int initialCapacity)
   {
      // Implemented by student.
         if (initialCapacity < 0)
         throw new IllegalArgumentException  ("The initialCapacity is negative: " + initialCapacity);
         data = new double[initialCapacity];
         manyItems = 0;
         currentIndex=0;
   }
 
 
   /**
   * Add a new element to this sequence, after the current element. 
   * If the new element would take this sequence beyond its current capacity,
   * then the capacity is increased before adding the new element.
   * @param element
   *   the new element that is being added
   * Postcondition:
   *   A new copy of the element has been added to this sequence. If there was
   *   a current element, then the new element is placed after the current
   *   element. If there was no current element, then the new element is placed
   *   at the end of the sequence. In all cases, the new element becomes the
   *   new current element of this sequence. 
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for increasing the sequence's capacity.
   * Note:
   *   An attempt to increase the capacity beyond
   *   Integer.MAX_VALUE will cause the sequence to fail with an
   *   arithmetic overflow.
   **/
 
   public void addAfter(double element)
   {
      // Implemented by student.
      if (manyItems == data.length)
      {
         // Double the capacity and add 1; this works even if manyItems is 0.
         // However, in the case that manyItems*2 + 1 is beyond
         // Integer.MAX_VALUE, there will be an arithmetic overflow and
         // the bag will fail.
         ensureCapacity(manyItems*2 + 1);
          //biggerArray = new Object [initialCapacity];
      }
  //check if there is no current index
  //if so, put element at end of list and reset current index
         
 
 //otherwise move all elements over and place element after
 //current and update current 
 
 
 
      //update manyItems
      }
  
//end addAfter
 
 
   /**
 
   * Add a new element to this sequence, before the current element. 
   * If the new element would take this sequence beyond its current capacity,
   * then the capacity is increased before adding the new element.
   * @param element
   *   the new element that is being added
   * Postcondition
   *   A new copy of the element has been added to this sequence. If there was
   *   a current element, then the new element is placed before the current
   *   element. If there was no current element, then the new element is placed
   *   at the start of the sequence. In all cases, the new element becomes the
   *   new current element of this sequence. 
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for increasing the sequence's capacity.
   * Note:
   *   An attempt to increase the capacity beyond
   *   Integer.MAX_VALUE will cause the sequence to fail with an
   *   arithmetic overflow.
   **/
 
   public void addBefore(double element)
   {
      // Implemented by student.
      if (manyItems == data.length)
      {
         // Double the capacity and add 1; this works even if manyItems is 0.
         // However, in the case that manyItems*2 + 1 is beyond
         // Integer.MAX_VALUE, there will be an arithmetic overflow and
         // the bag will fail.
         ensureCapacity(manyItems*2 + 1);
      }//id
     if (currentIndex == -1)
     {
     for (int i=manyItems; i>0; i--)
    data[i]=data[i-1];
      data[0]= element;
      currentIndex= 0;
      }
      else 
      {
     for (int i=manyItems; i>currentIndex; i--)
       data[i]=data[i-1];
     data[currentIndex]= element;
      }
       manyItems++;
      }
   
 
 
    
 
   /**
   * Move forward, so that the current element is now the next element in
   * this sequence.
   * @param - none
   * Precondition:
   *   isCurrent() returns true. 
   * Postcondition:
   *   If the current element was already the end element of this sequence 
   *   (with nothing after it), then there is no longer any current element. 
   *   Otherwise, the new element is the element immediately after the 
   *   original current element.
   * @exception IllegalStateException
   *   Indicates that there is no current element, so 
   *   advance may not be called.
   **/
 
   public void advance( )
 
   {
 
      // Implemented by student.
      if (!isCurrent())
       throw new IllegalStateException("There is no current item.");
    currentIndex++;
    if (currentIndex == manyItems)
        currentIndex= -1;
   }
 
   
 
   
 
   /**
 
   * Generate a copy of this sequence.
   * @param - none
   * @return
   *   The return value is a copy of this sequence. Subsequent changes to the
   *   copy will not affect the original, nor vice versa. Note that the return
   *   value must be type cast to a DoubleArraySeq before it can be used.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for creating the clone.
   **/ 
 
   public Object clone( )
   {  // Clone a DoubleArraySeq object.
      DoubleArraySeq answer;
      
      try
      {
         answer = (DoubleArraySeq) super.clone( );
      }
      catch (CloneNotSupportedException e)
 
      {  // This exception should not occur. But if it does, it would probably
         // indicate a programming error that made super.clone unavailable.
         // The most common error would be forgetting the "Implements Cloneable"
         // clause at the start of this class.
 
         throw new RuntimeException
 
         ("This class does not implement Cloneable");
 
      }
       answer.data = (double [ ]) data.clone( );
      return answer;
 
   }
  
 
   /**
   * Change the current capacity of this sequence.
   * @param minimumCapacity
   *   the new capacity for this sequence
   * Postcondition:
   *   This sequence's capacity has been changed to at least minimumCapacity.
   *   If the capacity was already at or greater than minimumCapacity,
   *   then the capacity is left unchanged.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for: new int[minimumCapacity].
   **/
 
   public void ensureCapacity(int minimumCapacity)
 
   {
      // Implemented by student.
      {
      //Object biggerArray[ ];
      double biggerArray[];
      
      if (data.length < minimumCapacity)
      {
         //biggerArray = new Object [minimumCapacity];
         biggerArray = new double [minimumCapacity];
         System.arraycopy(data, 0, biggerArray, 0, manyItems);
         data = biggerArray;
         //data = trimmedArray;
      }
   }
 
 
   }
 
   /**
 
   * Accessor method to get the current capacity of this sequence. 
   * The add method works efficiently (without needing
   * more memory) until this capacity is reached.
   * @param - none
   * @return
   *   the current capacity of this sequence
   **/
 
   public int getCapacity( )
 
   {
 
      // Implemented by student.
     return data.length; // to be changed
   }
 
 
   /**
   * Accessor method to get the current element of this sequence. 
   * @param - none
   * Precondition:
   *   isCurrent() returns true.
   * @return
   *   the current element of this sequence
   * @exception IllegalStateException
   *   Indicates that there is no current element, so 
   *   getCurrent may not be called.
   **/
 
   public double getCurrent( )
 
   {
 
      // Implemented by student.
       if (!isCurrent())
       throw new IllegalStateException("There is no current item.");
 
      return data[currentIndex]; //to be changed
   }
 
 
 
 
 
   /**
 
   * Accessor method to determine whether this sequence has a specified 
   * current element that can be retrieved with the 
   * getCurrent method. 
   * @param - none
   * @return
   *   true (there is a current element) or false (there is no current element at the moment)
   **/
 
   public boolean isCurrent( )
 
   {
 
      // Implemented by student.
      return (currentIndex >= 0);
 
    // to be changed
   }
 
              
 
   /**
 
   * Remove the current element from this sequence.
   * @param - none
   * Precondition:
   *   isCurrent() returns true.
   * Postcondition:
   *   The current element has been removed from this sequence, and the 
   *   following element (if there is one) is now the new current element. 
   *   If there was no following element, then there is now no current 
   *   element.
   * @exception IllegalStateException
   *   Indicates that there is no current element, so 
   *   removeCurrent may not be called. 
   **/
 
   public void removeCurrent( )
 
   {
 
      // Implemented by student.
             if (!isCurrent())
       throw new IllegalStateException("There is no current item.");
 
      if (currentIndex < manyItems-1)
    {
     for(int i=currentIndex; i<manyItems-1; i++)
        data[i]= data[i+1];
     }
    else currentIndex= -1;
         manyItems--;
 
 
   }
  
 
   /**
 
   * Determine the number of elements in this sequence.
   * @param - none
   * @return
   *   the number of elements in this sequence
   **/ 
 
   public int size( )
 
   {
 
      // Implemented by student.
return manyItems; // to be changed
   }
 
   /**
   * Set the current element at the front of this sequence.
   * @param - none
   * Postcondition:
   *   The front element of this sequence is now the current element (but 
   *   if this sequence has no elements at all, then there is no current 
   *   element).
   **/ 
 
   public void start( )
 
   {
 
      // Implemented by student.
      if (manyItems == 0) 
       currentIndex= -1;
     else
      currentIndex = 0;
 
 
   }
   /**
 
   * Reduce the current capacity of this sequence to its actual size (i.e., the
   * number of elements it contains).
   * @param - none
   * Postcondition:
   *   This sequence's capacity has been changed to its current size.
   * @exception OutOfMemoryError
   *   Indicates insufficient memory for altering the capacity. 
   **/
 
   public void trimToSize( )
 
   {
 
      double trimmedArray[ ];
      if (data.length != manyItems)
      {
         trimmedArray = new double[manyItems];
         System.arraycopy(data, 0, trimmedArray, 0, manyItems);
         data = trimmedArray;
         //data = arrycopy;
      }
 
   }
public static void main (String [] args){
double[] dataNum = {4.1,13.8,62.8,69.99,70.02,90.7};
DoubleArraySeq newDataNum = new DoubleArraySeq();
for (int j=0; j < dataNum.length; j++)
  newDataNum.addAfter(dataNum[j]);
  newDataNum.print();
  newDataNum.addBefore(11.99);
  newDataNum.print();
 }
}  

[ December 18, 2005: Message edited by: Harry Smith ]

[Scott Johnson]

What is the error? Include the full exception message text and stack trace.

[Ernest Friedman-Hill]

Hi Mr. ap,

Welcome to JavaRanch!

A bit of business: you may not have read our naming policy on the way in. It requires that you use a full, real (sounding) first and last name for your display name. Joke names and "handles" don't cut it. You'll find that many people are unwilling to answer your questions until you follow the house rules.

You can change your display name here. Thanks for your immediate attention.

[marc weber]

Code Tags are also a big help.

[marc weber]

The compilation problem is with the calls to newDataNum.print(); in main, where newDataNum is an instance of DoubleArraySeq. There is no print method defined in DoubleArraySeq. This is what the compiler should be telling you with...

DoubleArraySeq.java:450: cannot find symbol
symbol  : method print()
location: class DoubleArraySeq
          newDataNum.print();
                    ^
DoubleArraySeq.java:452: cannot find symbol
symbol  : method print()
location: class DoubleArraySeq
          newDataNum.print();
                    ^

...where 450 and 452 are the line numbers in your code.

[Harry Smith]

yes, you are right marc weber. thanks marc weber for your help.

[Adam Richards]

Another Tip: Try to use more specific subject lines. The more meaningful your subject, the more meaningful your replies.