java关键字static_Java中的static关键字

最新推荐文章于 2024-07-14 22:38:47 发布

cunchi4221

最新推荐文章于 2024-07-14 22:38:47 发布

阅读量258

点赞数

文章标签： java 编程语言 python mysql jvm

原文链接：https://www.journaldev.com/1365/static-keyword-in-java

版权

java关键字static

static keyword in Java is used a lot in java programming. Java static keyword is used to create a Class level variable in java. static variables and methods are part of the class, not the instances of the class.

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

Java中的static关键字 (static keyword in java)

Java static keyword can be used in five cases as shown in below image.

如下图所示，可以在五种情况下使用Java静态关键字。

We will discuss four of them here, the fifth one was introduced in Java 8 and that has been discussed at Java 8 interface changes.

我们将在这里讨论其中的四个，第五个是在Java 8中引入的，并且已经在Java 8接口更改中进行了讨论。

Java静态变量 (Java static variable)

We can use static keyword with a class level variable. A static variable is a class variable and doesn’t belong to Object/instance of the class.
Since static variables are shared across all the instances of Object, they are not thread safe.
Usually, static variables are used with the final keyword for common resources or constants that can be used by all the objects. If the static variable is not private, we can access it with ClassName.variableName
```
//static variable example
    private static int count;
    public static String str;
    public static final String DB_USER = "myuser";
```
我们可以在类级别的变量中使用static关键字。静态变量是类变量，不属于该类的对象/实例。

由于静态变量在Object的所有实例之间共享，因此它们不是线程安全的。

通常，静态变量与final关键字一起使用，以表示所有对象都可以使用的公共资源或常量。如果静态变量不是私有变量，则可以使用ClassName.variableName进行访问
Java静态方法 (Java static method)

Same as static variable, static method belong to class and not to class instances.
A static method can access only static variables of class and invoke only static methods of the class.
Usually, static methods are utility methods that we want to expose to be used by other classes without the need of creating an instance. For example Collections class.
Java Wrapper classes and utility classes contains a lot of static methods. The main() method that is the entry point of a java program itself is a static method.
```
//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;
    }
```
From Java 8 onwards, we can have static methods in interfaces too. For more details please read Java 8 interface changes.
与静态变量相同，静态方法属于类，而不属于类实例。

静态方法只能访问类的静态变量，并且只能调用类的静态方法。

通常，静态方法是我们希望公开的实用程序方法，供其他类使用，而无需创建实例。例如Collections类。

Java包装程序类和实用程序类包含许多静态方法。作为Java程序本身入口点的main（）方法是静态方法。

从Java 8开始，我们也可以在接口中使用静态方法。有关更多详细信息，请阅读Java 8接口更改。
Java静态块 (Java static block)

Java static block is the group of statements that gets executed when the class is loaded into memory by Java ClassLoader.
Static block is used to initialize the static variables of the class. Mostly it’s used to create static resources when the class is loaded.
We can’t access non-static variables in the static block. We can have multiple static blocks in a class, although it doesn’t make much sense. Static block code is executed only once when the class is loaded into memory.
```
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);
    }
```
Java静态块是由Java ClassLoader将类加载到内存中时执行的语句组。

静态块用于初始化类的静态变量。通常，它用于在加载类时创建静态资源。

我们无法在静态块中访问非静态变量。我们可以在一个类中有多个静态块，尽管这没有多大意义。当类加载到内存中时，静态块代码仅执行一次。
Java静态类 (Java Static Class)

We can use static keyword with nested classes. static keyword can’t be used with top-level classes.
A static nested class is same as any other top-level class and is nested for only packaging convenience.
Read: Java Nested Classes
我们可以对嵌套类使用static关键字。 static关键字不能与顶级类一起使用。

静态嵌套类与任何其他顶级类相同，并且仅出于包装方便而嵌套。

阅读： Java嵌套类

Let’s see all the static keyword in java usage in a sample program.

让我们在示例程序中查看Java用法中的所有static关键字。

StaticExample.java

package com.journaldev.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;
        
    }

}

Let’s see how to use static variable, method and static class in a test program.

让我们看看如何在测试程序中使用静态变量，方法和静态类。

TestStatic.java

package com.journaldev.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);
    }
    
}

The output of the above static keyword in java example program is:

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

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

Notice that static block code is executed first and only once as soon as class is loaded into memory. Other outputs are self-explanatory.

请注意，静态块代码首先执行，并且仅在类加载到内存后才执行一次。其他输出是不言自明的。

Java静态导入 (Java static import)

Normally we access static members using Class reference, from Java 1.5 we can use java static import to avoid class reference. Below is a simple example of Java static import.

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

package com.journaldev.test;

public class A {

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

package com.journaldev.test;

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

public class B {

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

Notice the import statements, for static import we have to use import static followed by the fully classified static member of a class. For importing all the static members of a class, we can use * as in import static com.journaldev.test.A.*;. We should use it only when we are using the static variable of a class multiple times, it’s not good for readability.

注意import语句，对于静态导入，我们必须使用import static然后再使用类的完全分类的static成员。为了导入一个类的所有静态成员，我们可以像在import static com.journaldev.test.A.*;那样使用import static com.journaldev.test.A.*; 。仅当我们多次使用类的静态变量时，才应使用它，这不利于可读性。

Update: I have recently created a video to explain static keyword in java, you should watch it below.

更新：我最近创建了一个视频来解释Java中的static关键字，您应该在下面观看。

演示地址