Java中的static关键字

1 年 ago

宇, 华

3 minutes

Java中的static关键字在java编程中使用得很多。Java的static关键字用于在java中创建一个类级别的变量。静态变量和方法是类的一部分，而不是类的实例的一部分。

在Java中的静态关键字

Java的static关键字可以在如下所示的五种情况下使用。我们在这里将讨论其中四种情况，第五种情况在Java 8中引入，并在Java 8接口更改中进行了讨论。

Java静态方法
与静态变量相同，静态方法属于类而不是类的实例。静态方法只能访问类的静态变量，并且只能调用类的静态方法。通常，静态方法是我们想要公开供其他类使用的实用方法，而不需要创建实例。例如，Collections类。Java包装类和实用程序类包含许多静态方法。java程序的入口点main()方法本身就是一个静态方法。
// 静态方法示例
public static void setCount(int count) {
if(count > 0)
StaticExample.count = count;
}

// 静态实用方法
public static int addInts(int i, int…js){
int sum=i;
for(int x : js) sum+=x;
return sum;
}

从Java 8开始，接口中也可以有静态方法。有关更多详细信息，请阅读Java 8接口更改。

Java静态代码块
Java静态代码块是一组语句，在类被Java类装载器加载到内存时执行。静态块用于初始化类的静态变量。在类加载时，通常用来创建静态资源。在静态块中，我们无法访问非静态变量。在一个类中，我们可以有多个静态代码块，尽管这没有太多意义。静态代码块的代码在类加载到内存时只执行一次。
static{
// 可以在类加载时初始化资源
System.out.println(“StaticExample静态代码块”);
// 只能访问静态变量和方法
str=”Test”;
setCount(2);
}

Java静态类
我们可以使用static关键字与嵌套类一起使用。静态关键字不能与顶级类一起使用。静态嵌套类与任何其他顶级类相同，只是为了便于封装而嵌套。阅读：Java嵌套类

我们来看看一个示例程序中Java中static关键字的使用情况。StaticExample.java

package com.Olivia.misc;

public class StaticExample {

    //static block
    static{
        //can be used to initialize resources when class is loaded
        System.out.println("StaticExample static block");
        //can access only static variables and methods
        str="Test";
        setCount(2);
    }
    
    //multiple static blocks in same class
    static{
        System.out.println("StaticExample static block2");
    }
    
    //static variable example
    private static int count; //kept private to control its value through setter
    public static String str;
    
    public int getCount() {
        return count;
    }

    //static method example
    public static void setCount(int count) {
        if(count > 0)
        StaticExample.count = count;
    }
    
    //static util method
    public static int addInts(int i, int...js){
        int sum=i;
        for(int x : js) sum+=x;
        return sum;
    }

    //static class example - used for packaging convenience only
    public static class MyStaticClass{
        public int count;
        
    }

}

让我们来看一下在测试程序中如何使用静态变量、方法和静态类。TestStatic.java

package com.Olivia.misc;

public class TestStatic {

    public static void main(String[] args) {
        StaticExample.setCount(5);
        
        //non-private static variables can be accessed with class name
        StaticExample.str = "abc";
        StaticExample se = new StaticExample();
        System.out.println(se.getCount());
        //class and instance static variables are same
        System.out.println(StaticExample.str +" is same as "+se.str);
        System.out.println(StaticExample.str == se.str);
        
        //static nested classes are like normal top-level classes
        StaticExample.MyStaticClass myStaticClass = new StaticExample.MyStaticClass();
        myStaticClass.count=10;
        
        StaticExample.MyStaticClass myStaticClass1 = new StaticExample.MyStaticClass();
        myStaticClass1.count=20;
        
        System.out.println(myStaticClass.count);
        System.out.println(myStaticClass1.count);
    }
    
}

上述Java示例程序中的static关键字的输出是：

StaticExample static block
StaticExample static block2
5
abc is same as abc
true
10
20

请注意，静态块代码在类加载到内存时首先执行一次。其他输出都很容易理解。

Java静态导入

通常我们使用类引用来访问静态成员，从Java 1.5开始，我们可以使用Java静态导入来避免使用类引用。下面是一个简单的Java静态导入的示例。

package com.Olivia.test;

public class A {

	public static int MAX = 1000;
	
	public static void foo(){
		System.out.println("foo static method");
	}
}

package com.Olivia.test;

import static com.Olivia.test.A.MAX;
import static com.Olivia.test.A.foo;

public class B {

	public static void main(String args[]){
		System.out.println(MAX); //normally A.MAX
		foo(); // normally A.foo()
	}
}

请注意导入语句，对于静态导入，我们必须使用import static，后跟类的完全限定的静态成员。对于导入类的所有静态成员，我们可以使用*，如import static com.Olivia.test.A.*；当我们多次使用类的静态变量时，才应该使用它，这对可读性不利。更新：我最近创建了一个视频来解释Java中的静态关键字，你应该在下面观看它。https://www.youtube.com/watch?v=2e-l1vb\_fwM