精华内容
下载资源
问答
  • 2021-05-21 02:39:36

    static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,也可以形成静态static代码块,但是Java语言中没有全局变量的概念。

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

    只要这个类被加载,Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此,static对象可以在它的任何对象创建之前访问,无需引用任何对象。

    用public修饰的static成员变量和成员方法本质是全局变量和全局方法,当声明它类的对象市,不生成static变量的副本,而是类的所有实例共享同一个static变量。

    static变量前可以有private修饰,表示这个变量可以在类的静态代码块中,或者类的其他静态成员方法中使用(当然也可以在非静态成员方法中使用–废话),但是不能在其他类中通过类名来直接引用,这一点很重要。实际上你需要搞明白,private是访问权限限定,static表示不要实例化就可以使用,这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

    更多相关内容
  • 因为之前在百度百科上看到有位大佬说全局变量也是静态变量,毕竟全局变量也是存储在静态存储区的嘛。。 求各位大佬解释一下吧。。![图片说明]...
  • 关于Java中的静态方法,下列说法哪些是正确的() A:静态方法是一个属于类而不属于对象(实例)的方法。(√) 静态方法可以在没有创建对象实例的情况下调用,其是可以通过类名引用。 B:静态方法只能访问静态数据...

    静态方法(static method)

    先从一道笔试题说起

    关于Java中的静态方法,下列说法哪些是正确的()
    A:静态方法是一个属于类而不属于对象(实例)的方法。(√)

    静态方法可以在没有创建对象实例的情况下调用,其是可以通过类名引用。

    B:静态方法只能访问静态数据无法访问非静态数据(实例变量)。(√)

    它这边的意思是不能直接访问非静态数据(实例变量),因为非静态数据是属于对象属性的,其只有在对象存在的时候才能引用。

    C:静态方法只能调用其他静态方法,不能从中调用非静态方法。(√)

    这里也是不能直接调用非静态方法,因为非静态方法是属于某个对象的,不先实例化对象,通过对象引用,那么将无法判断具体调用哪个对象(实例)的非静态方法。

    D:静态方法不能通过类名直接访问,也不需要任何对象。(×) 静态方法可以直接用类名访问。

    类名.静态方法名() 这种方式是可以的,所以静态方法可以直接通过类名进行访问。

    简单总结

    先总结:

    • (1)静态方法中不可以直接引用实例方法(非静态方法)或实例成员变量(非静态变量);

    静态方法中引用实例方法、实例变量,须先实例化对象,然后通过 对象名.实例变量名 对象名.实例方法名( )

    • (2)静态方法、实例方法(非静态方法)都可以引用静态变量、静态方法;
      • 如果在不同类中,则是通过 类名.静态变量名类名.静态方法名( ) 的方式引用;
      • 如果是在同一个类中,则可以省略类名

    当然,要想其他类能引用其静态变量、静态方法,则其不能将这些变量、方法设置为private。

    • (3)实例方法(非静态方法)中引用实例变量、其他实例方法;
      • 如果在不同类中,则需要先实例化对象,通过对象进行引用;
      • 如果在同一个类中,则直接引用即可;
    • (4)引用(调用)静态方法的方式有两种:
      • 类名.静态方法名( )
      • 先实例化一个对象,然后通过 对象名.静态方法名( )
    • (5)静态方法中不能使用 thissuper ,而实例方法可以;

    具体案例

    通过下面的案例,可以对上面所述内容有个更加清晰的认识。

    StaticMethodTest1

    package com.yuan.test;
    
    public class StaticMethodTest1 {
        private static int staticVariable;//静态成员变量
        public static int publicStaticVariable;
        protected static int protectedStaticVariable;
        private int instanceVariable;//实例成员变量(非静态成员变量)
    
        public static void staticMethod1(){
            staticVariable = 166;//静态方法中引用静态变量
            publicStaticVariable = 101;
            protectedStaticVariable = 102;
            System.out.println("StaticMethodTest1's staticVariable ="+staticVariable);
            /*
            Non-static field 'instanceVariable' cannot be referenced from a static context
            不能从静态上下文中引用非静态变量
             */
            //instanceVariable = 555;
    
            /*
            Non-static method 'instanceMethod()' cannot be referenced from a static context
            不能从静态上下文中引用非静态方法(实例方法)的
             */
            //instanceMethod1();
    
            staticMethod2();//在当前类中的静态方法中调用当前类的其它静态方法(可省略类名)
        }
    
        public void instanceMethod1(){
            // 实例方法(非静态方法)中是可以引用非静态变量(实例成员变量)的
            instanceVariable = 100;
            // 实例方法也可以引用静态变量
            staticVariable = 177;
        }
    
        public static void staticMethod2(){
            staticVariable = 188;
        }
    
        public static void main(String[] args){
            StaticMethodTest1 staticMethodTest1 = new StaticMethodTest1();
            staticMethodTest1.instanceMethod1();
            // main方法是典型的静态方法,所以引用实例变量须通过实例对象
            System.out.println(staticMethodTest1.instanceVariable);
            System.out.println(staticVariable);
    
            staticMethod1();//在当前类中调用静态方法,可以省略类名
            System.out.println(staticVariable);
            System.out.println(publicStaticVariable);
            System.out.println(protectedStaticVariable);
        }
    }
    

    运行后结果为:

    100
    177
    StaticMethodTest1's staticVariable =166
    188
    101
    102
    

    StaticMethodTest2

    package com.yuan.test;
    
    public class StaticMethodTest2 {
        private static int staticVariable;
        public static int publicStaticVariable;
    
        public static void staticMethod1(){
            // 通过类名直接引用StaticMethodTest1类的静态方法staticMethod1
            // 引用其他类的静态方法(类名.静态方法名())
            StaticMethodTest1.staticMethod1();
            // 修改当前类中的静态变量,可以省略类名
            staticVariable = 222;
            publicStaticVariable = 221;
            // 修改其它类中的静态变量(类名.静态变量名),注意:其它类的静态变量不能是private的
            StaticMethodTest1.publicStaticVariable = 201;
            StaticMethodTest1.protectedStaticVariable = 202;
            // 除了可以使用类名直接调用静态方法,还可以通过实例对象调用静态方法
            StaticMethodTest1 staticMethodTest1 = new StaticMethodTest1();
            staticMethodTest1.staticMethod1();//会将其publicStaticVariable、protectedStaticVariable 的值又改回101、102 
        }
    
        public static void main(String[] args){
            staticMethod1();
            // 引用其他类的静态变量(类名.静态变量名)
            System.out.println(StaticMethodTest1.publicStaticVariable);
            System.out.println(StaticMethodTest1.protectedStaticVariable);
            // 引用当前类的静态变量
            System.out.println(publicStaticVariable);
        }
    
    }
    

    运行结果为:

    StaticMethodTest1's staticVariable =166
    StaticMethodTest1's staticVariable =166
    101
    102
    221
    

    如果错误,欢迎指正!谢谢!

    参考:
    java 调用静态方法和实例(对象)方法的区别

    展开全文
  • python静态变量和静态方法

    万次阅读 2019-04-15 19:36:42
    一、静态变量和静态方法 1、静态变量和静态方法都属于类的静态成员,它们与普通的成员变量和成员方法不同,静态变量和静态方法只属于定义它们的类,而不属于某一个对象。 2、静态变量和静态方法都可以通过类名和...

    一、静态变量和静态方法

    1、静态变量和静态方法都属于类的静态成员,它们与普通的成员变量和成员方法不同,静态变量和静态方法只属于定义它们的类,而不属于某一个对象。
    2、静态变量和静态方法都可以通过类名和对象进行访问。

    二、静态变量示例

    class StaticMenthod:
    count = 0 #静态变量,不需要显示的声明

    def __init__(self):
        StaticMenthod.count += 1
    
    def __del__(self):
        StaticMenthod.count -= 1
    

    sMenthod = StaticMenthod() #创建对象实例

    sMenthod.count += 1 #通过对象实例操作静态变量
    print(“sMenthod:%d”%(sMenthod.count)) #通过对象实例调用静态变量
    print(“StaticMenthod:%d”%(StaticMenthod.count)) #通过类名调用静态变量

    运行结果如下:
    在这里插入图片描述

    通过上面的测试结果可以看出通过对象实例访问静态变量和通过类名访问静态变量的结果是不一样的,由此也证明了通过对象访问实例和通过类名访问实例是互相不干扰的。

    三、静态方法

    1、静态方法相关描述
    1》、静态方法中不需要传入self参数,因此无法访问在静态方法中访问静态实例变量。
    2》、静态方法中不可以直接访问类的静态变量,但可以通过类名引用静态变量。
    3》、可以通过装饰符定义静态变量。

    2、静态方法示例

    class StaticFunc:
    str = “this is static variable!”

    @staticmethod
    def static_func():
        print("this is static function!")
    

    StaticFunc.static_func()

    sFunc = StaticFunc() sFunc.static_func()

    print(StaticFunc.str)

    运行结果如下:
    在这里插入图片描述

    通过结果分析可以知道:通过对象名调用静态方法和通过类名调用静态方法的结果是没有什么区别的。

    说明:如有错误,欢迎指正。。。

    展开全文
  • 成员变量、类变量(静态变量)、局部变量的区别

    千次阅读 多人点赞 2017-08-03 20:31:04
    变量名首写字母使用小写,如果由多个单词组成,从第2个单词开始的其他单词的首写字母使用大写。 如果局部变量的名字和成员变量的名字相同, 要想在该方法中使用成员变量,必须使用关键字this [java] view ...
    变量名首写字母使用小写,如果由多个单词组成,从第2个单词开始的其他单词的首写字母使用大写。

    如果局部变量的名字和成员变量的名字相同, 要想在该方法中使用成员变量,必须使用关键字this

    [java]  view plain  copy
    1. class People {  
    2.     String name = "类体重定义的name";         //类中的成员变量并赋值  
    3.   
    4.     People(){  
    5.     }  
    6.       
    7.     public void speak() {  
    8.         String name = "类体方法中定义的name";       //在方法speak中定义和成员变量名字相同的name并赋值  
    9.         System.out.println(name);  
    10.         System.out.println(this.name);      //通过this来访问类中的成员变量  
    11.           
    12.     }  
    13. }  
    14.   
    15.   
    16. public class TestThis {                              //源文件中只能有一个类是public类,并且源文件的名字必须与这个类的名字完全相同,如  
    17.                                                          //果没有public类,那么源文件的名字只要和某个类的名字相同就可以了。  
    18.     public static void main(String[] args) {         
    19.         People myPeople = new People();  
    20.         myPeople.speak();  
    21.     }  
    22.   
    23. }  
    输出结果:

    成员变量和局部变量的区别

           成员变量:

              1、成员变量定义在类中,在整个类中都可以被访问。

              2、成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象所在的堆内存中。

              3、成员变量有默认初始化值。

          局部变量:

              1、局部变量只定义在局部范围内,如:函数内,语句内等,只在所属的区域有效。

              2、局部变量存在于栈内存中,作用的范围结束,变量空间会自动释放。

              3、局部变量没有默认初始化值 

          在使用变量时需要遵循的原则为:就近原则

          首先在局部范围找,有就使用;接着在成员位置找。



    成员变量和类变量的区别


    由static修饰的变量称为静态变量,其实质上就是一个全局变量。如果某个内容是被所有对象所共享,那么该内容就应该用静态修饰;没有被静态修饰的内容,其实是属于对象的特殊描述。

    不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量。


    [java]  view plain  copy
    1. class MyAdd {  
    2.     int count = 0;          //成员变量计数器  
    3.     static int sum = 0;     //静态变量计数器  
    4.     String name;  
    5.       
    6.   
    7.     MyAdd(String name){  
    8.         this.name = name;  
    9.     }  
    10.       
    11.     public void myAddMethod() {    
    12.         count++;  
    13.         System.out.println(name+"调用成员变量后的值:"+count);  
    14.     }  
    15.       
    16.     public void staticAddMethod() {    
    17.         sum++;  
    18.         System.out.println(name+"调用类后变量的值:"+sum);  
    19.     }  
    20.       
    21.       
    22. }  
    23.   
    24.   
    25. public class TestThis {  
    26.   
    27.     public static void main(String[] args) {  
    28.         MyAdd add1 = new MyAdd("add1");  
    29.         MyAdd add2 = new MyAdd("add2");  
    30.           
    31.         add1.myAddMethod();  
    32.         add2.myAddMethod();  
    33.         add1.myAddMethod();  
    34.         add1.staticAddMethod();  
    35.         add2.staticAddMethod();  
    36.         add1.staticAddMethod();  
    37.     }  
    38.   
    39. }  

    输出结果:



    成员变量和类变量的区别:

       1、两个变量的生命周期不同

          成员变量随着对象的创建而存在,随着对象的回收而释放。

          静态变量随着类的加载而存在,随着类的消失而消失。

       2、调用方式不同

          成员变量只能被对象调用。

          静态变量可以被对象调用,还可以被类名调用。

       3、别名不同

          成员变量也称为实例变量。

          静态变量也称为类变量。

       4、数据存储位置不同

          成员变量存储在堆内存的对象中,所以也叫对象的特有数据。

          静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。



    static:★★★ 关键字,是一个修饰符,用于修饰成员(成员变量和成员函数)。

       特点:

       1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

       2、被静态修饰的成员,可以直接被类名所调用。也就是说,静态的成员多了一种调用方式。类名.静态方式。

        3、静态随着类的加载而加载。而且优先于对象存在。

     

    弊端:

       1、有些数据是对象特有的数据,是不可以被静态修饰的。因为那样的话,特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以,在定义静态时,必须要明确,这个数据是否是被对象所共享的。

       2、静态方法只能访问静态成员,不可以访问非静态成员。

          因为静态方法加载时,优先于对象存在,所以没有办法访问对象中的成员。

       3、静态方法中不能使用this,super关键字。

          因为this代表对象,而静态在时,有可能没有对象,所以this无法使用。

     

    什么时候定义静态成员呢?或者说:定义成员时,到底需不需要被静态修饰呢?

    成员分两种:

       1、成员变量。(数据共享时静态化)

          该成员变量的数据是否是所有对象都一样:

          如果是,那么该变量需要被静态修饰,因为是共享的数据。 

          如果不是,那么就说这是对象的特有数据,要存储到对象中。 

       2、成员函数。(方法中没有调用特有数据时就定义成静态)

          如果判断成员函数是否需要被静态修饰呢?

          只要参考,该函数内是否访问了对象中的特有数据:

          如果有访问特有数据,那方法不能被静态修饰。

          如果没有访问过特有数据,那么这个方法需要被静态修饰。


    成员变量和静态变量的区别:

       1、成员变量所属于对象。所以也称为实例变量。

          静态变量所属于类。所以也称为类变量。

       2、成员变量存在于堆内存中。

          静态变量存在于方法区中。

       3、成员变量随着对象创建而存在。随着对象被回收而消失。

          静态变量随着类的加载而存在。随着类的消失而消失。

       4、成员变量只能被对象所调用 。

          静态变量可以被对象调用,也可以被类名调用。

       所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据。



    成员变量:包括实例变量和类变量,用static修饰的是类变量,不用static修饰的是实例变量,所有类的成员变量可以通过this来引用。
    局部变量:包括形参,方法局部变量,代码块局部变量,存在于方法的参数列表和方法定义中以及代码块中。
     
    1.成员变量可以被public,protect,private,static等修饰符修饰,而局部变量不能被控制修饰符及 static修饰;两者都可以定义成final型。
     
    2.成员变量存储在堆,局部变量存储在栈。局部变量的作用域仅限于定义它的方法,在该方法的外部无法访问它。成员变量的作用域在整个类内部都是可见的,所有成员方法都可以使用它。如果访问权限允许,还可以在类的外部使用成员变量。
     
    3.局部变量的生存周期与方法的执行期相同。当方法执行到定义局部变量的语句时,局部变量被创建;执行到它所在的作用域的最后一条语句时,局部变量被销毁。类的成员变量,如果是实例成员变量,它和对象的生存期相同。而静态成员变量的生存期是整个程序运行期。
     
    4.成员变量在累加载或实例被创建时,系统自动分配内存空间,并在分配空间后自动为成员变量指定初始化值,初始化值为默认值,基本类型的默认值为0,复合类型的默认值为null。(被final修饰且没有static的必须显式赋值),局部变量在定义后必须经过显式初始化后才能使用,系统不会为局部变量执行初始化。
     
    5.局部变量可以和成员变量 同名,且在使用时,局部变量具有更高的优先级,直接使用同名访问,访问的是局部变量,如需要访问成员变量可以用this.变量名访问


    先看下面两段程序:

    程序一:
    public class Variable
    {
    int i;
    void test()
    {
       int j=8;
       if(j==i)
        System.out.println("相等");
       else
        System.out.println("不相等");
    }
    public static void main(String[] args)
    {
       Variable v=new Variable();
       v.test();
    }
    }

    程序二:
    public class Variable
    {
       void test()
    {
       int i;
       int j=8;
       if(j==i)
        System.out.println("相等");
       else
        System.out.println("不相等");
    }
    public static void main(String[] args)
    {
       Variable v=new Variable();
       v.test();
    }
    }

    ----------------------------------------------------------------------------------------------------------

    第一个程序很正常,编译时不会出错。第二个程序编译时会提示如下错误:

    D:\Program\java\test>javac Variable.java
    Variable.java:9: 可能尚未初始化变量 i
                    if(j==i)
                          ^
    1 错误

    之所以会出现这样的错误是因为:成员变量有默认值,(被final修饰且没有static的必须显式赋值),局部变量不会自动赋值

    ===========================================================

    类体分为两部分。变量定义部分所定义的变量被称为类的成员变量,在方法体中定义的变量和方法的参数都被称为局部变量

    java中成员变量和局部变量的区别

    1.成员变量可以被public,protect,private,static等修饰符修饰,而局部变量不能被控制修饰符及static修饰;两者都可以定义成final型
    2.成员变量存储在堆,局部变量存储在栈
    3.存在时间不同
    4.成员变量有默认值,(被final修饰且没有static的必须显式赋值),局部变量不会自动赋值
    -------------------------------------------------------------------------------------------------------------
    顾名思意了
    什么是局部,方法内部,块内部都是局部,执行指令退出那个局部,局部变量自动清除

    比如方法中,不用说
    块中
    {
      int i=0; //这是一个局部变量,它的作用范围就在其中 
    }

    成员变量就会涉及到谁的成员,类的成员?实例的成员?

    class A{
    int i=0; //实例的成员
    static j=1;//类的成员
    }

    static 的差别,是否依赖于实例而存在
    ----------------------------------------------------------------------------------------------------------

    成员变量:作为类的成员而存在,直接存在于类中。

    局部变量:作为方法或语句块的成员而存在,存在于方法的参数列表和方法定义中。

    局部变量在使用前必须被程序员主动的初始化,和此形成对比,系统中的成员变量则会被系统提供一个默认的初始值。所以在语法上,类的成员变量能够定义后直接使用,而局部变量在定义后先要赋初值,然后才能使用。

     

    所有类的成员变量可以通过this来引用。成员变量又分成俩中类型:实例变量和静态变量。静态变量在定义时要使用static关键字。



    展开全文
  • 变量可以分为:全局变量静态全局变量静态局部变量和局部变量。 按存储区域分,全局变量静态全局变量静态局部变量都存放在内存的静态 存储区域,局部变量存放在内存的栈区。 按作用域分,全局变量在整个...
  • 以下关于Python缩进的描述中,错误的是在工业企业综合生产计划工作中,对品种指标的优化可采用A:销售收入和利润分析法B:线性规划法C:销售人员意见综合法D:盈亏平衡分析法下面对静态数据成员的描述中,正确的是A:类的...
  • 类内静态成员变量的定义和声明

    千次阅读 2021-02-24 14:33:09
    但是这种情况在C++类内静态变量的定义中存在特殊情况,也就是只声明、不定义、即使用。 1、对于一般的类内专属常量,遵循类内声明,类外定义。该类内专属常量最好使用static const修饰,对于不需要修改指向对象的...
  • Java面试题(带答案)

    千次阅读 2021-03-15 14:06:52
    A: 程序会打出 \B: 程序会抛出 NullPointerException C: 非静态变量不能够被静态方法引用D: 编译器会抛出 \的错误 答案:C19,HashMap和HashTable的描述错误的是? ( )A: 他们都实现了Map接口。B: HashMap非线程...
  • 昨天在修改项目函数功能时,在其中一个类中添加了一个静态成员变量和两个静态成员函数,结果在链接时出现一个非常典型的错误:“The follwing symbols referenced in processor “p0” could not be resolved:Class:...
  • 当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有... 静态成员变量不能在类中初始化,实际上类的定义只是在描述对象的蓝图,在其中指定初值是不允许的。也不能在类的构造...
  • 第三章 封装

    千次阅读 2020-04-18 19:43:51
    下列关于构造方法的描述错误的是() 2分 A、一个类中只能定义一个空参数的构造方法 B、一个类中可以定义多个构造方法 C、构造方法的方法名前面没有返回值类型的声明 D、在构造方法中不能使用return语句返回一个值...
  • 1.下面有关static类变量和实例变量描述,正确的有? static类变量又叫静态成员变量,它不需要创建对象就可以已经在内存中存在了 在创建实例对象的时候,内存中会为每一个实例对象的每一个非静态成员变量...
  •  在IDE开发工具大行其道的今天,对于编译的一些概念很多人已经不再清楚了,很多程序员最怕的就是处理连接错误(LINK ERROR), 因为它不像编译错误那样可以给出你程序错误的具体位置,你常常对这种错误感到懊恼,但是...
  •  static变量也称作静态变量静态变量和非静态变量的区别是:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的,在创建对象的时候被初始化,...
  • 在c++中,下列描述错误的是( )

    千次阅读 2020-09-12 20:42:12
    1.静态方法只能访问静态成员(包括成员变量和成员方法) 非静态方法可以访问静态也可以访问非静态 2.静态方法中不可以定义this,super关键字 因为 一个类中,一个static变量只会有一个内存空间,虽然有多个类实例,...
  • 来看看下面这段代码,Context对象为静态的,那么Activity就无法正常销毁,会常驻内存。 public class MainActivity extends Activity{ public static Context mContext; @Override protected void onCreate...
  • 下面有关java final的基本规则,描述错误的是? Afinal修饰的类不能被继承 Bfinal修饰的成员变量只允许赋值一次,且只能在类方法赋值 Cfinal修饰的局部变量即为常量,只能赋值一次。 Dfinal修饰的方法不允许被子类...
  • mysql变量之系统静态变量、状态变量

    千次阅读 2012-11-09 10:34:32
    初学mysql的时候,一直觉得其系统环境变量...Mysql的变量分为三种:系统静态变量、系统动态变量和系统状态变量,在这里介绍了一下系统静态变量和状态变量,记录如下:   变量名称 解释说明 默认值
  • C++类静态成员与类静态成员函数    当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有...
  • 静态变量,局部变量,全局变量

    千次阅读 2012-07-19 01:25:46
    静态变量当然是属于静态存储方式,但是属于静态存储方式的量不一定就是静态变量,例如外部变量虽属于静态存储方式,但不一定是静态变量,必须由 static加以定义后才能成为静态外部变量,或称静态全局变量。...
  • 下面对静态数据成员的描述中,正确的是? 正确答案: D 你的答案: 空 (错误) 静态数据成员可以在类体内进行初始化 静态数据成员不可以被类的对象调用 静态数据成员不受private控制符的作用 ...
  • jdk8.0 内存划分

    千次阅读 2021-03-09 00:00:48
    下图所示:方法区(Method Area)与Java堆一样,是各个线程共享的内存区域,它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分,...
  • Java面向对象练习题含解析(三)

    万次阅读 多人点赞 2021-04-07 20:30:11
    19、下列关于静态变量描述中,错误的是( ) A、静态变量指的是被static修饰的变量 B、静态变量是随着类的加载而加载 C、静态变量可以被所有的实例对象共享 D、静态变量同成员变量一样,都需要通过实例对象来调用...
  • 静态变量在多线程中的使用问题

    千次阅读 2013-05-17 09:57:17
    1、现象:问题描述  用户登陆门户网站页面后,通过SSO(single sign on)访问另一个网站,如果此Session超时,用户再进行操作会提示:必须先登陆才允许操作,但是当用户点击页面的返回按钮时,返回的页面并非...
  • 下面关于静态变量描述,正确的是( ) A: 静态变量可以定义在类中的任意位置 B: 静态变量一但被赋值不能被修改 C: 静态变量可以被类直接调用,因此可以说静态变量的生命周期与实例无关 D: 以上都不对 A、A B C D B...
  • 1、栈区(stack)— —由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。 2、堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收。...
  • 讨论全局变量之前我们先要明白几个基本的概念:  1. 编译单元(模块):  在IDE开发工具大行其道的今天,对于编译的一些概念很多人已经不再清楚了,很多程序员最怕的就是处理连接错误(LINK ERROR), 因为它不...
  • C++类静态成员与类静态成员函数    当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 204,599
精华内容 81,839
关键字:

关于静态变量的描述错误的是