浅谈java中static关键字修饰的几种用法

参考链接： Java中的static关键字

在java的关键字中，static和final是两个我们必须掌握的关键字。不同于其他关键字，他们都有多种用法，而且在一定环境下使用，可以提高程序的运行性能，优化程序的结构。下面我们先来了解一下static关键字及其用法。 

static关键字 

1，修饰成员变量 类，里面有属性和方法 属性里面又分局部变量，实例变量和类变量 

实例变量,在创建对象的时候分配空间初始化 类变量不再属于某一个对象，它属于全类公有； 实例变量和类变量区分主要看加不加static，统称变量 属性和方法合称为成员 

所以这里我再次区分一下， （1），static修饰变量时的用法： static修饰的变量叫做类变量 //类变量不再属于某一个对象，它属于全类公有； 

static int b = 20;

类变量是在类加载的时候初始化的； 什么是类加载： 所有数据都是存在虚拟机内存里面 jvm启动后，在程序之执行的过程中，肯定会用到很多的类 .class文件的读取过程只有一次，在第一次用到这个类的时候；这就是类的加载 类加载：当虚拟机第一次使用一个类时，需要通过Classpath找到这个类对应的.class文件 把这个文件中包含的类的信息读jvm并保存起来。 一般的说，一个类只会加载一次； 所有的类变量是在类加载的时候分配空间，并且初始化！ 

类加载的时机： 1，创建类的对象 2，访问类的静态成员 3，加载子类必须先加载父类 4，如果仅仅是声明类的引用，不会类加载； 

（2）修饰成员方法 static的另一个作用，就是修饰成员方法。相比于修饰成员属性，修饰成员方法对于数据的存储上面并没有多大的变化，因为我们从上面可以看出，方法本来就是存放在类的定义当中的。static修饰成员方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗，我们可能会经常在帮助类中看到它的使用： 

static修饰的静态方法：允许直接用类名调用 在静态方法中，只能访问类的静态成员 

 静态方法中不能直接访问本类非静态成员(方法和属性)  非静态方法中可以去访问静态成员  静态方法中不能使用this和super关键字  静态方法可以被覆盖，但是只能被静态方法覆盖， 而且 没有多态  

（3），初始代码块 静态初始代码块中的代码，在类加载的时候执行一次； 

其中，

局部变量

类

构造方法

等都不能静态

（4） 父类的静态方法只能被子类的静态方法覆盖 

为便于理解下面程序加了详细注释说明，每一种使用都有详细标注，相信把下面这个程序看懂就能理解static的具体用法了！ 

   package test;

    public class TestStatic{

    /**

    static   静态的

    修饰的   1，属性

            2，方法

            3，初始代码块

     */

        public static void main(String[] args) {

             MyClass m1 = new MyClass();

             MyClass m2 = new MyClass();

             m1.a++;

             m1.b++;

             System.out.println(m1.a);//11

              System.out.println(m1.b);//21

             System.out.println(m2.a);//10

             System.out.println(m2.b);//21

             //类变量允许直接用类名访问，与对象无关

             System.out.println(MyClass.b);//21

             //静态方法：允许直接用类名调用

             MyClass.print(); 

             //如果不是静态方法，需要创建对象然后通过对象去调用

             MyClass mc = new MyClass();

             mc.prints();

             System.out.println("****************************");

             //静态初始代码块中的代码，只在类加载的时候执行一次；

             /* 所以就算两次创建，也只会输出

                hahahha

                 MyClass2()

                 MyClass2()  */

             new MyClass2();

             new MyClass2();

             //多态

             Super s = new Sub();

             //对一个引用，调用其静态方法，仅相当于对引用的引用类型调用静态方法

             //例， s.method();等价于Super.method();

             s.method();//输出Super  

             /*根据以往学的多态的知识，此处应该打印Sub；

             //所以，静态方法可以被子类的静态方法覆盖，而且没有多态

             //没有多态，是指多态三条原则中的第三条不再适用，

             //不会根据对象实际类型去找子类覆盖之后的方法

             //即，静态方法的覆盖没有多态，*/

             Super s2 = null;

             s2.method();          

        }

    }

    class MyClass{

        //实例变量,在创建对象的时候分配空间初始化 

        int a = 10;

    /*    1，属性

        //静态变量   类变量，

        //类变量不再属于某一个对象，它属于全类公有； */

        static int b = 20;

    /*2，方法

        静态方法：允许直接用类名调用

        在静态方法中，只能访问类的静态成员     */

        public static void print(){

            System.out.println("==    ========");

            //在静态方法中，只能访问类的静态成员

            //System.out.println("=========="+a);error!!!

            System.out.println("=========="+b);//true

                //访问myclass类对象的成员就可以了

                MyClass ma = new MyClass();

                System.out.println(ma.a);//true

        }

        //非静态方法

        public void prints(){

            System.out.println("-----------");

        }

    }

     /*3，初始代码块 

        静态初始代码块中的代码，在类加载的时候执行一次； */

    class MyClass2{

        static{

            System.out.println("hahahha");

        }

        public MyClass2(){

            System.out.println(" MyClass2()");

        }

    }

    /*  局部变量, 类, 构造方法

    等都不能静态     */   

    //父类的静态方法只能被子类的静态方法覆盖

    class Super{

        public static void method(){

            System.out.println("Super");

        }

    }

    class Sub extends Super{

        public static void method(){

            System.out.println("Sub");

        }

    }

总结： static是java中非常重要的一个关键字，而且它的用法也很丰富，主要有四种用法： 

用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；静态块用法，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。