List creation - invisible output problem

Question

the method in question is appendItem(Object obj) in the ObjList class.
The ObjList class:
import java.util.NoSuchElementException;
public class ObjList {
     protected Node              list;   // Link to start of list;
     /** Creates a new (empty) ObjList. */
     public ObjList() {
          this.list = null;
     /** Returns the length of this ObjList. */
     public int length() {
          Node ndcur = this.list;     // Currently scanned node.
          int i = 0;                    // Index of current node nd.
          while (ndcur != null) {
               // Count one more item, and move on to the next one.
               ++ i;  ndcur = ndcur.tail();
          // i is index of the null item at the end of the scan,
          // which is also the number of non-null node links scanned.
          return i;
     /** Inserts the given object at the front of this list. */
     public void prependItem(Object obj) {
            Node n = new Node(obj, list);
            list = n;
     /** Inserts the given object at the end of this list. */
     public void appendItem(Object obj) {
            Node t = new Node(obj, null);
            list.setTail(t);
     /** Returns the item at position i in this list. */
     public Object getItemAt(int i) throws NoSuchElementException {
                Object obj = null;
          return obj;
     /** Inserts the given object into this list at position i
      * (so that the item previously at position i, and any
      * items at later positions, are all moved up by one position).
     public void insertItemAt(Object obj, int i)
     throws NoSuchElementException {
          if (i == 0)
               // "insert at 0" is just "prepend".
               this.prependItem(obj);
          else {
               // ASSERT: 1 <= i;
               // TBD
     /** Deletes the item at position i from this list. */
     public void deleteItemAt(int i) {
          if (this.list == null)
               throw new NoSuchElementException(
                    "deleteItemAt("+i+"): list is empty!");
          // ASSERT: list is non-empty.
          // TBD
     /** Returns a string representation for this list. **/
     public String toString() {
          // Represent the list as one item per line,
          // plus header/footer...
          final String EOL = System.getProperty("line.separator");
          // Use a string buffer to build the result.
          StringBuffer str =
               new StringBuffer("----ObjList:start----"+EOL);
          // Scan the nodes, generating one line for each.
          for (Node nd=this.list; nd!=null; nd=nd.tail())
               str.append(nd.head()).append(EOL);
          str.append("----ObjList:end----"+EOL);
          return str.toString();
     /*########  Node class definition.   ########*/
     /** The list Node class definition is essentially as in
      * the lecture notes.
     protected static class Node {
          private Object      h;          // head
          private Node        t;          // tail link
          public Node(Object hd, Node tl) {
               this.h = hd;  this.t = tl;
          public Object   head() { return this.h; }
          public Node     tail() { return this.t; }
          public void     setTail(Node tl) { this.t = tl; }
}The Main class:
public class IntList extends ObjList implements IntListSpec {
    /** main() -- basic IntList checking method. */
    public static void main(String[] args) {
    IntList intlist = new IntList();
    intlist.prependItem(1);
    intlist.prependItem(2);
    intlist.prependItem(3);
    intlist.appendItem(1);
    intlist.appendItem(2);
    intlist.appendItem(3);
    System.out.println(intlist.toString());
//        // e.g. ...
//          // Create a list of size 1 million -- if this takes a long time
//          // then the constructor that takes an array parameter is
//          // not as efficient as it could be.
//        int[] million = new int[1000 * 1000];
//        System.out.println("List of a million --- start creation.");
//        IntListSpec ilm = new IntList(million);
//        System.out.println("List of a million --- created.");
//        System.out.println();
          // Release the large data items.
//        million = null;
//        ilm = null;
          // etc., etc.
/*########  IntList Constructor and Instance Methods.  ########*/
    /** Creates a new (empty) IntList. */
    public IntList() {
        super();
    /** Creates a new IntList containing the given values, in order. */
    public IntList(int[] values) {
        this();
          // TBD
          // (add successive values from the array into the list, but
          // do it efficiently!)
     /** Inserts value n at the front of this list. */
    public void prependItem(int n) {
   // Delegate this one to our superclass.
        super.prependItem(new Integer(n));
     /** Appends value n at the end of this list. */
    public void appendItem(int n) {
        // Delegate this one to our superclass.
  //      super.appendItem(new Integer(n));
     /** Finds and returns the value at position i in this list. */
    public int getIntAt(int i) {
//        // Delegate this one to our superclass.
      return i;//((Integer)(super.getItemAt(i))).intValue();
     /** Inserts value n at position i in this list. */
    public void insertIntAt(int n, int i) {
        // Delegate this one to our superclass.
  //      super.insertItemAt(new Integer(n), i);
     /** Deletes the value at position i in this list. */
    public void deleteIntAt(int i) {
        // Delegate this one to our superclass.
  //      super.deleteItemAt(i);
     /** Returns a one-line display string for this list. */
    public String toString() {
        // Represent this list as a single-line string
          // (which may be inconvenient when the list is big!).
        StringBuffer str = new StringBuffer("<");
        if (this.list != null) {
            str.append(this.list.head());
               Node cur = this.list.tail();
            while (cur != null) {
                str.append(" " + cur.head());
                    cur = cur.tail();
        str.append(">");
          return str.toString();
}The interface class:
import java.util.NoSuchElementException;
* NB  In the method definitions below; the index i is assumed
* to be non-negative; if it is too big for the given operation
* then a NoSuchElementException should be thrown.
public interface IntListSpec {
    // List operations, as in the "Linked Data Structures"
    // lecture.
     /** Inserts value n at the front of this list. */
    void prependItem(int n);
     /** Appends value n at the end of this list. */
    void appendItem(int n);
     /** Finds and returns the value at position i in this list. */
    int getIntAt(int i) throws NoSuchElementException;
     /** Inserts value n at position i in this list. */
    void insertIntAt(int n, int i) throws NoSuchElementException;
     /** Deletes the value at position i in this list. */
    void deleteIntAt(int i) throws NoSuchElementException;
     /** Returns a one-line display string for this list. */
    String toString();
}My problem, as implied by the subject, is that when outputting the contents of this list after the 6 operations, only prependItem is being shown. Bear in mind that we were given all the code (degree course at uni) other than the prepend method, the append method, and all other places marked 'TBD'.
Any help would be appreciated. I think what is happening is that 'list' doesn't know it has these extra items on the end, although I thought list.setTail(t) should have sorted that.
Anyhow, many thanks in advance.

Answer 1

You're not linking the previous tail with this new item you're trying to append.
This is not a Java related question. It is an algorithm question. You don't have your algorithm correct, and we're not here to do your homework for you.