java静态变量定义

‘壹’ java静态变量的基本介绍

1·、static应用范围：可用于内部类、方法和变量。
2、标记一个方法为static，意味着这个方法，被所在类的所有实例公用，在类装载时被首先执行，执行一次即被所有该类的实例共享，同时意味着：
A、static方法内部不能引用非static变量。
B、static方法不能被子类重写为非static方法。
C、父类的非static方法不能被子类重写为static方法。
D、static代码块可以用static {}来完成，在类被第一次装载时执行初始化，先于静态方法和其他方法的执行。
3、标记一个变量为static，则该变量在内存中有不变的位置，相当于全局变量，所有类的实例都访问同一个存储变量区域。对其修改对于所有类的实例来说都是可见和一致的。

‘贰’ java中什么叫静态成员变量麻烦告诉我

在java变量分为实例变量和静态变量
方法实例方法和静态方法如class Example{
int data;//定义实例变量，也叫成员变量
public void method(){
.....}static int count = 0;//定义静变量
public static func(){ //静态方法
......}public void static main(String arg[]){
Example e = new Example();//实例化一个对象
e.data = 0;//若要调用实例变量，则必须通过对象e来调用
count++;//要调用静态变量，则在这里直接调用
//同样，实例方法和静态方法也是如此}}如果要在其它类中调用实例变量，则用 类.对象.实例变量，(如果实例变量是public)
若调用静态方法，用 类.方法 调用。
实例变量和实例方法是 对象的属性，
而静态变量和静态方法是 类的属性。

‘叁’ java 静态初始化块中是否可以定义静态变量

静态变量只能定义在类的内部，不可以定义在静态块或方法中
可以在类内部定义静态变量，在静态块中进行初始化操作，因为类的内部是不允许有操作语句存在的，比如JDBC操作，所以可以在静态块static{} 中进行初始化操作，如：JDBC
定义静态变量主要是为了供外部访问，定义在一个局部中外部没有权限访问，为什么要定义呢，而且不能定义

‘肆’ 谁能详细说明java中什么样的是静态成员变量

Java类中的静态变量在程序运行期间，其内存空间对所有该类的对象实例而言是共享的，有些时候可以认为是全局变量。因此在某些时候为了节省系统内存开销、共享资源，可以将类中的一些变量声明为静态变量。
因为静态变量生命周期较长，而且不易被系统回收，因此如果不能合理地使用静态变量，就会适得其反，造成大量的内存浪费，所谓过犹不及。因此，建议在具备下列全部条件的情况下，尽量使用静态变量：
（1）变量所包含的对象体积较大，占用内存较多。
（2）变量所包含的对象生命周期较长。
（3）变量所包含的对象数据稳定。
（4）该类的对象实例有对该变量所包含的对象的共享需求。
如果变量不具备上述特点建议你不要轻易地使用静态变量，以免弄巧成拙。

‘伍’ java静态变量怎么声明

个人的总结
1 静态变量只有一份被类的所有实例共享
2 静态变量的声明在编译时已经明确了内存的位置
3 延迟初始化是改变静态变量的值
引用

Java静态变量的初始化（static块的本质）

在网上看到了下面的一段代码：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

上述代码会打印出什么结果来呢？10还是20？本文将以此代码为引子，着重讨论一下静态变量的初始化问题。 楼主可以找组织先记下175再来记下161最后填写984就会出现扣裙问题1：静态变量如何初始化

Java类中可以定义一个static块，用于静态变量的初始化。如：

1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6. }

public class Test { public static int _i; static { _i = 10; } }

当然最常用的初始化静态变量的操作是在声明变量时直接进行赋值操作。如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

那么上述两例在本质上有什么区别吗？回答是没有区别。两例代码编译之后的字节码完全一致，通过 “javap -c”查看到的字节码如下：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: return

}

通过字节码还可以看出，当类的定义中不含有static块时，编译器会为该类提供一个默认的static块。当然这是在含有静态变量初始化操作的前 提下。如果静态变量没有初始化操作，则编译器不会为之提供默认的static块。如：

1. public class Test {
2. public static int _i;
3. }

public class Test { public static int _i; }

其字节码的表现形式为：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

}

由于静态变量是通过赋值操作进行初始化的，因此可以通过静态函数返回值的方式为其初始化。如：

1. public class Test {
2. public static int _i = init();
3.
4. private static int init() {
5. return 10;
6. }
7. }

public class Test { public static int _i = init(); private static int init() { return 10; } }

其本质与下面的代码相同：

1. public class Test {
2. public static int _i;
3. static {
4. _i = init();
5. }
6.
7. private static int init() {
8. return 10;
9. }
10. }

public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }

问题2：JDK如何处理static块

类定义中可以存在多个static块吗？回答是可以。如：

1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6.
7. public static void main(String[] args) {
8. }
9.
10. static {
11. _i = 20;
12. }
13. }

public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }

此类编译之后的字节码为：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

public static void main(java.lang.String[]);
Code:
0: return

static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: bipush 20
7: putstatic #2; //Field _i:I
10: return

}

观察static{}部分可以看出，上例的代码与下面的代码效果一致：

1. public class Test {
2. public static int _i;
3.
4. public static void main(String[] args) {
5. }
6.
7. static {
8. _i = 10;
9. _i = 20;
10. }
11. }

public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }

此例可以证明，不仅类定义中可以有多个static块，而且在编译时编译器会将多个static块按照代码的前后位置重新组合成一个static 块。
问题3：如何看待静态变量的声明

静态变量存放在常量池之中。如何证明呢？如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

使用“javap -c -verbose”查看其字节码的内容如下：

public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 49
Constant pool:
const #1 = Method #4.#14; // java/lang/Object."<init>":()V
const #2 = Field #3.#15; // Test._i:I
const #3 = class #16; // Test
const #4 = class #17; // java/lang/Object
const #5 = Asciz _i;
const #6 = Asciz I;
const #7 = Asciz <init>;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz <clinit>;
const #12 = Asciz SourceFile;
const #13 = Asciz Test.java;
const #14 = NameAndType #7:#8;// "<init>":()V
const #15 = NameAndType #5:#6;// _i:I
const #16 = Asciz Test;
const #17 = Asciz java/lang/Object;

{
public static int _i;

public Test();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 2: 0

static {};
Code:
Stack=1, Locals=0, Args_size=0
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
LineNumberTable:
line 3: 0

}

我们看到，常量池中const #2指向的就是Test._i，也就是静态变量。静态变量被保存到常量池中的工作原理这里不深入讨论。在此需要注意的是：

* 静态变量的声明与初始化是两个不同的操作；
* 静态变量的声明在编译时已经明确了内存的位置。

如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

上述代码的本质可以视为：

1. public class Test {
2. // 静态变量的声明
3. public static int _i;
4.
5. // 静态变量的初始化
6. static {
7. _i = 10;
8. }
9. }

public class Test { // 静态变量的声明 public static int _i; // 静态变量的初始化 static { _i = 10; } }

由于静态变量的声明在编译时已经明确，所以静态变量的声明与初始化在编码顺序上可以颠倒。也就是说可以先编写初始化的代码，再编写声明代码。如：

1. public class Test {
2. // 静态变量的初始化
3. static {
4. _i = 10;
5. }
6.
7. // 静态变量的声明
8. public static int _i;
9. }

public class Test { // 静态变量的初始化 static { _i = 10; } // 静态变量的声明 public static int _i; }

对初始问题的解答

解答了上述三个问题，让我们再来看看开篇提到的问题。代码如下：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

其本质可以用下面的代码表示：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i;
6. static {
7. _i = 10;
8. }
9.
10. public static void main(String[] args) {
11. System.out.println(_i);
12. }
13. }

public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

再简化一下，可以表示为：

1. public class Test {
2. public static int _i;
3.
4. static {
5. _i = 20;
6. _i = 10;
7. }
8.
9. public static void main(String[] args) {
10. System.out.println(_i);
11. }
12. }

public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

至此，代码已经明确告诉我们打印结果是什么了！

‘陆’ java 静态变量和静态常量

• 静态变量是属于静态存储方式，但是属于静态存储方式的量不一定就是静态变量，例如外部变量虽属于静态存储方式，但不一定是静态变量，必须由static加以定义后才能成为静态外部变量，或称静态全局变量。

• 对于自动变量，它属于动态存储方式。但是也可以用static定义它为静态自动变量，或称静态局部变量，从而成为静态存储方式。由此看来，一个变量可由static进行再说明，并改变其原有的存储方式。

• 而在以Pascal为代表的许多程序语言中，所有局部变量都由系统自动分配存储空间，而所有全局变量的存储空间则以静态分配的方式获取，因此由于实际上“局部变量”和“全局变量”这两个术语已足以涵盖所有的情况，在这些程序语言中通常不使用“静态变量”这一术语，而直接以“全局变量”代之。

• 在这些程序语言中，静态变量就是全局变量，而即使在有明确区分全局和静态变量的程序语言中，在编译后的代码里二者也以相同的方式获取存储空间。而今术语“静态变量”的概念则主要基于C族语言的“static”的定义。

• 静态变量也可以用于存储常数。具体来说，静态变量可用const，constant或final等关键字标识，这时其值就会在编译时设定，并且无法在运行时改变。编译器通常将静态常量与文本一起置于目标文件的文本区域，而非常量初始化数据则置于数据区

‘柒’ java中什么是静态变量，什么是常量

在C++中(以及其他一些语言，如 C#，Java 等面向对象的语言中)类的成员变量被声明为static（称为静态成员变量），意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见。
比如在某个类A中声明一个static int number;初始化为0。这个number就能被所有A的实例共用。在A的构造函数里加上number++，在A的析构函数里加上number--。那么每生成一个A的实例，number就加一，每销毁一个A的实例，number就减一，这样，number就可以记录程序中共生成了多少个A的实例。
这只是静态成员的一种用法而已。

常量(constant）
也称常数，是一种恒定的或不可变的数值或数据项。
它们可以是不随时间变化的某些量和信息，也可以是表示某一数值的字符或字符串，常被用来标识、测量和比较。

‘捌’ java 静态函数中的变量定义

局部变量好像不能用静态修饰吧……因为局部变量它定义的局部使用，不能长期存在，而静态变量会一直保存在内存中，两者本质上是冲突的
变量分成局部变量和成员变量，成员变量又分成类变量（用static修饰）和实例变量，静态方法可以调用所有的成员变量，普通方法只能调用非静态变量，也就是实例变量

‘玖’ 在Java中，到底什么是静态变量呢

答：在程序开发时，我们经常希望一个变量和方法不随对象的改变而改变，甚至在没有创建对象时也能访问数据和方法，这时就可以在数据和方法上加上Static关键字，被Static修饰的数据就叫做静态变量（数据）而方法就叫静态方法。静态变量在内存中的地址是相同的，所以对于同一类的不同对象，它们静态变量的值肯定是相同的。