Why is my object staying null?

Question

For some reason, I can't seem to fix this giving me a NullPointerException. I print out poly.term.degree without any errors, and then set poly.next equal to poly and then get a nullPointerException when I try to print out poly.next.term.degree which should seemingly be the same. I'm aware this is incomplete code but I think this is my main issue.

public Polynomial add(Polynomial p)
{   
    Polynomial newPoly = new Polynomial();

    newPoly.poly = new Node(0,0,null);

    Polynomial myCurr = this;

    Polynomial otherCurr = p;       

    while(myCurr.poly != null)
    {

        int myDeg = myCurr.poly.term.degree;
        int otherDeg = p.poly.term.degree;

        float myCo = myCurr.poly.term.coeff;
        float otherCo = otherCurr.poly.term.coeff;

        if(myDeg == otherDeg)
        {
            System.out.println("degrees "+myDeg + " and "+ otherDeg+ " are equal, creating new node...");

            Node n = new Node(myCo+otherCo,p.poly.term.degree, newPoly.poly.next);

            System.out.println(newPoly.poly.term.degree);

            newPoly.poly.next = newPoly.poly;
            newPoly.poly = n;

            System.out.println(newPoly.poly.next.term.degree); // Gives me a NullPointerException

        }

Also, the constructors and everything for these classes is below.

      package poly;

      import java.io.*;
      import java.util.StringTokenizer;

/**
 * This class implements a term of a polynomial.
 * 
 * @author runb-cs112
 *
 */
 class Term {
    /**
    * Coefficient of term.
    */
    public float coeff;

    /**
     * Degree of term.
     */
    public int degree;

    /**
     * Initializes an instance with given coefficient and degree.
     * 
     * @param coeff Coefficient
     * @param degree Degree
     */
    public Term(float coeff, int degree) {
        this.coeff = coeff;
        this.degree = degree;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    public boolean equals(Object other) {
        return other != null &&
        other instanceof Term &&
        coeff == ((Term)other).coeff &&
        degree == ((Term)other).degree;
    }

    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    public String toString() {
        if (degree == 0) {
            return coeff + "";
        } else if (degree == 1) {
            return coeff + "x";
        } else {
            return coeff + "x^" + degree;
        }
    }
}

/**
 * This class implements a linked list node that contains a Term instance.
 * 
 * @author runb-cs112
 *
 */
class Node {

    /**
     * Term instance. 
     */
    Term term;

    /**
     * Next node in linked list. 
     */
    Node next;

    /**
     * Initializes this node with a term with given coefficient and degree,
     * pointing to the given next node.
     * 
     * @param coeff Coefficient of term
     * @param degree Degree of term
     * @param next Next node
     */
    public Node(float coeff, int degree, Node next) {
        term = new Term(coeff, degree);
        this.next = next;
    }

}

/**
 * This class implements a polynomial.
 * 
 * @author runb-cs112
 *
 */
public class Polynomial {

    /**
     * Pointer to the front of the linked list that stores the polynomial. 
     */ 
    Node poly;

    /** 
     * Initializes this polynomial to empty, i.e. there are no terms.
     *
     */
    public Polynomial() {
        poly = null;
    }

    /**
     * Reads a polynomial from an input stream (file or keyboard). The storage format
     * of the polynomial is:
     * <pre>
     *     <coeff> <degree>
     *     <coeff> <degree>
     *     ...
     *     <coeff> <degree>
     * </pre>
     * with the guarantee that degrees will be in descending order. For example:
     * <pre>
     *      4 5
     *     -2 3
     *      2 1
     *      3 0
     * </pre>
     * which represents the polynomial:
     * <pre>
     *      4*x^5 - 2*x^3 + 2*x + 3 
     * </pre>
     * 
     * @param br BufferedReader from which a polynomial is to be read
     * @throws IOException If there is any input error in reading the polynomial
     */
    public Polynomial(BufferedReader br) throws IOException {
        String line;
        StringTokenizer tokenizer;
        float coeff;
        int degree;

        poly = null;

        while ((line = br.readLine()) != null) {
            tokenizer = new StringTokenizer(line);
            coeff = Float.parseFloat(tokenizer.nextToken());
            degree = Integer.parseInt(tokenizer.nextToken());
            poly = new Node(coeff, degree, poly);
        }
    }

Answer 1

I think the problem lies here:

        newPoly.poly.next = newPoly.poly;
        newPoly.poly = n;

At first you say, that newPoly.poly.next = newPoly.poly; so you assign the current element to the next, which is recursive. And then you say newPoly.poly = n; . So you assign a new element to newPoly. I think that the garbage collector deletes the newPoly element, because it is overwritten, so you lose the reference to the newPoly element. Which means when you access it later you get a nullpointer exception. You could fix this like this:

    newPoly.poly.next = n;
    //and dont forget to set the next pointer of the new elemnt to 0
    n.next = NULL;

Just assign the new element to the next element. EDIT @hendersawn

You could sort the list. See below:

sort(Node head_p){ //do not change the head, or you will lose the beginning.
Node tmp_p; 
Node curr_p = head_p; 
while(curr_p != NULL){ 
if(curr_p.poly.term.degree < curr_p.next.poly.term.degree) //either degree is smaller or greater 
{//swap 
    tmp_p = curr_p; //save first element
    curr_p = curr_p.next; //set first element to second
    //now the 2 element is the actual third element so we need 
    //to put the first between the second and the third
    tmp_p.next = curr_p.next; //set next of first to third
    curr_p.next = tmp_p; //set second element to the first that we saved before
}
curr_p = curr_p.next; //move to next element...rinse repeat
}
}

Answer 2

newPoly might be null

newPoly.poly might be null

newPoly.poly.next might be null

newPoly.poly.next.term might be null

or

newPoly.poly.next.term.degree might be null.

To avoid NullPointerException, you need to make sure that any member used is initialized with a proper value.

Answer 3

Nothing is obviously null that I can tell, however with four 'dots' (something.something.something.something) of Object Oriented Indirection, you're going to encounter this problem a lot. Usually two - three 'dots' on a single line are all you should ever do, but since that's more about the design and not the error, I digress.

The way to find this problem would be to either:

1. Put a breakpoint right at that line and see what the variables are there, and which one is null or
2. Do a System.out.println for each of the components to see which one breaks it, and work backwards from there. ex: System.out.println(newPoly.poly.next.term.degree); // Gives me a NullPointerException

System.out.println(newPoly);

System.out.println(newPoly.poly);

System.out.println(newPoly.poly.next);

System.out.println(newPoly.poly.next.term);

because the nullPointerException would only get thrown on one of those (it can't be degree, otherwise that statement would have just printed 'null'

if I had to bet, I'd say it's probably newPoly.poly.next which is null

the lines:

newPoly.poly.next = newPoly.poly;
newPoly.poly = n;

Superficially seem like they would be the culprit of your trouble, since you're assigning the 'next' of your newPoly.poly, but then you re-assign your newPoly.poly, and lose that old reference to .next, I think.

Good luck! hope that helps.