Java static关键字/静态变量/静态方法/final关键字

傷城~ 2022-05-22 11:55 276阅读 0赞

原文：www.weixueyuan.net/view/6003.html

http://www.weixueyuan.net/view/6004.html

静态变量和静态方法能够通过类名来访问，不需要创建一个类的对象来访问该类的静态成员，所以static修饰的成员又称作类变量和类方法。静态变量与实例变量不同，实例变量总是通过对象来访问，因为它们的值在对象和对象之间有所不同。

**static 的内存分配**

静态变量属于类，不属于任何独立的对象，所以无需创建类的实例就可以访问静态变量。之所以会产生这样的结果，是因为编译器只为整个类创建了一个静态变量的副本，也就是只分配一个内存空间，虽然有多个实例，但这些实例共享该内存。实例变量则不同，每创建一个对象，都会分配一次内存空间，不同变量的内存相互独立，互不影响，改变 a 对象的实例变量不会影响 b 对象。

public class Demo {
        static int i;
        int j;
    
        public static void main(String[] args) {
            Demo obj1 = new Demo();
            obj1.i = 10;
            obj1.j = 20;
           
            Demo obj2 = new Demo();
           
            System.out.println("obj1.i=" + obj1.i + ", obj1.j=" + obj1.j);
            System.out.println("obj2.i=" + obj2.i + ", obj2.j=" + obj2.j);
        }
    }

运行结果：  
obj1.i=10, obj1.j=20  
obj2.i=10, obj2.j=0

上面的代码中，i 是静态变量，通过 obj1 改变 i 的值，会影响到 obj2；j 是实例变量，通过 obj1 改变 j 的值，不会影响到 obj2。这是因为 obj1.i 和 obj2.i 指向同一个内存空间，而 obj1.j 和 obj2.j 指向不同的内存空间。

注意：类变量(class variables)用关键字 static 修饰，在类加载的时候，分配类变量的内存，以后再生成类的实例对象时，将共享这块内存（类变量），任何一个对象对类变量的修改，都会影响其它对象。

**关于静态变量和静态方法的总结**

*  一个类的静态方法只能访问静态变量；
 *  一个类的静态方法不能够直接调用非静态方法；
 *  如访问控制权限允许，静态变量和静态方法也可以通过对象来访问，但是不被推荐；
 *  静态方法中不存在当前对象，因而不能使用 this，当然也不能使用 super；
 *  静态方法不能被非静态方法覆盖；
 *  构造方法不允许声明为 static 的；
 *  局部变量不能使用static修饰。

**静态初始器（静态块）**

块是由大括号包围的一段代码。静态初始器(Static Initializer)是一个存在于类中、方法外面的静态块。静态初始器仅仅在类装载的时候（第一次使用类的时候）执行一次，往往用来初始化静态变量。

public class Demo {
        public static int i;
        static{
            i = 10;
            System.out.println("Now in static block.");
        }
        public void test() {
            System.out.println("test method: i=" + i);
        }
    
        public static void main(String[] args) {
            System.out.println("Demo.i=" + Demo.i);
            new Demo().test();
        }
    }

运行结果：  
Now in static block.  
Demo.i=10

test method: i=10

静态导入

用来导入类的静态变量和静态方法。静态导入的好处是可以简化一些操作，例如输出语句 System.out.println(); 中的 out 就是 System 类的静态变量，可以通过 import static java.lang.System.\*; 将其导入，下次直接调用 out.println() 就可以了。

import static java.lang.System.*;
    import static java.lang.Math.random;
    public class Demo {
        public static void main(String[] args) {
            out.println("产生的一个随机数：" + random());
        }
    }

运行结果：  
产生的一个随机数：0.05800891549018705

**final关键字**

具体规定如下：

*  final 修饰的类不能被继承。
 *  final 修饰的方法不能被子类重写。
 *  final 修饰的变量（成员变量或局部变量）即成为常量，只能赋值一次。
 *  final 修饰的成员变量必须在声明的同时赋值，如果在声明的时候没有赋值，那么只有 一次赋值的机会，而且只能在构造方法中显式赋值，然后才能使用。
 *  final 修饰的局部变量可以只声明不赋值，然后再进行一次性的赋值。

注意：

如果将引用类型（任何类的类型）的变量标记为 final，那么该变量不能指向任何其它对象。但可以改变对象的内容，因为只有引用本身是 final 的。

如果变量被标记为 final，其结果是使它成为常数。想改变 final 变量的值会导致一个编译错误。

final 也可以用来修饰类（放在 class 关键字前面），阻止该类再派生出子类。

方法也可以被 final 修饰，被 final 修饰的方法不能被覆盖；变量也可以被 final 修饰，被 final 修饰的变量在创建对象以后就不允许改变它们的值了。一旦将一个类声明为 final，那么该类包含的方法也将被隐式地声明为 final，但是变量不是。

被 final 修饰的方法为静态绑定，不会产生多态（动态绑定），**程序在运行时不需要再检索方法表**，能够提高代码的执行效率。在Java中，被 static 或 private 修饰的方法会被隐式的声明为 final，因为动态绑定没有意义。

JVM 中的即时编译器能够实时监控程序的运行信息，可以准确的知道类之间的继承关系。**如果一个方法没有被覆盖并且很短**，编译器就能够对它进行优化处理，这个过程为称为内联(inlining)。例如，内联调用 e.getName() 将被替换为访问 e.name 变量。