D:\>javadoc ArrayTool -d myhelp -author -version
正在装入软件包 ArrayTool 的源文件...
javadoc: 警告 - 没有软件包 ArrayTool 的源文件
正在构造 Javadoc 信息...
javadoc: 警告 - 没有软件包 ArrayTool 的源文件
javadoc: 错误 - 找不到可以文档化的公共或受保护的类。
1 错误
2 警告
程序编写如下：我的程序哪里出错了，求各位牛人给予解答。

1. **
   
2. *这个程序主要就是为了提供一些列的数组操作，包括取最值，排序，查找。
   
3. * @author 张三
   
4. * @version 1.2
   
5. *
   
6. */
   
7. public class ArrayTool {
   
8.         /**
   
9.          * 获取数组中的最大值
   
10.          * @param arr int型数组
    
11.          * @return 最大值max
    
12.          */
    
13.                 public static int getMax(int[] arr){
    
14.                        
    
15.                         int max=arr[0];
    
16.                         for(int i=1;i<arr.length;i++){
    
17.                                 if(max<arr[i])
    
18.                                 {
    
19.                                         max=arr[i];
    
20.                                 }
    
21.                         }
    
22.                         return max;
    
23.                 }
    
24.                 /**
    
25.                  * 获取数组中的最小值
    
26.                  * @param arr int型数组
    
27.                  * @return 最小值min
    
28.                  */
    
29.                 public static int getMin(int[] arr){
    
30.                        
    
31.                         int min=arr[0];
    
32.                         for(int i=1;i<arr.length;i++){
    
33.                                 if(min>arr[i])
    
34.                                 {
    
35.                                         min=arr[i];
    
36.                                 }
    
37.                         }
    
38.                         return min;
    
39.                 }
    
40.                 /**
    
41.                  * 对数组进行排序，一般排序方法
    
42.                  * @param arr int型数组
    
43.                  */
    
44.                 public static void selectSort(int[] arr){
    
45.                         for(int i=0;i<arr.length-1;i++)
    
46.                         {
    
47.                                 for(int y=i+1;y<arr.length;y++)
    
48.                                 {
    
49.                                         if(arr[i]>arr[y]){
    
50.                                                 alternate(arr,i,y);
    
51.                                         }
    
52.                                 }
    
53.                         }
    
54.                 }
    
55.                 private static void alternate(int[] arr,int i, int j) {
    
56.                         int temp=arr[i];
    
57.                         arr[i]=arr[j];
    
58.                         arr[j]=temp;
    
59.                        
    
60.                 }
    
61.                 /**
    
62.                  * 对数组进行排序，冒泡排序方法
    
63.                  * @param arr int型数组
    
64.                  */
    
65.                 public static void bubbleSort(int[] arr)
    
66.                 {
    
67.                         for(int x=0;x<arr.length-1;x++){
    
68.                                 for(int y=0;y<arr.length-1-1;y++)
    
69.                                 {
    
70.                                         if(arr[y]>arr[y+1])
    
71.                                         {
    
72.                                                 alternate(arr,y,y+1);
    
73.                                         }
    
74.                                 }
    
75.                         }
    
76.                 }
    
77.                 /**
    
78.                  * 打印数组到控制台上，打印结果[element1,element2,...]
    
79.                  * @param arr
    
80.                  */
    
81.                 public static void printArray(int[] arr)
    
82.                 {
    
83.                         System.out.print("[");
    
84.                         for(int i=0;i<arr.length;i++)
    
85.                         {
    
86.                                 if(i!=arr.length-1)
    
87.                                         System.out.print(arr[i]+",");
    
88.                                 else
    
89.                                         System.out.print(arr[i]);
    
90.                         }
    
91.                         System.out.print("]");
    
92.                 }
    
93.                 /**
    
94.                  * 在数组中进行数据查找
    
95.                  * @param arr int型数组
    
96.                  * @param key  要查找的数据
    
97.                  * @return 数据所在的数组位置
    
98.                  *         -1表示没有找到，此数据在数组中不存在
    
99.                  */
    
100.                 public static int generalSearch(int[] arr,int key){
     
101.                         for(int i=0;i<arr.length;i++){
     
102.                                 if(arr[i]==key)
     
103.                                 {
     
104.                                         return i;
     
105.                                 }
     
106.                         }
     
107.                         return -1;
     
108.                 }
     
109.                 /**
     
110.                  * 在数组中进行数据查找，折半查找法，值针对有序数组
     
111.                  * @param arr int型数组
     
112.                  * @param key  要查找的数据
     
113.                  * @return 数据所在的数组位置
     
114.                  *         -1表示没有找到，此数据在数组中不存在
     
115.                  */
     
116.                 public static int halfSearch(int[] arr, int key){
     
117.                         int max=arr.length;
     
118.                         int min=0;
     
119.                         int mid;
     
120.                         while(min<=max)
     
121.                         {
     
122.                                 mid=(min+max)>>1;
     
123.                                 if(arr[mid]>key){
     
124.                                         max=mid;
     
125.                                 }
     
126.                                 else if(arr[mid]<key){
     
127.                                         min=mid;
     
128.                                 }
     
129.                                 else
     
130.                                         return mid;
     
131.                         }
     
132.                         return -1;
     
133.                 }
     
134. }

复制代码

1，代码的第一行应该是：/**
2，命令应该这样写：javadoc ArrayTool.java -d myhelp -version -author

哦，那个是漏复制了，我本来是写的有的，呵呵呵

你是不是这样编译的呢！
javadoc 目录地址 ArrayTool.java
正确如下：javadoc -d 目录地址 ArrayTool.java

如果没有加-d是不能指定目录的，但是如果加了-d就一定要加上输出目录

韩新凯 发表于 2012-4-22 21:51
1，代码的第一行应该是：/**
2，命令应该这样写：javadoc ArrayTool.java -d myhelp -version -author ...

谢谢，运行成功了，呵呵呵

黄或俊 发表于 2012-4-22 21:56
你是不是这样编译的呢！
javadoc 目录地址 ArrayTool.java
正确如下：javadoc -d 目录地址 ArrayTool.java

谢谢了了

马东华 发表于 2012-4-22 22:08
谢谢，运行成功了，呵呵呵

不用客气

你可能多了*号了，修改后的你看看，我只是把你多余的星号去了。
还有命令错了  应该是javadoc -d myhelp -author -version ArrayTool.java



/**
这个程序主要就是为了提供一些列的数组操作，包括取最值，排序，查找。
@author 张三
@version 1.2

*/



public class Demo
{
          /**
          获取数组中的最大值
          @param arr int型数组
          @return 最大值max
         */
        public static int getMax(int[] arr)
        {
                int max = 0;
                for(int x=1; x<arr.length; x++)
                {
                        if(arr[x]>arr[max])
                                max = x;
                }
                return arr[max];
        }
        
          /**
                  获取数组中的最小值
                  @param arr int型数组
                  @return 最小值min
                 */
        public static int getMin(int[] arr)
        {
                int min = 0;
                for(int x=1; x<arr.length; x++)
                {
                        if(arr[x]<arr[min])
                                min = x;
                }
                return arr[min];
        }
         /**
                  对数组进行排序，一般排序方法
                  @param arr int型数组
                 */
        public static void selectSort(int[] arr)
        {
                for (int x=0; x<arr.length-1 ; x++ )
                {
                        for(int y=x+1; y<arr.length; y++)
                        {
                                if(arr[x]>arr[y])
                                {
                                        swap(arr,x,y);
                                }
                        }
                }
        }
             /**
                  对数组进行排序，冒泡排序方法
                  @param arr int型数组
                 */
        public static void bubbleSort(int[] arr)
        {
                for (int x=0; x<arr.length-1 ; x++ )
                {
                        for(int y=0; y<arr.length-x-1; y++)
                        {
                                if(arr[y]>arr[y+1])
                                {
                                        swap(arr,y,y+1);
                                }
                        }
                }
        }
        /**
        给数组中元素进行位置的置换。
        @param arr  接收一个int类型的数组。
        @param a 要置换的位置
        @param b 要置换的位置
        */
        private  static void swap(int[] arr,int a,int b)
        {
                int temp = arr[a];
                arr[a] = arr;
                arr = temp;
        }
            /**
                 打印数组到控制台上，打印结果[element1,element2,...]
                  @param arr
                 */
        public static void printArray(int[] arr)
        {
                System.out.print("[");
                for(int x=0; x<arr.length; x++)
                {
                        if(x!=arr.length-1)
                                System.out.print(arr[x]+", ");
                        else
                                System.out.println(arr[x]+"]");
                }
        }
     /**
                  在数组中进行数据查找
                  @param arr int型数组
                  @param key  要查找的数据
                  @return 数据所在的数组位置
                          -1表示没有找到，此数据在数组中不存在
                 */
                public static int generalSearch(int[] arr,int key){
                        for(int i=0;i<arr.length;i++){
                                if(arr==key)
                                {
                                        return i;
                                }
                        }
                        return -1;
                }
  /**
                  在数组中进行数据查找，折半查找法，值针对有序数组
                  @param arr int型数组
                  @param key  要查找的数据
                  @return 数据所在的数组位置
                          -1表示没有找到，此数据在数组中不存在
                 */
                public static int halfSearch(int[] arr, int key){
                        int max=arr.length;
                        int min=0;
                        int mid;
                        while(min<=max)
                        {
                                mid=(min+max)>>1;
                                if(arr[mid]>key){
                                        max=mid;
                                }
                                else if(arr[mid]<key){
                                        min=mid;
                                }
                                else
                                        return mid;
                        }
                        return -1;
                }
}

类必须是public修饰
完了，此贴未被版主看见，顶顶