Ok, before everyone gets mad at me for not looking around the board for these topics, I have, but they weren't my problem. My problem I am having is calling the Polynomial class. I know how to call classes in a different class, but this is a bit different. I also realize that this is a homework assignment, and I don't want anyone to do my assignment for me. This is just a step that I am confused about. In addition, I can't just call the Polynomial class because I need to add two polynomials, then in another case subtract, and the other math-type stuff.
Thank you for looking at my thread, if you helped, thanks a lot, if not, thank you for your time to look.

This is my driver class, which all it does so far is basically the menu system.

//Driver
import java.io.*;
import java.util.*;
public class Project6
{
	private static Scanner console = new Scanner(System.in);
	public static void main(String[] args)

	{
		//3 instances of the class Polynomial
		Polynomial polyAdd = new Polynomial();
		Polynomial polySub = new Polynomial();
		Polynomial polyMul = new Polynomial();

		//Call to menu
		menu();
	}
	public static void menu()

	{
		//Decalre Variable to record the user's number entered to navigate menu
		int choice;
		String polynomial1;
		String polynomial2;

		//Menu print
		System.out.println("1. Create a Polynomial from the keyboard.");
		System.out.println("2. Add two Polynomials and Display Result.");
		System.out.println("3. Subtract two Polynomials and Display Result.");
		System.out.println("4. Multiply two Polynomials and Display Result.");
		System.out.println("5. Terminate the program");
		System.out.println("");

		//Take in choice variable to navigate the menu
		choice = console.nextInt();
		System.out.println("");

		//Switch controlling the menu system
		switch (choice)
		{
		//Take in two polynomails
		case 1:
		System.out.println("Enter the first polynomial.");
		polynomial1 = console.next();
		System.out.println("Enter the second polynomial.");
		polynomial2 = console.next();
		System.out.println("");
		break;

		//Add two Polynomials and Display result
		case 2:
		System.out.println("");
		break;

		//Subtract two Polynomials and Display result
		case 3:
		System.out.println("");
		break;

		//Multiply two Polynomials and Display result
		case 4:

		System.out.println("");
		break;


		//Terminate the program
		case 5:
		System.exit(0);
		break;

		//Default
		default:
		choice = console.nextInt();
		console.nextLine();
		}
		menu();
	}

}

This is a worker class, and I am trying to call it.

import java.util.*;

public class Polynomial extends UnorderedArrayList<Double>
{
       //Default constructor
       //Postcondition: An array of the size 100, and
       //             length and maxSize are set to 100
    public Polynomial()
    {
         super();
         length = 100;
    }

      //Constructor with a parameter
      //Postcondition: An array of the size specified by
      //               the parameter size is created, length
      //               and maxSize are initialized to size
    public Polynomial(int size)
    {
         super(size);
         length = size;
    }

       //Method to evaluate a polynomial at a given value
       //Postcondition: The polynomial is evaluated at x and
       //               the value is returned
    public double evaluate(Double x)
    {
        double value = 0.0;

        Double coeff;

        for (int i = 0; i < length; i++)
        {
            coeff = retrieveAt(i);

            if (coeff != 0.0)
               value = value + coeff * Math.pow(x, i);
        }

        return value;
    }

       //Method to add two polynomials
       //Postcondition: This polynomial is added with the polynomial
       //               specified by the parameter right. A
       //               reference of the result is returned.
    public Polynomial add(Polynomial right)
    {
        int size = max(length, right.length);
        int i;
        Double sumCoeff;

        Double coeffP;
        Double coeffQ;

        Polynomial temp = new Polynomial(size);

        for (i = 0; i < min(length, right.length); i++)
        {
            coeffP = retrieveAt(i);
            coeffQ = right.retrieveAt(i);

            sumCoeff = coeffP + coeffQ;
            temp.replaceAt(i, sumCoeff);
        }

        if (size == length)
            for (i = min(length, right.length); i < length; i++)
                temp.replaceAt(i, retrieveAt(i));
        else
            for (i = min(length, right.length);
                                  i < right.length; i++)
                temp.replaceAt(i, right.retrieveAt(i));

        return temp;
    }

       //Method to subtract two polynomials
       //Postcondition: The polynomial specified by the
       //               parameter right is subtracted from this
       //               polynomial. A reference of the result
       //               is returned.
    public Polynomial subtract(Polynomial right)
    {
        int size = max(length, right.length);
        int i;
        Double diffCoeff;

        Double coeffP;
        Double coeffQ;

        Polynomial temp = new Polynomial(size);

        for (i = 0; i < min(length, right.length); i++)
        {
            coeffP = retrieveAt(i);
            coeffQ = right.retrieveAt(i);

            diffCoeff = coeffP - coeffQ;
            temp.replaceAt(i, diffCoeff);
        }

        if (size == length)
           for (i = min(length, right.length); i < length; i++)
               temp.replaceAt(i, retrieveAt(i));
        else
           for (i = min(length, right.length);
                                    i < right.length; i++)
           {
               Double coeff;
               coeff = right.retrieveAt(i);
               coeff = -coeff;
               temp.replaceAt(i, coeff);
           }

        return temp;
    }

       //Method to multiply two polynomials
       //Postcondition: This polynomial is multiplied with the
       //               polynomial specified by the parameter right.
       //               A reference of the result is returned.
    public Polynomial multiply(Polynomial right)
    {

        Polynomial temp = new Polynomial();

        System.out.println("See Programming Exercise 5 at "
                         + "the end of the chapter.");

        return temp;
    }

       //Method to read the coefficients of a polynomial
    public void read()
    {
        Scanner console = new Scanner(System.in);

        Double x;

        System.out.println("The degree of this polynomial is: "
                         + (length - 1));
        for (int i = 0; i < length; i++)
        {
            System.out.print("Enter the coefficient of x^"
                             + i + ": ");

            x = console.nextDouble();
            replaceAt(i, x);
        }
    }

       //Method to return the string containing the polynomial
    public String toString()
    {
        int i;
        int firstNonzeroCoeff = 0;
        Double coeff = 0.0;
        String str = "";

        for (i = 0; i < length; i++)
        {
            coeff = retrieveAt(i);

            if (coeff != 0.0)
            {
               firstNonzeroCoeff = i;
               break;
            }
        }

        if (firstNonzeroCoeff < length)
        {
           if (firstNonzeroCoeff == 0)
              str = retrieveAt(firstNonzeroCoeff) + " ";
           else
              str = retrieveAt(firstNonzeroCoeff) + "x^"
                       + firstNonzeroCoeff + " ";

           for (i = firstNonzeroCoeff + 1; i < length; i++)
           {
               coeff = retrieveAt(i);

               if (coeff != 0.0)
                  if (coeff > 0.0)
                     str += "+ " + coeff + "x^" + i + " ";
                  else
                     str += "- " + (-coeff) + "x^" + i + " ";
           }
        }

        return str;
    }

       //Method to determine the smaller of x and y
       //Postcondition: The smaller of x and y is returned
    public int min(int x, int y)
    {
        if (x <= y)
           return x;
        else
           return y;
    }

       //Method to determine the larger of x and y
       //Postcondition: The larger of x and y is returned
    public int max(int x, int y)
    {
        if (x >= y)
            return x;
        else
            return y;
    }
}

I included the next class because it was extended in my Polynomial worker class.

public class UnorderedArrayList<T> extends ArrayListClass<T>
{
	   //Default constructor
    public UnorderedArrayList()
    {
        super();
    }

       //Constructor with a parameter
    public UnorderedArrayList(int size)
    {
        super(size);
    }

       //Method to determine whether searchItem is in the list.
       //Postcondition: If searchItem is found, returns the
       //               location in the array where searchItem
       //               is found; otherwise, returns -1.
    public int seqSearch(T searchItem)
    {
        int loc;
        boolean found = false;

        for (loc = 0; loc < length; loc++)
            if (list[loc].equals(searchItem))
            {
                found = true;
                break;
            }

        if (found)
            return loc;
        else
            return -1;
    } //end seqSearch

       //Method to insert insertItem in the list at the position
       //specified by location.
       //Postcondition: Starting at location, the elements of
       //               the list are shifted to make room for
       //               insertItem, list[location] = insertItem;,
       //               and length++;
       //               If the list is full or location is out
       //               of range, an appropriate message is
       //               output.
    public void insertAt(int location, T insertItem)
    {
        if (location < 0 || location >= maxSize)
            System.err.println("The position of the item to "
                             + "be inserted is out of range.");
        else
            if (length >= maxSize)  //list is full
                System.err.println("Cannot insert in a full "
                                 + "list.");
            else
            {
                for (int i = length; i > location; i--)
                    list[i] = list[i - 1];  //move the
                                            //elements down

                list[location] = insertItem;
                length++;   //increment the length
            }
    } //end insertAt

       //Method to insert insertItem at the end of the list.
       //Postcondition: list[length] = insertItem; and length++;
       //               If the list is full, an appropriate
       //               message is output.
    public void insertEnd(T insertItem)
    {
        if (length >= maxSize)  //the list is full
            System.err.println("Cannot insert in a full list.");
        else
        {
              list[length] = insertItem;  //insert the
                                          //item at the end
              length++; //increment the length
        }
    } //end insertEnd


       //Method to replace the element in the list at
       //the position specified by location with repItem.
       //Postcondition: list[location] = repItem
       //               If location is out of range, an
       //               appropriate message is output.
    public void replaceAt(int location, T repItem)
    {
        if (location < 0 || location >= length)
            System.err.println("The location of the item to "
                             + "be replaced is out of range.");
        else
            list[location] = repItem;
    } //end replaceAt

       //Method to remove an item from the list.
       //The parameter removeItem specifies the item to
       //be removed.
       //Postcondition: If removeItem is found in the list, it
       //               is removed from the list and length is
       //               decremented by one.
    public void remove(T removeItem)
    {
        int loc;

        if (length == 0)
            System.err.println("Cannot delete from an "
                             + "empty list.");
        else
        {
            loc = seqSearch(removeItem);

            if (loc != -1)
                removeAt(loc);
            else
                System.out.println("The item to be deleted "
                                 + "is not in the list.");
        }
    } //end remove
}

I included this class because it was extended in my UnorderedArrayList class.

public abstract class ArrayListClass<T>
                      implements ArrayListADT<T>, Cloneable
{
    protected int length;  //to store the length of the list
    protected int maxSize; //to store the maximum size of
                           //the list
    protected T[] list;    //array to hold the list elements


       //Default constructor
       //Creates an array of size 100
       //Postcondition: list points to the array, length = 0,
       //               and maxSize = 100
    public ArrayListClass()
    {
        maxSize = 100;

        length = 0;
        list = (T[]) new Object[maxSize];
    }

       //Constructor with a parameter
       //Creates an array of the size specified by the
       //parameter size.
       //Postcondition: list points to the array, length = 0,
       //               and maxSize = size
    public ArrayListClass(int size)
    {
        if (size <= 0)
        {
            System.err.println("The array size must be positive. "
                             + "Creating an array of size 100. ");
             maxSize = 100;
        }
        else
            maxSize = size;

        length = 0;
        list = (T[]) new Object[maxSize];
    }

       //Method to determine whether the list is empty.
       //Postcondition: Returns true if the list is empty;
       //               otherwise, returns false.
    public boolean isEmpty()
    {
        return (length == 0);
    }

       //Method to determine whether the list is full.
       //Postcondition: Returns true if the list is full;
       //               otherwise, returns false.
    public boolean isFull()
    {
        return (length == maxSize);
    }

       //Method to return the number of elements in the list.
       //Postcondition: Returns the value of length.
    public int listSize()
    {
        return length;
    }

       //Method to return the maximum size of the list.
       //Postcondition: Returns the value of maxSize.
    public int maxListSize()
    {
        return maxSize;
    }

       //Method to output the elements of the list.
       //Postcondition: Elements of the list are output on the
       //standard output device.
    public void print()
    {
        for (int i = 0; i < length; i++)
            System.out.println(list[i]);
        System.out.println();
    }

       //Returns a copy of objects data in store.
       //This method clones only the references stored in
       //the array. The objects that the array references
       //point to are not cloned.
    public Object clone()
    {
        ArrayListClass<T> copy = null;

        try
        {
            copy = (ArrayListClass<T>) super.clone();
        }
        catch (CloneNotSupportedException e)
        {
            return null;
        }

        copy.list = (T[]) list.clone();

        return copy;
    }

       //Method to determine whether item is the same as the item
       //in the list at the position specified by location.
       //Postcondition: Returns true if list[location] is the
       //               same as item; otherwise, returns false.
    public boolean isItemAtEqual(int location, T item)
    {
        if (location < 0 || location >= length)
        {
            System.err.println("The location of the item to "
                             + "be compared is out of range.");
            return false;
        }

        return (list[location].equals(item));
    }

       //Method to remove all the elements from the list.
       //Postcondition: length = 0
    public void clearList()
    {
        for (int i = 0; i < length; i++)
            list[i] = null;

          length = 0;

        System.gc();   //invoke garbage collector
    } //end clearList

       //Method to remove the item from the list at the position
       //specified by location.
       //Postcondition: The list element at list[location] is
       //               removed and length is decremented by 1.
       //               If location is out of range, an
       //               appropriate message is output.
    public void removeAt(int location)
    {
        if (location < 0 || location >= length)
            System.err.println("The location of the item to "
                             + "be removed is out of range.");
        else
        {
            for (int i = location; i < length - 1; i++)
                  list[i] = list[i + 1];

            list[length - 1] = null;

            length--;
        }
    } //end removeAt

       //Method to retrieve the element from the list at the
       //position specified by location.
       //Postcondition: A reference of the element at the
       //               position specified by location is
       //               returned. If location is out of range,
       //               an appropriate message is output and
       //               null is returned.
    public T retrieveAt(int location)
    {
        if (location < 0 || location >= length)
        {
            System.err.println("The location of the item to be "
                             + "retrieved is out of range.");
            return null;
        }
        else
            return list[location];
    } //end retrieveAt


       //Method to insert insertItem in the list at the position
       //specified by location.
       //Postcondition: Starting at location, the elements of
       //               the list are shifted to make room for
       //               insertItem, list[location] = insertItem;,
       //               and length++;
       //               If the list is full or location is out
       //               of range, an appropriate message is
       //               output.
    public abstract void insertAt(int location, T insertItem);

       //Method to insert insertItem at the end of the list.
       //Postcondition: list[length] = insertItem; and length++;
       //               If the list is full, an appropriate
       //               message is output.
    public abstract void insertEnd(T insertItem);

        //Method to replace the element in the list at
        //the position specified by location with repItem.
        //Postcondition: list[location] = repItem
        //               If location is out of range, an
        //               appropriate message is output.
    public abstract void replaceAt(int location, T repItem);

       //Method to determine whether searchItem is in the list.
       //Postcondition: If searchItem is found, returns the
       //               location in the array where searchItem
       //               is found; otherwise, returns -1.
    public abstract int seqSearch(T searchItem);

       //Method to remove an item from the list.
       //The parameter removeItem specifies the item to
       //be removed.
       //Postcondition: If removeItem is found in the list, it
       //               is removed from the list and length is
       //               decremented by one.
    public abstract void remove(T removeItem);
}

Recommended Answers

All 5 Replies

public static void main(String[] args) {
        Polynomial polyAdd = new Polynomial();
        System.out.println(polyAdd.toString());
    }

run:
Exception in thread "main" java.lang.NullPointerException
at Hanyouslayer.Polynomial.toString(Polynomial.java:162)
at Hanyouslayer.Polynomial.main(Polynomial.java:213)
Java Result: 1

Why it gives error, where are defaults...

defaults as in in my switch statement?

Default polynomial:
Look athttp://en.wikipedia.org/wiki/Polynomial#Classifications
The simplest polynomial is

The polynomial 0, which may be considered to have no terms at all, is called the zero polynomial.

I would like to see that Your default Polynomial() meet the minimum requirements to be a polynomial.
Like new Point() == new Point(0,0)
//
Menu structure:
1. Create a Polynomial from the keyboard.
- User should enter as many polynomials as he wishes (You know lists) , and displays them in order.
- User should indicate which pairs of polynomials and in what order subject to mathematical operations, result should be stored
- Bringing in of a fully polynomial with a keyboard, inside constructor.
Why not? Constructor displays own menu and gets all necessary parameters.

where is the codes for public Polynomial multiply(Polynomial right) ?

It's in this thread if you look for it.
But you would be far better advised to write your own rather than copy something that can be traced on the internet

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.