当前位置：主页 > JAVA语言

java中static成员变量-static变量 java

发布时间：2023-05-18 09:21 浏览次数：次作者：佚名

（一）什么情况下我们要使用static呢？

1、只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创建对象。

2、我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能

调用的方法。

（二）static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码

块，但是Java语言中没有全局变量的概念。

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有

实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，

static对象可以在它的任何对象创建之前访问，无需引用任何对象。

（三）（1）用public修饰static成员，表示它们是全局成员（成员变量和成员方法），当生成类的对象时，不

为每一个对象生成static变量的副本，Java只为static变量生成一个副本，所有的类的对象共享这一个副本；

当不存在任何类对象时，要访问一个public的static成员，用类名.成员访问。

（2）用private修饰的static成员，只能通过该类的方法进行访问。如果不存在任何类的对象时访问一

个private的static成员，则必须提供一个public的static方法，并且在调用该方法时，必须添加类名和点运算

符以进行限制。

（四）static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语

法为：

（1）类名.静态方法名(参数列表...)

（2）类名.静态变量名

（3）static {

// whatever code is needed for initialization goes here

}

形如这样的式子----用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码

块

（五）static变量

按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量

；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：

对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完

成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。

对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝

，互不影响（灵活）。

类中static变量初始化_java中static成员变量_static变量 java

（六）静态方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键

字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属

类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是

记忆！

因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

（七）static代码块

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便

放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它

们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：

public class Test5 {

private static int a;

private int b;

static{

Test5.a=3;

System.out.println(a);

Test5 t=new Test5();

t.f();

t.b=1000;

System.out.println(t.b);

}

static{

Test5.a=4;

System.out.println(a);

}

public static void main(String[] args) {

// TODO 自动生成方法存根

}

static{

Test5.a=5;

static变量 java_类中static变量初始化_java中static成员变量

System.out.println(a);

}

public void f(){

System.out.println("hhahhahah");

}

运行结果：

hhahhahah

1000

这个例子的运行顺序是：首先Java虚拟机调用main方法（因为mian方法是程序的入口），main方法位于Test5类

中，此main方法是静态的java中static成员变量，此时Java解释器查找路径，找到Test5.class文件，加载Test5.class。于此同时静

态初始化开始了（包括静态变量和静态代码块的初始化，静态方法（除了main）不可以初始化，只可以用实例

方法、静态方法调用或者类名、对象调用）。

（八）总结static变量和方法的访问限制：

（1）实例方法可以访问实例变量和实例方法

（2）实例方法可以访问静态变量和静态方法

（3）静态方法可以访问静态变量和静态方法

（4）静态方法不能访问实例变量和实例方法。静态方法中不能使用关键字this和super

（九）static final一起修饰的作用

从字面意思看，表示全局常量。static final修饰的变量只占据“一段”存储空间，这个存储空间不可以改变

。也就是赋予它的值是不可以改变的。如果是基本类型，那么数值不可变；如果是引用变量，那么引用变量不

变，一旦引用被初始化指向一个对象，就不可以把它指向另一个对象java中static成员变量，但是这个对象的内容可以改变，也就是

说这个对象里面的变量的值可以改变。比如：下面标记***的地方

//: c06:FinalData.java

import com.bruceeckel.simpletest.*;

import java.util.*;

class Value {

java中static成员变量_类中static变量初始化_static变量 java

int i; // Package access

public Value(int i) { this.i = i; } // ***注意;这里的i就是类的内容可以改变***

}

public class FinalData {

private static Test monitor = new Test();

private static Random rand = new Random();

private String id;

public FinalData(String id) { this.id = id; }

// Can be compile-time constants:

private final int VAL_ONE = 9;

private static final int VAL_TWO = 99;

// Typical public constant:

public static final int VAL_THREE = 39;

// Cannot be compile-time constants:

private final int i4 = rand.nextInt(20);

static final int i5 = rand.nextInt(20);

private Value v1 = new Value(11);

private final Value v2 = new Value(22);

private static final Value v3 = new Value(33);

// Arrays:

private final int[] a = { 1, 2, 3, 4, 5, 6 };

public String toString() {

return id + ": " + "i4 = " + i4 + ", i5 = " + i5;

}

public static void main(String[] args) {

FinalData fd1 = new FinalData("fd1");

//! fd1.VAL_ONE++; // Error: can't change value

fd1.v2.i++; // Object isn't constant!

fd1.v1 = new Value(9); // OK -- not final

for(int i = 0; i < fd1.a.length; i++)

类中static变量初始化_static变量 java_java中static成员变量

fd1.a[i]++; // Object isn't constant!

//! fd1.v2 = new Value(0); // Error: Can't

//! fd1.v3 = new Value(1); // change reference

//! fd1.a = new int[3];

System.out.println(fd1);

System.out.println("Creating new FinalData");

FinalData fd2 = new FinalData("fd2");

System.out.println(fd1);

System.out.println(fd2);

monitor.expect(new String[] {

"%% fd1: i4 = //d+, i5 = //d+",

"Creating new FinalData",

"%% fd1: i4 = //d+, i5 = //d+",

"%% fd2: i4 = //d+, i5 = //d+"

});

}

} ///:~

例（二）

package c06.net;

class Value{

static int c=0;

Value(){

c=15;

}

Value(int i){

c=i;

}

static void inc(){

c++;

}

java中static成员变量_static变量 java_类中static变量初始化

}

class Count{

public static void prt(String s){

System.out.println(s);

}

Value v=new Value(10);

static Value v1,v2;

static{