先感谢论坛的朋友们教我做代码呀，这个问题前天在发过，可能问的时候写的不明确，没有得到满意的答案，现在我改的更详细了些，还希望黑马同志们帮我解决呀

1. 
   
2. /**
   
3. 分析比较器的排序原理：
   
4. 二叉树排序算法，中序遍历
   
5. 二叉树排序的基本原理：第一个内容作为根节点，后面值小，则放在跟节点左子树，若大，右子树
   
6. 中序遍历：左子树——根节点——右子树
   
7. Integer类本身已经实现了Comparable接口
   
8. 
   
9. 要求：基于Comparable接口实现的二叉树操作
   
10.     对8、3、3、10、9、1、5、5进行排序？？？？
    
11. 思路：
    
12. 1.首先，定义一个二叉树的类BinaryTree{}
    
13. 2.在类中声明一个节点类（内部类）
    
14. 3.节点类中声明节点的具体内容（Comparable数据）、节点的左子树、节点的右子树
    
15.   取得新元素的值public Node(Comparable data){}
    
16. 4.声明根元素root，在Node类外
    
17. 5.定义一个传入新数的方法add(Comparable data){}
    
18. 6.每传入一个新数就声明一个根节点
    
19.   判断传入的数（if语句）是否是第一个数，若是则设置成根元素，
    
20.   若不是，则确定是放在左子树还是右子树（调用addNode()方法）
    
21.   
    
22. 7.Node类内定义一个将值加入节点的的方法public void addNode(Node newNode){}，
    
23.   在此方法中确定加入的值是放在左子树还是右子树（if语句）
    
24. 8.输出节点的方法print(){}，调用9
    
25. 9.Node类内，采用中序遍历方法输出，左子树——根节点——右子树
    
26. 10.主函数：
    
27.    声明一个二叉树对象：bt
    
28.    加入N个元素（其中有重复的元素）
    
29.    打印输出
    
30. 注：谁有数据谁具有方法，内部类Node中有加入的数放入节点的方法public void addNode(Node newNode){}
    
31.      和节点输出的方法printNode(){}
    
32. */
    
33. class BinaryTree         //首先，定义一个二叉树的类BinaryTree{}
    
34. {
    
35. class Node          //在类中声明一个节点类（内部类）
    
36. {
    
37.   private Comparable data;     //节点类中声明节点的具体内容（Comparable数据）、
    
38.   private Node left;       //节点的左子树、
    
39.   private Node right;       //节点的右子树
    
40.   public Node(Comparable data){    //取得新元素的值public Node(Comparable data){}
    
41.    this.data=data;
    
42.   }
    
43.   public void addNode(Node newNode){ //Node类内定义一个将值加入节点的的方法public void addNode(Node newNode){}，
    
44.    if (newNode.data.compareTo(this.data)<0)  //比较加入的数与当前节点的数的大小，
    
45.    {  
    
46.     if (this.left==null)      //若小且没有左子树，则放在左子树
    
47.     {
    
48.      this.left=newNode;
    
49.     }else{
    
50.      this.left.addNode(newNode);             //否则，以左子树为节点继续向下判断
    
51.     }
    
52.    }
    
53.    if (newNode.data.compareTo(this.data)>=0)  //比较加入的数与当前节点的数的大小，
    
54.    {  
    
55.     if (this.right==null)      //若小且没有右子树，则放在右子树
    
56.     {
    
57.      this.right=newNode;
    
58.     }else{
    
59.      this.right.addNode(newNode);             //否则，以右子树为节点继续向下判断
    
60.     }
    
61.    }
    
62.   }
    
63.   public void printNode(){       //Node类内，采用中序遍历方法输出，左子树——根节点——右子树
    
64.    if (this.left!=null)
    
65.    {
    
66.     this.left.printNode();
    
67.    }
    
68.    System.out.print(this.data+"\t");
    
69.    if (this.right!=null)
    
70.    {
    
71.     this.right.printNode();
    
72.    }
    
73.   }
    
74.   
    
75. }
    
76. private Node root;         //声明根元素root，在Node类外
    
77. public void add(Comparable data){     //定义一个传入新数的方法add(Comparable data){}
    
78.   Node newNode=new Node(data);      //每传入一个新数就声明一个根节点
    
79.   //newNode.data=data;        
    
80.   if(root==null){
    
81.   root=newNode;         // 判断传入的数（if语句）是否是第一个数，若是则设置成根元素，
    
82.   }else{
    
83.    root.addNode(newNode);      //若不是，则确定是放在左子树还是右子树（调用addNode()方法）
    
84.   }
    
85. }
    
86. public void print(){        
    
87.   this.root.printNode();       //输出节点的方法print(){}，调用9
    
88. }
    
89. }
    
90. public class ComparableDemo02
    
91. {
    
92. public static void main(String[] args)
    
93. {
    
94.   BinaryTree bt=new BinaryTree();    //声明一个二叉树对象：bt
    
95.   bt.add(8);
    
96.   bt.add(3);
    
97.   bt.add(3);          //加入N个元素（其中有重复的元素）
    
98.   bt.add(10);
    
99.   bt.add(9);
    
100.   bt.add(1);
     
101.   bt.add(5);
     
102.   bt.add(5);
     
103.   System.out.println("排序之后的结果");
     
104.   bt.print();
     
105.   
     
106. }
     
107. }
     

复制代码

编译后：

泛型安全问题吧,你用了 Comparable没指定泛型

错误在90行 ：类ComparableDemo02是公共的 ，应在名为ComparableDemo02.java的文件中声明
public class  ComparableDemo02所以文件名必须和类名一致   

这个提示是在JDK1.5版本后泛型出现后，对不安全的语句进行的提示，就是说Comparable和Comparator都是泛型类，只要进行了泛型声明就没问题了。
将所有Cmparable接口的泛型都定义为Integer：Comparable<Integer>，
再将(Integer)this.data) < 0和(Integer)this.data) >= 0强转就OK了。

这个就是泛型定义的问题
集合在1.5之后，如果你不添加泛型都会有这个提示的
这个不是错误，就是一个提示

这种问题最伤心了，让人如何一点一点地看！