精华内容
下载资源
问答
  • 静态变量存储哪个区
    万次阅读
    2019-06-26 22:40:35
    静态变量存储在__区 
    A 全局区 
    B 堆 
    C 栈 
    D 常量区
    

    参考答案:A


    知识点

    内存到底分几个区?

    1、栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。

    2、堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由os回收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表。

    3、全局区(静态区)(static)—全局变量静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后有系统释放。

    4、文字常量区 — 常量字符串就是放在这里的。 程序结束后由系统释放。

    5、程序代码区 — 存放函数体的二进制代码

    更多相关内容
  • 静态变量只存在于函数作用域内,也就是说,静态变量只存活栈中。一般的函数内变量函数结束后会释放,比如局部变量,但是静态变量却不会。就是说,下次再调用这个函数的时候,该变量的值会保留下来。 只要变量...
  •  ● 静态变量是基本数据类型,这种情况下类的外部不必创建该类的实例可以直接使用  ● 静态变量是一个引用。这种情况比较特殊,主要问题是由于静态变量是一个对象的引用,那么必须初始化这个对象之后才能将...
  • 静态方法(实际上所有方法)以及静态变量都存储PermGen部分,因为它们是反射数据的一部分(类相关数据,而不是与实例相关的)。需要澄清的最新情况:注意,只有变量及其技术值(原语或引用)存储PermGen空间中。如果...

    静态方法(实际上所有方法)以及静态变量都存储在PermGen部分,因为它们是反射数据的一部分(类相关数据,而不是与实例相关的)。

    需要澄清的最新情况:

    注意,只有变量及其技术值(原语或引用)存储在PermGen空间中。

    如果静态变量是对象的引用,则该对象本身存储在堆的正常部分(年轻/旧代或幸存者空间)。这些对象(除非它们是类等内部对象)是不存储在PermGen空间。

    例子:static int i = 1; //the value 1 is stored in the PermGen sectionstatic Object o = new SomeObject(); //the reference(pointer/memory address) is stored in the PermGen section, the object itself is not.

    一个关于垃圾收集的词:

    做不倚靠finalize()因为它不一定会跑。这完全取决于JVM何时运行垃圾收集器和收集什么,即使一个对象符合垃圾收集的条件。

    当然,您可以将静态变量设置为NULL,从而删除对堆上对象的引用,但这并不意味着垃圾回收器将要收集它(即使没有更多的参考资料)。

    另外finalize()只运行一次,因此您必须确保它不会引发异常或以其他方式阻止对象被收集。如果您通过某些异常停止了终结,finalize()不会再次在同一个对象上调用。

    最后注意事项代码、运行时数据等的存储方式取决于所使用的JVM,即HotSpot可能与JRockit不同,甚至在相同JVM的不同版本之间也可能有所不同。上面的内容是基于HotsforJava 5和6的(它们基本上是相同的),因为在回答时,我想说大多数人都使用这些JVM。由于Java 8时内存模型发生了重大变化,上述语句可能不适用于Java 8 HotSpot-而且我没有检查Java 7 HotSpot的更改,所以我猜以上对于那个版本仍然是正确的,但我在这里不确定。

    展开全文
  • 众所周知,Python语言并不支持静态变量,比如下面这样一个应用场景: void foo() {  static int count = 0;  count ++; } Python中无法自然实现这个功能。换个角度来看这个问题,函数中的静态变量其实...
  • 本文实例讲述了C#中static静态变量的用法。分享给大家供大家参考。具体如下: 使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员static修饰符可用于类、字段、方法、属性、运算符、事件和构造函数,...
  • kotlin定义静态变量、方法可以采用伴生对象companion object的方式。 下面这篇文章主要给大家介绍了关于Kotlin使用静态变量与静态方法的相关资料,需要的朋友可以参考下
  • 本文主要介绍了C++中的局部变量、全局变量、局部静态变量、全局静态变量的区别。具有很好的参考价值,下面跟着小编一起来看下吧
  • 本文实例讲述了JS中类的静态方法,静态变量,实例方法,实例变量区别与用法。分享给大家供大家参考,具体如下: 1.类的静态方法 先来段代码之后分析 // JS类静态函数 function BaseClass() { } // 类添加add函数 ...
  • wpf 给控件绑定静态变量,静态变理改变后控件上的值随着变量的demo,这只是个demo,具体应用场景可以根据实际的情况进行调整,本demo使用 vs2019进行编写。
  • 即使局部静态变量定义时没有赋初值,系统会自动赋初值0(对数值型变量)或空字符(对字符变量);静态变量的初始值为0。4.当多次调用一个函数且要求调用之间保留某些变量的值时,可考虑采用静态局部变量。虽然用...
  • 下面小编就为大家带来一篇利用反射获取Java类中的静态变量名及变量值的简单实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • C++之类的静态变量

    2020-09-03 14:12:50
    主要介绍了C++之类的静态变量的相关资料,需要的朋友可以参考下
  • 主要介绍了spring boot静态变量注入配置文件的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 本文实例讲述了C#静态变量与实例变量的具体用法,分享给大家供大家参考。具体分析如下: 1)语法定义上的区别: 类变量也叫静态变量静态变量前要加static关键字,而实例变量前则不加; 实例变量也叫对象变量,...
  • 主要介绍了python类和函数中使用静态变量的方法,实例分析了三种常用的实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了浅析C#静态类,静态构造函数,静态变量 的相关资料,非常不错具有参考借鉴价值,需要的朋友可以参考下
  • static所声明的变量Java中有一个初始化的先后顺序,带着这个问题接下来我们就来进行Java中static静态变量的初始化完全解析:
  • (1)加局部变量的前面使之成为静态局部变量,作用域还是函数内部,可是生存周期延长了。 (2)加全局变量的前面限定该变量作用域为文件作用域,就是说即使其他文件使用了extern扩展作用域也不行。这C语言的...
  • php 静态变量的初始化

    2020-10-29 14:23:20
    php的成员变量可以声明的同时进行初始化,但是只能用标量进行初始化。
  • 本篇文章主要介绍了spring 如何将配置信息注入静态变量的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 静态成员变量: 类体中的数据成员的声明前加上static关键字,该数据成员就成为了该类的静态数据成员。和其他数据成员一样,静态数据成员也遵守public/protected/private访问规则。同时,静态数据成员还具有以下特点...
  • 主要介绍了springboot 使用yml配置文件给静态变量赋值教程,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 数据成员可以分静态变量、非静态变量两种. 静态成员:静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态...
  • 静态变量和非静态变量的区别
  • 下面小编就为大家带来一篇C++静态成员函数不能调用非静态成员变量(详解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java静态变量怎么声明?

    千次阅读 2021-02-12 19:10:26
    展开全部个人的总结1 静态变量e69da5e6ba9062616964757a686964616f31333337616564只有一份被类的所有实例共享2 静态变量的声明编译时已经明确了内存的位置3 延迟初始化是改变静态变量的值引用Java静态变量的初始化...

    展开全部

    个人的总结

    1 静态变量e69da5e6ba9062616964757a686964616f31333337616564只有一份被类的所有实例共享

    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."":()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."":()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."":()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."":()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 ;

    const #8 = Asciz ()V;

    const #9 = Asciz Code;

    const #10 = Asciz LineNumberTable;

    const #11 = Asciz ;

    const #12 = Asciz SourceFile;

    const #13 = Asciz Test.java;

    const #14 = NameAndType #7:#8;// "":()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."":()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); } }

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

    2Q==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,256,530
精华内容 502,612
关键字:

静态变量在哪里