Cannot make a static reference to the non-static type

[Meg Berg]

Hi,

I am working on using linked lists. My project will include a UI, but I am trying to check that my class is doing what I expect it to but adding a main method and printing to the console. My object is AntiqueInfo and I am using my Node class to manage the list. When I try to add new AntiqueInfo items in the Node class in the main method, I am getting the error: Cannot make a static reference to the non-static type

The same code works in the AntiqueInfo class and I just don't understand what I did in the Node class that makes the AntiqueInfo not static.

Here's my code:

public class AntiqueInfo {
    

        private String name;
        private double price;
        

      

        public AntiqueInfo(String na, double pr) {

            name = new String(na);
            price = pr;
            
        }

       
        public String getName() {
            return name;
        }

       
        public double getPrice() {
            return price;
        }

       

        public String toString() {
            return name + "\t" + price;
        }

        /**
         * boolean to see if two items are the same, compares strings and returns
         * false if value does not equal 0
         * 
         * @return boolean
         */
        // precondition name is defined
        // postcondition AntiqueInfo detail has been defined is equal or unequal
        public boolean equals(Object obj) {
            if ( obj instanceof AntiqueInfo ) {
                AntiqueInfo detail = (AntiqueInfo) obj;
                return (this.name.toLowerCase()
                    .compareTo(detail.name.toLowerCase()) == 0);
            } else
                return false;
        }

        /**
         * clone of Antique items
         * 
         * @return returns clone of Antique info and clone of attributes
         */

       
        public void setName(String name) {
            this.name = name;
        }

        public void setRating(Double price) {
            this.price = price;
        }

        

        /**
         * compares the names of two Antique items and returns the int valute of
         * the difference of the two strings
         * 
         * @return int value of difference in strings
         */
        // precondition AntiqueInfo name is a string
        // postconition returns int value of difference between two strings
        public int compareTo(AntiqueInfo AntiqueInfo) {

            int compareToValue = this.getName().compareToIgnoreCase(
                AntiqueInfo.getName());

            return compareToValue;
        }

        

        public static void main(String[] args) {

            AntiqueInfo antq1 = new AntiqueInfo("Telephone, Gold, circa 1890", 149.76);
            AntiqueInfo antq2 = new AntiqueInfo("Ab", 4);

            System.out.println(antq1.compareTo(antq2));

            System.out.println(antq1.toString() + "\n" + antq2.toString());

            if ( antq1.equals(antq2) )
                System.out.println("they are equal");
            else
                System.out.println("They are not the same");

        }

    }

public class Node<AntiqueInfo> {

    private Node <AntiqueInfo>link;
    private Node <AntiqueInfo>tail;
    private Node <AntiqueInfo>head;
    private AntiqueInfo data2;
    
    
    public Node(AntiqueInfo initialData, Node<AntiqueInfo> initialLink) {
        data2 = initialData;
        link = initialLink;
    }
    
    public AntiqueInfo getData() {
        return data2;
    }
    
    public Node<AntiqueInfo> getLink() {
        return link;
    }
    
    public void setData(AntiqueInfo newData) {
        
        data2 = newData;
    }
    
    public void setLink (Node <AntiqueInfo>newLink) {
        link = newLink;
    }
    
    public void addNode (AntiqueInfo newData) {
        
        head = new Node<AntiqueInfo>(newData, head);
    }
    
    public void removeNode() {
        head = head.getLink();
    }
    
    public void removeNodeAfter() {
        link = link.link;
    }
    
    public void addNodeAfter(AntiqueInfo element) throws OutOfMemoryError{
        link = new Node<AntiqueInfo>(element, link);
        
    }
    
    public int listLength(Node<AntiqueInfo> head) {
        
        Node<AntiqueInfo> cursor;        
        int answer;
        answer = 0;
        
        for (cursor = head; cursor != null; cursor = cursor.link)
            answer++;
        return answer;
    }
    
    public  Node<AntiqueInfo> listSearch (Node<AntiqueInfo>head, 
        Node<AntiqueInfo>target) {

        Node<AntiqueInfo> cursor;

        for (cursor = head; cursor != null; cursor=cursor.link) 
            if (target == cursor.data2)
                return cursor;

        return null;

    }
    
    public Node<AntiqueInfo> listPosition(Node<AntiqueInfo> head, int position) {
        
        Node<AntiqueInfo> cursor;
        int i;
        
        if(position<=0)
            throw new IllegalArgumentException("position is not positive, fool");
        
        cursor = head;
        for (i=1; (i<position) && (cursor !=null); i++);
            cursor = cursor.link;
        
        return cursor;
    }
    
    public Node<AntiqueInfo> listCopy(Node<AntiqueInfo> source) throws OutOfMemoryError {
        Node<AntiqueInfo> copyHead;
        Node<AntiqueInfo> copyTail;
        
        if (source == null)
            return null;
        
        copyHead = new Node<AntiqueInfo>(source.data2, null);
        copyTail = copyHead;
        
        while (source.link !=null) {
            source = source.link;
            copyTail.addNodeAfter(source.data2);
            copyTail = copyTail.link;
        }
        return copyHead;
        
        
    }
    
    public Node<AntiqueInfo> [] listCopyWithTail(Node<AntiqueInfo> source) {
        
        Node<AntiqueInfo> copyHead;
        Node<AntiqueInfo> copyTail;
        Node<AntiqueInfo>[] answer = new Node[2];
        
        if (source ==null)
            return answer;
        
        copyHead = new Node<AntiqueInfo>(source.data2, null);
        copyTail = copyHead;
        
        while (source.link != null) {
            source = source.link;
            copyTail.addNodeAfter(source.data2);
            copyTail = copyTail.link;
        }
        
        answer[0] = copyHead;
        answer[1] = copyTail;
        
        return answer;
        
    }
    
    public Node<AntiqueInfo> [] listPart(Node<AntiqueInfo> start, Node<AntiqueInfo> end) {
        
        Node<AntiqueInfo> copyHead;
        Node<AntiqueInfo> copyTail;
        
        Node<AntiqueInfo>[] answer = new Node[2];
        
        if (start == null)
            throw new IllegalArgumentException("start is null");
        if (end == null)
            throw new IllegalArgumentException("end is null");
        
        copyHead = new Node<AntiqueInfo>(start.data2, null);
        copyTail = copyHead;
        
        while (start != end) {
            start = start.link;
            if(start ==null)
                throw new IllegalArgumentException("end node was not found on the list");
            copyTail.addNodeAfter(start.data2);
            copyTail = copyTail.link;
        }
        
        answer[0] = copyHead;
        answer[1] = copyTail;
        
        return answer;
        
        
    }
    
    
    public static void main(String[] args) {

        AntiqueInfo antq3 = new AntiqueInfo("Telephone, Gold, circa 1890", 149.76);
        AntiqueInfo antq4 = new AntiqueInfo("Ab", 4);
        System.out.println("something");
        
       
    }
    
}

[Steve Luke]

What is the exact error message you get? What are the package and import statements you use at the top of the classes?

[Jelle Klap]

This confusion is due to a naming conflict between the type parameter of the Node class and the name of the AntiqueInfo class. It is the type parameter that the main method of the Node class refers to. Try renaming the type parameter of the Node class to T. That will solve the naming conflict and allow you to refer to the AntiqueInfo class by it's simple name from the main method of the Node class. You may have to add an import for the AntiqueInfo class in the Node class first though, depending on whether or not they are in the same package. Please refer to the tutorial section on generic types (and the generics tutorial as a whole) for more information.

[Campbell Ritchie]

Why are you using compareTo and not equals() in your equals() method?