静态的应用
每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，一边服用
虽然可以通过建立ArrayTool的对象来使用这些工具方法，对数组进行操作
     但是，我们发现了问题：
    1，对象是用于封装数组的，可是ArrayTool对象并未封装特有数据。、
    2，操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
   此时，就考虑让程序更严谨，是不需要对象的
   可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可* 当方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的
   为了更严谨，强制使该类不能建立对象
   可以通过将构造函数私有化来完成


将ArrayTool.class文件发送给其他人，其他人只需要将该文件设置到classpath路径下，就可以使用该工具类
  但还是，很遗憾，该类中定义了多少个方法，对方并不清楚，因为该类并没有使用说明书
  所以开始制作说明书，java的说明书通过文档注释来完成

1. /**
   
2. * 这是一个可以对数组进行操作的工具类，该类中提供了获取最值，排序等功能
   
3. *
   
4. * @author Hades
   
5. * @version v1.1
   
6. */
   
7. public class ArrayTool
   
8. {
   
9.         /**
   
10.          * 空参数构造函数
    
11.          */
    
12.         ArrayTool(){}
    
13.         /**
    
14.          * 获取一个整型数组中的最大值
    
15.          *
    
16.          * @param arr 接收一个int类型的数组
    
17.          * @return 会返回一个该数组中的最大值
    
18.          */
    
19.         public static int getMax(int[] arr)//寻找最大值
    
20.         {
    
21.                 int max = 0;
    
22.                 for (int x=1;x<arr.length;x++)
    
23.                 {
    
24.                         if (arr[x]>arr[max])
    
25.                                 max = x;
    
26.                 }
    
27.                 return arr[max];
    
28.         }
    
29.         /**
    
30.          * 获取一个整型数组中的最小值
    
31.          *
    
32.          * @param arr 接收一个int类型的数组
    
33.          * @return 会返回一个该数组中的最小值
    
34.          */
    
35.         public static int getMin(int[] arr)//寻找最小值
    
36.         {
    
37.                 int min = 0;
    
38.                 for (int x=1;x<arr.length;x++)
    
39.                 {
    
40.                         if (arr[x]<arr[min])
    
41.                                 min = x;
    
42.                 }
    
43.                 return arr[min];
    
44.         }
    
45.         /**
    
46.          * 对数组进行选择排序
    
47.          * @param arr 接收一个int类型的数组
    
48.          */
    
49.         public static void selectSort(int[] arr)//选择排序
    
50.         {
    
51.                 for (int x=0;x<arr.length-1;x++)
    
52.                 {
    
53.                         for(int y=x+1;y<arr.length;y++)
    
54.                         {
    
55.                                 if(arr[x]>arr[y])
    
56.                                 {
    
57.                                         swap(arr,y,y+1);
    
58.                                 }
    
59.                         }
    
60.                 }
    
61.         }
    
62.         /**
    
63.          * 对数组进行冒泡排序
    
64.          * @param arr 接收一个int类型的数组
    
65.          */
    
66.         public static void bubbleSort(int[] arr)//冒泡排序
    
67.         {
    
68.                 for (int x=0;x<arr.length-1;x++)
    
69.                 {
    
70.                         for (int y=0;y<arr.length-x-1;y++)
    
71.                         {
    
72.                                 if (arr[y]>arr[y+1])
    
73.                                 {
    
74.                                         swap(arr,y,y+1);
    
75.                                 }
    
76.                         }
    
77.                 }
    
78.                
    
79.         }
    
80.         /**
    
81.          * 给数组中的元素进行位置指环
    
82.          * @param arr 接收一个int数组
    
83.          * @param a 要置换的位置
    
84.          * @param b 置换的位置
    
85.          */
    
86.         private static void swap(int[] arr,int a,int b)//调换位置工具
    
87.         {
    
88.                 int temp = arr[a];
    
89.                 arr[a] = arr[b];
    
90.                 arr[b] = temp;
    
91.         }
    
92.         /**
    
93.          * 打印数组中的元素，打印形式是[elemet1, elemet2, ...]
    
94.          * @param arr 接收一个int数组
    
95.          */
    
96.         public static void printArray(int[] arr)
    
97.         {
    
98.                 System.out.print("{");
    
99.                 for(int x=0; x<arr.length;x++)
    
100.                 {
     
101.                         if (x!=arr.length-1)
     
102.                                 System.out.print(arr[x]+",");
     
103.                         else
     
104.                                 System.out.println(arr[x]+"}");
     
105.                 }
     
106.         }
     
107. }

复制代码

一个类中默认会有一个共参数的构造函数
这个默认的的构造函数的权限和所属类一致
如果类被public修饰，那么默认的构造函数也带public
如果类没有被public修饰，那么默认的构造函数也没有public修饰

即：默认构造的构造函数的权限是随着类的变化而变化的

谢谢分享！