java笔记-static（静态）关键字

静态：static

用法：是一个修饰符，用于修饰成员（成员变量，成员函数）

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用

static特点：

a.随着类的加载而加载，随着类的消失而消失

b.优先于对象存在

c.被所有对象所共享

d.可以被类名调用

实例变量与类变量的区别

a.存放位置：类变量随着类的加载而存在于方法区中；实例变量随着对象的建立而存在于堆内存中

b.生命周期：类变量生命周期最长，随着类的消失而消失；实例变量随着对象的消失而消失

注意：

a.静态方法只能访问静态成员

b.静态方法中不可以定义this,super关键字，因为静态优先于对象存在

public class Person {
    String name;
    static String country="CN";
     public void show(){
          System.out.println(name+":"+country);
     }
}

public class PersonDemo {
    public static void main(String[] args){
        System.out.println(Person.country);        
    }
}

主函数的定义：

public：代表着该函数访问权限是最大的

static：代表主函数随类的加载就已经存在了

void：主函数没有具体的返回值

mian：不是关键字，但是是一个特殊的单词，可以被jvm识别

(String[] arr)：函数的参数，参数类型是一个数组，该数组中的元素是字符串

什么时候使用静态？

a.什么时候定义静态变量：当对象中出现共享数据时，该数据被静态所修饰

b.什么时候定义静态函数：当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的

静态的应用

每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用

class ArrayTool{
   public int getMax(int[] arr){
      int max=0;
      for(int i=0;i<arr.length;i++){
         if(arr[i]>arr[max]){
            max=i;
         }
      }
      return arr[max];
   }
   public int getMin(int[] arr){
      int min=0;
      for(int i=0;i<arr.length;i++){
         if(arr[i]<arr[min]){
            min=i;
         }
      }
      return arr[min];
   }

   public void selectSort(int[] arr){
      for(int i=0;i<arr.length-1;i++){
         for(int y=i+1;y<arr.length;y++){
            if(arr[i]>arr[y]){
               swap(arr,i,y);
            }
         }
      }
   }
   public void bubbleSort(int[] arr){
      for(int i=0;i<arr.length-1;i++){
         for(int y=0;y<arr.length-i-1;y++){
            if(arr[y]>arr[y+1]){
               swap(arr,y,y+1);
            }
         }
      }
   }
   public void swap(int[] arr,int a,intb){
      int temp=arr[a];
      arr[a]=arr[b];
      arr[b]=temp;
   }
   public void printArray(int[] arr){
      System.out.print(“[”);
      for(int i=0;i<arr.length;i++){
         if(i!=arr.length-1)
            System.out.print(arr[x]+”, ”);
         else

             System.out.print(arr[x]+”] ”);
      }
   }

}

class ArrayToolDemo{

      public static void main(String[] args){
       int[] arr={3,53,23,54,12,5,13,42};
       ArrayTool tool=new ArrayTool();
       int max=tool.getMax(arr);
       System.out.println(“max=”+max);
       tool.printArray(arr);
       tool.selectSort(arr);
       tool.printArray(arr);
    }

}
升级一下

class ArrayTool{
   private ArrayTool(){}
   public static int getMax(int[] arr){
      int max=0;
      for(int i=0;i<arr.length;i++){
         if(arr[i]>arr[max]){
            max=i;
         }
      }
      return arr[max];
   }
   public static int getMin(int[] arr){
      int min=0;
      for(int i=0;i<arr.length;i++){
         if(arr[i]<arr[min]){
            min=i;
         }
      }
      return arr[min];
   }

   Public static void selectSort(int[] arr){
      for(int i=0;i<arr.length-1;i++){
         for(inty=i+1;y<arr.length;y++){
            if(arr[i]>arr[y]){
               swap(arr,i,y);
            }
         }
      }
   }
   public static void bubbleSort(int[]arr){
      for(int i=0;i<arr.length-1;i++){
         for(inty=0;y<arr.length-i-1;y++){
            if(arr[y]>arr[y+1]){
               swap(arr,y,y+1);
            }
         }
      }
   }
   private static void swap(int[] arr,inta,int b){
      int temp=arr[a];
      arr[a]=arr[b];
      arr[b]=temp;
   }
   public static void printArray(int[]arr){
      System.out.print(“[”);
      for(int i=0;i<arr.length;i++){
         if(i!=arr.length-1)
            System.out.print(arr[i]+”, ”);
         else

             System.out.print(arr[i]+”] ”);
      }
   }

}

class ArrayToolDemo{

      public static void main(String[] args){
       int[] arr={3,53,23,54,12,5,13,42};
       int max=ArrayTool.getMax(arr);
       System.out.println(“max=”+max);
    }

}

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

静态代码块

static{

      静态代码块中执行的语句

}

特点：随着类的加载而执行，只执行一次，并优先于主函数，用于给类进行初始化