Generics: cannot make a static reference to the non-static type

[Victor Thomas]

Okay, I'm just really confused right now... the original signature for the method I'm supposed to write :

public static void reverse(UnordereLinkedList<String> staff)

So silly me trying to show off figured...

public static void reverse(UnorderedLinkedList<T> unorderedList)

Of course this went over like a lead zeppelin, so...

public class UnorderedLinkedList<T> extends LinkedListClass<T> {

	public UnorderedLinkedList(){
		initializeList();
	}

	@Override
	public boolean search(T searchItem) {
		LinkedListNode<T> current;
		boolean found;
		current = first;
		found = false;
		while(current != null && !found){
			if(current.info.equals(searchItem))
				found = true;
			else
				current = current.link;
		}
		return found;
	}

	@Override
	public void insertFirst(T newItem) {
		LinkedListNode<T> newNode;
		newNode = new LinkedListNode<T>(newItem,first);
		first = newNode;
		if(last == null) last = newNode;
		count++;
	}

	@Override
	public void insertLast(T newItem) {
		LinkedListNode<T> newNode;
		newNode = new LinkedListNode<T>(newItem,null);
		if(first == null){
			first = newNode;
			last = newNode;
		}
		else{
			last.link = newNode;
			last = newNode;
		}
		count++;
	}

	@Override
	public void deleteNode(T deleteItem) {
		LinkedListNode<T> current;
		LinkedListNode<T> trailCurrent;
		boolean found;
		if(first == null)
			System.err.println("Cannot delete from an empty list");
		else{
			if(first.info.equals(deleteItem)){
				first = first.link;
				if(first == null) last = null;
				count--;
			}
			else{
				found = false;
				trailCurrent = first;
				current = first.link;
				while(current != null && !found){
					if(current.info.equals(deleteItem))
						found = true;
					else{
						trailCurrent = current;
						current = current.link;
					}
				}
				if(found){
					count--;
					trailCurrent.link = current.link;
					if(last == current)
						last = trailCurrent;
				}
				else
					System.out.println("Item to be deleted is not in list");
			}
		}
	}
	
	public static <T> void reverse(UnorderedLinkedList<T> unorderedList){
		if(unorderedList.first == null) return;
		if(unorderedList.first.link == null) return; 
		LinkedListNode<T> current;// eclipse freaks out here!
		
	}
}

I "think" I have the correct algorithm to reverse the list, I just need to get past this. After googling around I figured that making the method generic would solve most of the problem... LinkedListNode<T> is an inner class of the abstract class LinkedListClass. I could really use some assistance and a good canonical source with examples on generics since this text sucks on the subject. Thanks.

v

[Victor Thomas]

finally googled around some more... I probably shouldn't do it this way, however I'm almost out of time and need to submit this as is. However, it does works...

Complete code:

public interface LinkedListADT<T> extends Cloneable{
	
	public Object clone();
	
	public boolean isEmptyList();
	
	public void initializeList();
	
	public void print();
	
	public int length();
	
	public T front();
	
	public T back();
	
	public boolean search(T searchItem);
	
	public void insertFirst(T newItem);
	
	public void insertLast(T newItem);
	
	public void deleteNode(T deleteItem);
}

import java.util.NoSuchElementException;


public abstract class LinkedListClass<T> implements LinkedListADT<T> {
	
	protected LinkedListNode<T> first;
	protected LinkedListNode<T> last;
	protected int count;
	
	protected class LinkedListNode<T> implements Cloneable{

		public T info;
		public LinkedListNode<T> link;
		
		public LinkedListNode(){
			info = null;
			link = null;
		}
		
		public LinkedListNode(T elem, LinkedListNode<T> ptr){
			info = elem;
			link = ptr;
		}
		
		public Object clone(){
			LinkedListNode<T> copy = null;
			try{
				copy = (LinkedListNode<T>)super.clone();
			}
			catch(CloneNotSupportedException e){
				return null;
			}
			return copy;
		}
		
		public String toString(){
			return info.toString();
		}
	}//end LinkedListNode()~
	
	public class LinkedListIterator<T>{
		
		protected LinkedListNode<T> current;
		protected LinkedListNode<T> previous;
		
		public LinkedListIterator(){
			current = (LinkedListNode<T>) first;
			previous = null;
		}
		
		public void reset(){
			current = (LinkedListNode<T>) first;
			previous = null;
		}
		
		public T next(){
			if(!hasNext()) throw new NoSuchElementException();
			LinkedListNode<T> temp = current;
			previous = current;
			current = current.link;
			return temp.info;
		}
		
		public boolean hasNext(){
			return (current != null);
		}
		
		public void remove(){
			if(current == null) throw new NoSuchElementException();
			if(current == first){
				first = first.link;
				current = (LinkedListNode<T>)first;
				previous = null;
				if(first == null) last = null;
			}
			else{
				previous.link = current.link;
				if(current == last){
					last = first;
					while(last.link != null)
						last = last.link;
				}
				current = current.link;
			}
			count--;
		}
		
		public String toString(){
			return current.info.toString();
		}
	}// end LinkedListIterator()~
	
	public LinkedListClass(){
		first = null;
		last = null;
		count = 0;
	}
	
	public boolean isEmptyList(){
		return (first == null);
	}
	
	public void initializeList(){
		first = null;
		last = null;
		count = 0;
	}
	
	public void print(){
		LinkedListNode<T> current;
		current = first;
		while(current != null){
			System.out.print(current+" ");
			current = current.link;
		}
	}
	
	public int length(){
		return count;
	}
	
	public T front(){
		return first.info;
	}
	
	public T back(){
		return last.info;
	}
		
	public Object clone(){
		LinkedListClass<T> copy = null;
		try{
			copy = (LinkedListClass<T>)super.clone();
		}
		catch(CloneNotSupportedException e){
			return null;
		}
		if(first != null){
			copy.first = (LinkedListNode<T>)first.clone();
			copy.last = copy.first;
			LinkedListNode<T> current;
			if(first != null) current = first.link;
			else current = null;
			while(current != null){
				copy.last.link = (LinkedListNode<T>)current.clone();
				copy.last = copy.last.link;
				current = current.link;
			}
		}
		return copy;
	}
	
	public abstract boolean search(T searchItem);
	
	public abstract void insertFirst(T newItem);
	
	public abstract void insertLast(T newItem);
	
	public abstract void deleteNode(T deleteItem);
}

public class UnorderedLinkedList<T> extends LinkedListClass<T> {

	public UnorderedLinkedList(){
		initializeList();
	}

	@Override
	public boolean search(T searchItem) {
		LinkedListNode<T> current;
		boolean found;
		current = first;
		found = false;
		while(current != null && !found){
			if(current.info.equals(searchItem))
				found = true;
			else
				current = current.link;
		}
		return found;
	}

	@Override
	public void insertFirst(T newItem) {
		LinkedListNode<T> newNode;
		newNode = new LinkedListNode<T>(newItem,first);
		first = newNode;
		if(last == null) last = newNode;
		count++;
	}

	@Override
	public void insertLast(T newItem) {
		LinkedListNode<T> newNode;
		newNode = new LinkedListNode<T>(newItem,null);
		if(first == null){
			first = newNode;
			last = newNode;
		}
		else{
			last.link = newNode;
			last = newNode;
		}
		count++;
	}

	@Override
	public void deleteNode(T deleteItem) {
		LinkedListNode<T> current;
		LinkedListNode<T> trailCurrent;
		boolean found;
		if(first == null)
			System.err.println("Cannot delete from an empty list");
		else{
			if(first.info.equals(deleteItem)){
				first = first.link;
				if(first == null) last = null;
				count--;
			}
			else{
				found = false;
				trailCurrent = first;
				current = first.link;
				while(current != null && !found){
					if(current.info.equals(deleteItem))
						found = true;
					else{
						trailCurrent = current;
						current = current.link;
					}
				}
				if(found){
					count--;
					trailCurrent.link = current.link;
					if(last == current)
						last = trailCurrent;
				}
				else
					System.out.println("Item to be deleted is not in list");
			}
		}
	}
	
	public static <T> void reverse(UnorderedLinkedList<T> unorderedList){
		if(unorderedList.first == null) return; // empty list
		if(unorderedList.first.link == null) return; // only one element
		LinkedListClass.LinkedListNode current = unorderedList.first;// go raw...
		unorderedList.first = null;
		while(current != null){
			LinkedListClass.LinkedListNode previous = current;// and again...
			current = current.link;
			previous.link = unorderedList.first;
			unorderedList.first = previous;
		}
		
	}
}

public class UnorderedLinkedListDemo {

	public static void main(String[] args) {
		UnorderedLinkedList<Integer> ints = new UnorderedLinkedList<Integer>();
		int i;String s = "abcdefghijklmnopq";
		for(i=65;i<81;i++){
			ints.insertFirst(new Integer(i));// stack
		}
		ints.print();
		System.out.println();
		UnorderedLinkedList<String> strs = new UnorderedLinkedList<String>();
		for(i=0;i<s.length()-1;i++){
			strs.insertLast(""+s.charAt(i)+s.charAt(i+1));// queue
		}
		strs.print();
		System.out.println("\nDeleting Nodes : ");
		ints.deleteNode(65);
		strs.deleteNode("pq");
		ints.print();
		System.out.println();
		strs.print();
		System.out.println("\nReversing List : ");
		ints.reverse(ints);
		strs.reverse(strs);
		ints.print();
		System.out.println();
		strs.print();
	}

}

If someone has a better solution, please post it! Again, if anyone could suggest a good tutorial on generics, I'd really appreciate it. If no one replies by tomorrow, I'll mark this as resolved. BTW, this is not the way I'd do an implementation of a Linked List ... Thanks in advance.

v

[Victor Thomas]

Okay, I think I have something better now, (at least eclipse quit complaining...)

public class UnorderedLinkedList<T> extends LinkedListClass<T> {

	public UnorderedLinkedList(){
		initializeList();
	}

	@Override
	public boolean search(T searchItem) {
		LinkedListNode<T> current;
		boolean found;
		current = first;
		found = false;
		while(current != null && !found){
			if(current.info.equals(searchItem))
				found = true;
			else
				current = current.link;
		}
		return found;
	}

	@Override
	public void insertFirst(T newItem) {
		LinkedListNode<T> newNode;
		newNode = new LinkedListNode<T>(newItem,first);
		first = newNode;
		if(last == null) last = newNode;
		count++;
	}

	@Override
	public void insertLast(T newItem) {
		LinkedListNode<T> newNode;
		newNode = new LinkedListNode<T>(newItem,null);
		if(first == null){
			first = newNode;
			last = newNode;
		}
		else{
			last.link = newNode;
			last = newNode;
		}
		count++;
	}

	@Override
	public void deleteNode(T deleteItem) {
		LinkedListNode<T> current;
		LinkedListNode<T> trailCurrent;
		boolean found;
		if(first == null)
			System.err.println("Cannot delete from an empty list");
		else{
			if(first.info.equals(deleteItem)){
				first = first.link;
				if(first == null) last = null;
				count--;
			}
			else{
				found = false;
				trailCurrent = first;
				current = first.link;
				while(current != null && !found){
					if(current.info.equals(deleteItem))
						found = true;
					else{
						trailCurrent = current;
						current = current.link;
					}
				}
				if(found){
					count--;
					trailCurrent.link = current.link;
					if(last == current)
						last = trailCurrent;
				}
				else
					System.out.println("Item to be deleted is not in list");
			}
		}
	}
	/**
	 *  reverse() is a 'generic' method, corrected for unsafe type checking
	 */
	public static <T> void reverse(UnorderedLinkedList<T> unorderedList){
		if(unorderedList.first == null) return; 
		if(unorderedList.first.link == null) return; 
		LinkedListClass<T>.LinkedListNode<T> current = unorderedList.first;// success?
		unorderedList.first = null;
		while(current != null){
			LinkedListClass<T>.LinkedListNode<T> previous = current;
			current = current.link;
			previous.link = unorderedList.first;
			unorderedList.first = previous;
		}	
	}
}

And...

public class UnorderedLinkedListDemo {

	public static void main(String[] args) {
		UnorderedLinkedList<Integer> ints = new UnorderedLinkedList<Integer>();
		int i;String s = "abcdefghijklmnopq";
		for(i=65;i<81;i++){
			ints.insertFirst(new Integer(i));
		}
		System.out.println("Printing Linked Lists : ");
		ints.print();
		System.out.println();
		UnorderedLinkedList<String> strs = new UnorderedLinkedList<String>();
		for(i=0;i<s.length()-1;i++){
			strs.insertLast(""+s.charAt(i)+s.charAt(i+1));		}
		strs.print();
		System.out.println("\nDeleting Nodes : ");
		ints.deleteNode(65);
		strs.deleteNode("pq");
		ints.print();
		System.out.println();
		strs.print();
		System.out.println("\nReversing Lists : ");
		UnorderedLinkedList.reverse(ints);// I can't believe that I didn't catch this earlier...
		UnorderedLinkedList.reverse(strs);
		ints.print();
		System.out.println();
		strs.print();
	}
}

Don't know what I did right, but at least now I can safely submit the code. I really do wish someone could explain to me the why this is 'better' than my original. I will still wait to mark this as resolved.

v

[Paul Clapham]

Well, you have about 90 lines of code in each of them. I could scroll back and forth and try to identify the differences, but that's awfully difficult and inconvenient. And you never really did say what you didn't like about the first attempt (and by the way, that stat/non-static issue has nothing to do with generics, and vice versa). So I'm sorry, I'm not going to do that.

On the other hand if you explained what you did, somebody might be able to explain why that was a good thing to do.

[Victor Thomas]

Paul Clapham wrote:Well, you have about 90 lines of code in each of them...

Sorry for the amount of code contained herein. Like I expressed earlier, I had to add code to an existing project. I would never write this of my own free will...

Paul Clapham wrote:And you never really did say what you didn't like about the first attempt

What I was concerned with was the what I thought was the problem which happened to by the real problem as you surmised: scope

Paul Clapham wrote: (and by the way, that stat/non-static issue has nothing to do with generics, and vice versa).

I was just watching the tube and realized that the issue was that LinkedListNode is an inner class and that's why it worked when I :

LinkedListClass.LinkedListNode current = unorderedList.first;//

So my original mistake was try to instantiate the inner class. Once I finished kicking myself in the butt, I decided that I shouldn't wait until almost the last minute to complete an assignment again.

Paul Clapham wrote:So I'm sorry, I'm not going to do that.

No worries! I sometimes wear myself down and don't see the problem until I let go. I always hope that a better pair of eyes can spot my insanity quicker than me. I just need to manage my time better...Thanks for your help.

[Alex Hurtt]

Your problem isn't with Generics...your problem was trying to reference a non-static inner class from a static method. You always need an instance of the outer class class to make an instance of a non-static inner class. This can be implicitly done within instance methods because of the 'this' reference...but static code has no 'this' reference...hence to construct an instance of a non-static inner class from a static method you'd have to construct a new outer class first and use that to construct the inner class along the lines of:

Outer.Inner innie = new Outer().new Inner();

(where Inner is a non-static inner class inside Outer and both Outer and Inner are visible to the calling code).