static关键字总结：
       1，static 是一个修饰符，用于修饰成员（成员变量，成员方法），用static修饰的成员，将存储于方法区中
       2，静态随着类的加载而加载，随着类的释放而消失，故静态是先于对象存在，且生命周期最长！
       3，被所有的对象共享。调用方式：类名.静态成员
       4，静态方法只能访问静态成员（静态中不可以出现this，super关键字）
       5，静态存储的是共享的内容，所以可以节省内存空间，但同时，生命周期过长，访问出现局限性(只能访问静态)
       6，每一个程序中都有共性的内容，可以将这些共性的内容独立抽取，封装，以便使用。。
            【当功能内部没有访问到非静态数据（对象的特有数据，所谓对象特有的数据，就是随着对象的建立
             而产生的特有的数据），那么该功能可以定义成静态的。】

如下例：

class ArrayTool{ //工具类
String name;
//所谓对象的特有数据，是指随着对象的建立而产生的特有数据，比如，人的姓名，性别，年龄，
private ArrayTool(){}//构造函数私有化，禁止创建对象
/**
  *
  * @param arr
  * @return
  */
public static int getMax(int[] arr){
  //this.name = arr[1]; 类中的静态先于对象存在，不能使用this，super关键字
  int max = 0;
  for(int x=1;x<arr.length;x++){
   if(arr[max]<arr[x]){
    max = x;
   }
  }
  return max;
}
/**
  *
  * @param arr
  * @return
  */
public static int getMin(int[] arr){
  int min = 0;
  for(int x=1;x<arr.length;x++){
   if(arr[min] > arr[x]){
    min = x;
   }
  }
  return min;
}
/**
  * 选择排序
  * @param arr
  */
public static void selectSort(int[] arr){
  for(int x=0;x<arr.length-1;x++){
   for(int y=x+1;y<arr.length-1;y++){
    if(arr[x] >arr[y]){
     swap(arr,x,y);
    }
   }
  }
}
/**
  * 冒泡排序
  * @param arr
  */
public static void bubbleSort(int[] arr){
  for(int x=0;x<arr.length;x++){
   for(int y=0;y<arr.length-x-1;y++){
    if(arr[y]>arr[y+1]){
     swap(arr,y,y+1);
    }
   }
  }
}
/**
  * 交换位置的函数
  * @param arr
  * @param x
  * @param y
  */
private static void swap(int[] arr,int x,int y){ //外部访问没用，定义成私有的
  int temp = arr[x];
  arr[x] = arr[y];
  arr[y] = temp;
}
/**
  * 输出数组的元素
  * @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
  * @param x
  */
public static void beforeSortMax(int[] arr,int x){
  System.out.println("排序前的最大值是："+arr[x]);
}
/**
  * 输出函数
  * @param arr
  * @param x
  */
public static void afterSortMax(int[] arr,int x){
  System.out.println("排序后的最大值是："+arr[x]);
}
/**
  * 输出函数
  * @param arr
  * @param x
  */
public static void beforeSortMin(int[] arr,int x){
  System.out.println("排序前的最小值是："+arr[x]);
}
/**
  * 输出函数
  * @param arr
  * @param x
  */
public static void afterSortMin(int[] arr,int x){
  System.out.println("排序后的最小值是："+arr[x]);
}
}
public class StaticDemo3 {
public static void main(String[] args){
  //ArrayTool at = new ArrayTool();是错误的，构造函数私有，不能创建对象
  int[] ar = {8,9,1,3,0,11,18};
  ArrayTool.printArray(ar);
  ArrayTool.beforeSortMax(ar, ArrayTool.getMax(ar));
  //int max1 = ArrayTool.getMax(ar);
  //System.out.println("排序前的最大值是："+ar[max1]);
  //int min1 = ArrayTool.getMin(ar);
  //System.out.println("排序前的最小值是："+ar[min1]);
  ArrayTool.beforeSortMin(ar, ArrayTool.getMin(ar));
  ArrayTool.bubbleSort(ar);
  ArrayTool.printArray(ar);  
  //int max2 = ArrayTool.getMax(ar);
  //System.out.println("排序后的最大值是："+ar[max2]);
  ArrayTool.afterSortMax(ar, ArrayTool.getMax(ar));
  
  //int min2 = ArrayTool.getMin(ar);
  //System.out.println("排序后的最小值是："+ar[min2]);
  ArrayTool.afterSortMin(ar, ArrayTool.getMin(ar));
  
  int[] a1 = {88,38,29,34,100,80,68,70};
  ArrayTool.printArray(a1);
  
  ArrayTool.beforeSortMax(a1, ArrayTool.getMax(a1));
  //int max3 = ArrayTool.getMax(a1);
  //System.out.println("排序前的最大值是："+a1[max3]);
  ArrayTool.beforeSortMin(a1, ArrayTool.getMin(a1));
  //int min3 = ArrayTool.getMin(a1);
  //System.out.println("排序后的最小值是："+a1[min3]);
  ArrayTool.bubbleSort(a1);
  ArrayTool.printArray(a1);
  
  ArrayTool.afterSortMax(a1, ArrayTool.getMax(a1));
  ArrayTool.afterSortMin(a1, ArrayTool.getMin(a1));
}

}

善于总结的孩子都是好孩子。{:soso_e113:}

嗯,总结的不错.

谢谢！{:soso_e142:}