1. class  ArrayTool
   
2. {
   
3.         private ArrayTool(){}
   
4.          private static int getMax(int[] arr)
   
5.         {
   
6.                 int Max=0;
   
7.                 for(int x=1; x<arr.length; x++)
   
8.                 {
   
9.                         if(arr[Max]<arr[x])
   
10.                         {
    
11.                                 Max=x;
    
12.                         }
    
13.                 }
    
14.                 return arr[Max];
    
15.         }
    
16.          
    
17.         private static int getMin(int[] arr)
    
18.         {
    
19.                 int Min=0;
    
20.                 for(int x=1;x<arr.length;x++)
    
21.                 {
    
22.                         if(arr[Min]>arr[x])
    
23.                         {
    
24.                                 Min=x;
    
25.                         }
    
26.                 }
    
27.                 return arr[Min];
    
28.         }
    
29.        
    
30.         private static void selectSort(int[] arr)
    
31.         {
    
32.                 for(int x=0;x<arr.length-1;x++)
    
33.                 {
    
34.                         for(int y=x+1;y<arr.length;y++)
    
35.                         {
    
36.                                 if(arr[x]>arr[y])
    
37.                                 {
    
38.                                         swap(arr,x, y);
    
39.                                 }
    
40.                         }
    
41.                 }
    
42.                  
    
43.         }
    
44.         private static void swap(int[] arr,int a,int b)
    
45.         {
    
46.                 int temp;
    
47.                 temp=arr[a];
    
48.                 arr[a]=arr[b];
    
49.                 arr[b]=temp;
    
50.         }
    
51.         private static void bubbleSort(int[] arr)
    
52.         {
    
53.                 for(int x=0;x<arr.length-1;x++)
    
54.                 {
    
55.                         for(int y=0;y<arr.length-x-1;y++)
    
56.                         {
    
57.                                 if(arr[y]>arr[y+1])
    
58.                                 {
    
59.                                         swap(arr,y,y+1);
    
60.                                 }
    
61.                         }
    
62.                 }
    
63.         }
    
64.         private static void printArray(int[] arr)
    
65.         {
    
66.                 System.out.print("[");
    
67.                 for(int x=0;x<arr.length;x++)
    
68.                 {
    
69.                         if(x!=arr.length-1)
    
70.                                 System.out.print(arr[x]+",");
    
71.                         else
    
72.                                 System.out.println(arr[x]+"]");
    
73.                                  
    
74. 
    
75.                 }
    
76.         }
    
77. }

复制代码

同类可以访问的  

private  在本类中有效

private类型，本类可以调用

1、private修饰词，表示成员是私有的，只有自身可以访问；   
2、protected，表示受保护权限，体现在继承，即子类可以访问父类受保护成员，同时相同包内的其他类也可以访问protected成员。   
3、无修饰词（默认），表示包访问权限（friendly， java语言中是没有friendly这个修饰符的，这样称呼应该是来源于c++ ），同一个包内可以访问，访问权限是包级访问权限；  
4、public修饰词，表示成员是公开的，所有其他类都可以访问；
楼主这个例子中private修饰的是成员方法。那么成员方法在自己所属的类中被使用是可以的。

ノtrack 发表于 2014-4-22 10:41
同类可以访问的

恩！这我知道就是，我把它定义为工具类，其他类中可以调用，但是应该不能用建立对象的形式，可是我试了，还是可以建立对象！

kuroro自走核炮 发表于 2014-4-22 10:44
1、private修饰词，表示成员是私有的，只有自身可以访问；   
2、protected，表示受保护权限，体现在继承， ...

若是不相同的类呢！这是个工具类！其他类可以调用，但应该不能建立对象吧！我建立对象后还是能用这是为什么呢？

千曲生 发表于 2014-4-22 10:51
若是不相同的类呢！这是个工具类！其他类可以调用，但应该不能建立对象吧！我建立对象后还是能用这是为什 ...

用这个工具类的私有构造方法建立对象试了一下，编译就报错了。你怎么建立对象的？

工具类的方法一般都为public

kuroro自走核炮 发表于 2014-4-22 11:02
用这个工具类的私有构造方法建立对象试了一下，编译就报错了。你怎么建立对象的？
...

我编译了一下，没有问题的可以！而且可以调用！这是我搞不懂的地方！

千曲生 发表于 2014-4-22 22:46
我编译了一下，没有问题的可以！而且可以调用！这是我搞不懂的地方！

竟然能编译通过，你用什么IDE来开发的？应该和你的IDE有关系。
正常情况下是编译不通过的。

就算能编译通过，试试能不能运行。

私有权限在本类中可以使用。
楼主，你这个类作为工具类的话，首先你私有化了无参构造函数，其次，你没有创建带参构造函数，这样是没法创建对象的。你的方法是静态的，所以可以通过类名调用类中的方法，这样就属于本类调用，是没有问题的

千曲生 发表于 2014-4-22 22:46
我编译了一下，没有问题的可以！而且可以调用！这是我搞不懂的地方！

我不清楚你怎么弄的。但是我这边在另一个类中无论是建立对象还是引用都是编译无法通过的。

  java中类的修饰符有以下几种：private 、default（package）、protect、public，其范围如下表：

范围	private	default	protected	public
同一类	√	√	√	√
同一包中的类		√	√	√
同一包中的类、不同包中的子类			√	√
所有				√

补充：还有final、和abstract修饰符： final修饰的类不能被继承，没有子类。 abstract修饰的类不能被实例化，必须被子类继承。类只要有一个抽象方法就必定是抽象类，但抽象类不一定要有抽象方法。

private 只在本来可以被调用
对外调用时，需要使用访问器。
我昨天夜里也走进一个构造函数和访问器的误区，哈哈。
有兴趣看我马上的提问。

清风夜独醉 发表于 2014-4-23 00:12
竟然能编译通过，你用什么IDE来开发的？应该和你的IDE有关系。
正常情况下是编译不通过的。

恩，试了一下现在不能运行了，谢谢!可能是电脑反应问题有很多程序老师莫名出错。。。