静态概念

2017-07-07

1. static 只可修饰成员变量或者方法，存在于内存方法区(共享区)，没有必要每一个对象中存储一份相同数据。可以直接用类名调用。随着类的加载而加载，随着类的消失而消失，生命周期最长，优先于对象存在，并且被这个类的所有对象共享。弊端就是静态方法只能访问静态成员。道理很简单，因为没对象，所以非静态的访问不到。静态方法中不能出现this。

2. 方法没有用到对象特有属性，那就定义成static会更好。所以像工具类，通常不会封装自己的特有数据和操作自己的数据，而是像工具一样被用来操作传入的数据，就可以用static修饰。所以往往工具类构造方法私有化。

           class NumDemo{
               public static void main (String[] args) {
                   int [] arr = {32,54,1,5,12,34};
                   System.out.println(ArrUtil.getMax(arr));
                   System.out.println(ArrUtil.getMin(arr));
                   ArrUtil.print(ArrUtil.sort(arr));       
               } 
           }
   
   
           class ArrUtil{
   
               // 私有化构造方法
               private ArrUtil() {
   
               };          
   
               public static int getMax(int[] arr) {
                   int max = arr[0];
                   for (int i = 1; i < arr.length; i++ ) {
                       if (arr[i] > max) {
                           max = arr[i];
                       }
                   }
                   return max;
               }
   
               public static int getMin(int[] arr) {
                   int min = arr[0];
                   for (int i = 1; i < arr.length; i++ ) {
                       if (arr[i] < min) {
                           min = arr[i];
                       }
                   }
                   return min;
               }
   
               public static int[] sort(int[] arr) {
   
                   for (int i = 0; i < arr.length - 1; i++ ) {
                       for (int j = i+1; j < arr.length; j++ ) {
                           if (arr[i] > arr[j] ) {
                               swap(arr,i,j); //这个地方仅仅swap(arr[i],arr[j]) 貌似不行，要把数组传入，脑袋有点晕
                           }
                       }
                   }
                   return arr;
               }
   
               // 不对外提供的方法私有起来
               private static void swap(int[] arr, int a, int b) {
                   int temp = arr[a];
                   arr[a] = arr[b];
                   arr[b] = temp;
               }
   
               public static void print(int [] arr){
                   for (int i = 0; i<arr.length ; i++) {
   
                       if (i != arr.length - 1) {
                           System.out.print(arr[i] + ",");
                       } else {
                           System.out.print(arr[i] + ".");
                       }
                   }
               }
           }

3. 静态代码块在类被加载进内存的时候初始化一次，哪怕再new一个对象，也不会再次执行。构造代码块是创建对象时候执行，构造函数在创建对应对象时候执行。

4. new一个对象，经过了很多步骤
   
   1. 栈中创建引用变量
   2. 类文件加载进内存
   3. 静态代码块初始化
   4. 堆内存分配空间
   5. 对象属性默认初始化
   6. 对象属性显式初始化
   7. 构造代码块初始化
   8. 构造函数初始化
   9. 内存地址赋值给引用变量