Need help with generic class with comparable type

Question

Hi. I'm at University, and I have some coursework to do on writing a generic class which offers ordered binary trees of items which implement the comparable interface.
I cant get the code to compile which I have written.
I get the error: OBTComparable.java uses unchecked or unsafe operations
this is the more detailed information of the error when I compile with -Xlint:unchecked
OBTComparable.java:62: warning: [unchecked] unchecked call to insert(OBTType) as
a member of the raw type OBTComparable
left.insert(insertValue);
^
OBTComparable.java:64: warning: [unchecked] unchecked call to insert(OBTType) as
a member of the raw type OBTComparable
right.insert(insertValue);
^
OBTComparable.java:75: warning: [unchecked] unchecked call to find(OBTType) as a
member of the raw type OBTComparable
return left.find(findValue);
^
OBTComparable.java:77: warning: [unchecked] unchecked call to find(OBTType) as a
member of the raw type OBTComparable
return right.find(findValue);
^
and here is my code for the class
public class OBTComparable<OBTType extends Comparable<OBTType>>
  // A tree is either empty or not
  private boolean empty;
  // If the tree is not empty then it has
  // a value, a left and a right.
  // These are not used it empty == true
  private OBTType value;
  private OBTComparable left;
  private OBTComparable right;
  // Create an empty tree.
  public OBTComparable()
    setEmpty();
  } // OBTComparable
  // Make this tree into an empty tree.
  private void setEmpty()
    empty = true;
    value = null; // arbitrary
    left = null;
    right = null;
  } // setEmpty
  // See if this is an empty (Sub)tree.
  public boolean isEmpty()
  { return empty; }
  // Get the value which is here.
  public OBTType getValue()
  { return value; }
  // Get the left sub-tree.
  public OBTComparable getLeft()
  { return left; }
  // Get the right sub-tree.
  public OBTComparable getRight()
  { return right; }
  // Store a value at this position in the tree.
  private void setValue(OBTType requiredValue)
    if (empty)
      empty = false;
      left = new OBTComparable<OBTType>(); // Makes a new empty tree.
      right = new OBTComparable<OBTType>(); // Makes a new empty tree.
    } // if
    value = requiredValue;
  } // setValue
  // Insert a value, allowing multiple instances.
  public void insert(OBTType insertValue)
    if (empty)
      setValue(insertValue);
    else if (insertValue.compareTo(value) < 0)
      left.insert(insertValue);
    else
      right.insert(insertValue);
  } // insert
  // Find a value
  public boolean find(OBTType findValue)
    if (empty)
      return false;
    else if (findValue.equals(value))
      return true;
    else if (findValue.compareTo(value) < 0)
      return left.find(findValue);
    else
      return right.find(findValue);
  } // find
} // OBTComparableI am unsure how to check the types of OBTType I am comparing, I know this is the error. It is the insert method and the find method that are causing it not to compile, as they require comparing one value to another. How to I put the check in the program to see if these two are of the same type so they can be compared?
If anyone can help me with my problem that would be great!
Sorry for the long post, I just wanted to put in all the information I know to make it easier for people to answer.
Thanks in advance
David

Answer 1

I have good news and undecided news.
First the good news. Your code has compiled. Those are warnings not errors. A warning is the compiler's way of saying "I understand what you are asking but maybe you didn't fully think through the consequences and I just thought I would let you know that...[something] "
In this case it's warning you that you aren't using generics. But like I said this isn't stopping it from compiling.
The undecided news is the complier is warning you about not using generics. Are you supposed to use generics for this assignment. My gut says no and if that's true then you have no problem. If you are supposed to use generics well then you have some more work.