精华内容
下载资源
问答
  • 关于static关键字

    2017-08-09 14:10:20
    static关键字的理解

    这篇文章归类到了c++中是因为第一次学习static是在c++中,但实际上真正较好地理解它却是在最近看的Java中。

    static本身的中文解释为“静态的”,这与咱们的编程语言中的含义是一样的。通俗来说,只要变量/方法用static修饰了,它“已经静静地在那里存在了”。

    具体来看例子更好理解,用c++的语法来写:

    1.static变量

    int i;
    static int j;

    相当简单的两行代码,第一行定义了一个整型变量i,但没有对它进行初始化,因此它的值将是不确定的。 

    第二行同样定义了一个整型变量j,同样也没有初始化,但用static关键字进行了修饰。这样一来即使我没有对j初始化,j也有了默认值0。

    不相信的同学可以cout验证一下。

    这里说明了第一个事:static修饰的变量具有默认初始值0(当然这不仅限于int类型,double/float/char等等基本类型都一样,同样我们可以进行验证)。

    接下来看下面的代码

    void my_method()
    {
        int k=0;
        static int m;
    }
    
    int main() 
    {
        my_method();
        m++;
        cout<<m<<endl;
        //cout<<k<<endl;
        retrun 0;
    }

    这段代码如果去掉倒数第三行的注释符号(即加上cout<<k<<endl;这句)一定是编译不过的,因为我们都知道k是一个局部变量,它的生存期随my_method()函数结束而结束。

    但static变量就不一样了:即使变量所在的函数运行结束,变量依然存在并保持它的当前值,并且可以继续在后续代码中使用。这就是static修饰变量的第二个用法。

    回头看在文章开头的那个说法,顺带总结一下static变量:

    只要变量/方法用static修饰了,它“已经静静地在那里存在了”——这意味着static变量在未初始化时有默认值0,且一直存在,在程序运行过程中不会因为函数结束而消失。

    2.static方法(函数)和存在于类中的static

    在一块儿我认为大家应该用面向对象的思维来理解,一方面是因为下面的代码要写类(class)了,但不会很复杂。另一方面,或许比较敏感的同学发现了文章开头的那种通俗说法“只要变量/方法用static修饰了”这半句没有包括对象。这么做有两方面原因:第一是我个人在没接触Java时认为对象也是个变量,只不过比较特殊而已(当然现在我已经改变了这个错误的想法,《Java编程思想》(《Think in Java》为英文原著)让我明白了创建一个对象实际上是创建了它的一个“引用”(更准确来说更像是指针));第二是我认为对象是和类分不开的,因为至今还没看见过static class这种用法。

    说了这么多,还是来看下面的代码:

    class my_class
    {
    private:
        static int i;
    public:
        void my_method(){i++;}
        static void my_s_method(){i++;}
        void show(){cout<<i<<endl;}
    };

    类声明过后在主函数做一些操作:

    int main()
    {
        my_class.my_s_method();
        my_class a;
        a.show();
        return 0;
    }

    运行结果将是

    1
    
    仔细看,我们做了这么一个工作:直接通过类名调用类之中的静态方法(函数)而没有定义对象。对于类中静态的方法,这么做完全没问题,但对非静态的方法则是错误的。

    同样的,对静态变量我们也可以通过类名访问。即

    my_class.i++
    到此为止,static很经典的用法基本上就讲完了。斗胆引用《Java编程思想》(《Think in Java》为英文原著)中的一段话做个全面性的理解,同时也为这篇文章作结:

    尽管当static作用于某个字段时,肯定会改变数据创建的方式(因为一个static字段对每个类来说都只有一份存储空间,而非static字段则是对每个对象有一个存储空间),但是如果static作用于某个方法,差别却没有那么大。static方法的一个重要用法就是在不创建任何对象的前提下就可以调用它。正如我们将会看到的一样,这一点对定义main()方法很重要,这个方法是运行一个应用时的入口点。

    和其他方法一样,static方法可以创建或使用与其类型相同的被命名对象,因此,static方法常常拿来做“牧羊人”的角色,负责看护与其隶属同一类型的实例群。

    展开全文
  • 关于Static关键字

    2008-07-31 10:37:00
    C++的static有两种用法:面向过程...一、面向过程设计中的static1、静态全局变量在全局变量前,加上关键字static,该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子,如下: //Example 1#include
     
    


      C++的static有两种用法:面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数,不涉及类;后者主要说明static在类中的作用。

    一、面向过程设计中的static

    1、静态全局变量

    在全局变量前,加上关键字static,该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子,如下:

    //Example 1
    #include <iostream.h>
    void fn();
    static int n; //定义静态全局变量
    void main()
    {
    	n=20;
    	cout<<n<<endl;
    	fn();
    }
    
    void fn()
    {
    	n++;
    	cout<<n<<endl;
    }
    
    静态全局变量有以下特点:
    • 该变量在全局数据区分配内存;
    • 未经初始化的静态全局变量会被程序自动初始化为0(自动变量的值是随机的,除非它被显式初始化);
    • 静态全局变量在声明它的整个文件都是可见的,而在文件之外是不可见的; 
    静态变量都在全局数据区分配内存,包括后面将要提到的静态局部变量。对于一个完整的程序,在内存中的分布情况如下图:
     
    代码区
    全局数据区
    堆区
    栈区

      一般程序的由new产生的动态数据存放在堆区,函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间,静态数据(即使是函数内部的静态局部变量)也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现,Example 1中的代码中将

    	static int n; //定义静态全局变量
    改为
    	int n; //定义全局变量
    程序照样正常运行。
    的确,定义全局变量就可以实现变量在文件中的共享,但定义静态全局变量还有以下好处:
    • 静态全局变量不能被其它文件所用;
    • 其它文件中可以定义相同名字的变量,不会发生冲突;

    您可以将上述示例代码改为如下:

    //Example 2
    //File1
    #include <iostream.h>
    void fn();
    static int n; //定义静态全局变量
    void main()
    {
    	n=20;
    	cout<<n<<endl;
    	fn();
    }
    
    //File2
    #include <iostream.h>
    extern int n;
    void fn()
    {
    	n++;
    	cout<<n<<endl;
    }
    
    编译并运行Example 2,您就会发现上述代码可以分别通过编译,但运行时出现错误。试着将
    static int n; //定义静态全局变量
    
    改为
    int n; //定义全局变量
    
    再次编译运行程序,细心体会全局变量和静态全局变量的区别。

    2、静态局部变量

    在局部变量前,加上关键字static,该变量就被定义成为一个静态局部变量。

    我们先举一个静态局部变量的例子,如下:

    //Example 3
    #include <iostream.h>
    void fn();
    void main()
    {
    	fn();
    	fn();
    	fn();
    }
    void fn()
    {
    	static n=10;
    	cout<<n<<endl;
    	n++;
    }
    
      通常,在函数体内定义了一个变量,每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体,系统就会收回栈内存,局部变量也相应失效。
      但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来,变量已经不再属于函数本身了,不再仅受函数的控制,给程序的维护带来不便。
      静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区,而不是保存在栈中,每次的值保持到下一次调用,直到下次赋新值。

    静态局部变量有以下特点:

    • 该变量在全局数据区分配内存;
    • 静态局部变量在程序执行到该对象的声明处时被首次初始化,即以后的函数调用不再进行初始化;
    • 静态局部变量一般在声明处初始化,如果没有显式初始化,会被程序自动初始化为0;
    • 它始终驻留在全局数据区,直到程序运行结束。但其作用域为局部作用域,当定义它的函数或语句块结束时,其作用域随之结束;

    3、静态函数

      在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同,它只能在声明它的文件当中可见,不能被其它文件使用。

    静态函数的例子:

    //Example 4
    #include <iostream.h>
    static void fn();//声明静态函数
    void main()
    {
    	fn();
    }
    void fn()//定义静态函数
    {
    	int n=10;
    	cout<<n<<endl;
    }
    
    定义静态函数的好处:
    • 静态函数不能被其它文件所用;
    • 其它文件中可以定义相同名字的函数,不会发生冲突;

    二、面向对象的static关键字(类中的static关键字)

    1、静态数据成员

    在类内数据成员的声明前加上关键字static,该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。

    //Example 5
    #include <iostream.h>
    class Myclass
    {
    public:
    	Myclass(int a,int b,int c);
    	void GetSum();
    private:
    	int a,b,c;
    	static int Sum;//声明静态数据成员
    };
    int Myclass::Sum=0;//定义并初始化静态数据成员
    
    Myclass::Myclass(int a,int b,int c)
    {
    	this->a=a;
    	this->b=b;
    	this->c=c;
    	Sum+=a+b+c;
    }
    
    void Myclass::GetSum()
    {
    	cout<<"Sum="<<Sum<<endl;
    }
    
    void main()
    {
    	Myclass M(1,2,3);
    	M.GetSum();
    	Myclass N(4,5,6);
    	N.GetSum();
    	M.GetSum();
    
    }
    
    可以看出,静态数据成员有以下特点:
    • 对于非静态数据成员,每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个,静态数据成员在程序中也只有一份拷贝,由该类型的所有对象共享访问。也就是说,静态数据成员是该类的所有对象所共有的。对该类的多个对象来说,静态数据成员只分配一次内存,供所有对象共用。所以,静态数据成员的值对每个对象都是一样的,它的值可以更新;
    • 静态数据成员存储在全局数据区。静态数据成员定义时要分配空间,所以不能在类声明中定义。在Example 5中,语句int Myclass::Sum=0;是定义静态数据成员;
    • 静态数据成员和普通数据成员一样遵从public,protected,private访问规则;
    • 因为静态数据成员在全局数据区分配内存,属于本类的所有对象共享,所以,它不属于特定的类对象,在没有产生类对象时其作用域就可见,即在没有产生类的实例时,我们就可以操作它;
    • 静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为:
      <数据类型><类名>::<静态数据成员名>=<值>
    • 类的静态数据成员有两种访问形式:
      <类对象名>.<静态数据成员名> 或 <类类型名>::<静态数据成员名>
      如果静态数据成员的访问权限允许的话(即public的成员),可在程序中,按上述格式来引用静态数据成员 ;
    • 静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类,每个实例的利息都是相同的。所以,应该把利息设为存款类的静态数据成员。这有两个好处,第一,不管定义多少个存款类对象,利息数据成员都共享分配在全局数据区的内存,所以节省存储空间。第二,一旦利息需要改变时,只要改变一次,则所有存款类对象的利息全改变过来了;
    • 同全局变量相比,使用静态数据成员有两个优势:
    1. 静态数据成员没有进入程序的全局名字空间,因此不存在与程序中其它全局名字冲突的可能性;
    2. 可以实现信息隐藏。静态数据成员可以是private成员,而全局变量不能;
    2、静态成员函数

      与静态数据成员一样,我们也可以创建一个静态成员函数,它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样,都是类的内部实现,属于类定义的一部分。普通的成员函数一般都隐含了一个this指针,this指针指向类的对象本身,因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下,this是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比,静态成员函数由于不是与任何的对象相联系,因此它不具有this指针。从这个意义上讲,它无法访问属于类对象的非静态数据成员,也无法访问非静态成员函数,它只能调用其余的静态成员函数。下面举个静态成员函数的例子。

    //Example 6
    #include <iostream.h>
    class Myclass
    {
    public:
    	Myclass(int a,int b,int c);
    	static void GetSum();/声明静态成员函数
    private:
    	int a,b,c;
    	static int Sum;//声明静态数据成员
    };
    int Myclass::Sum=0;//定义并初始化静态数据成员
    
    Myclass::Myclass(int a,int b,int c)
    {
    	this->a=a;
    	this->b=b;
    	this->c=c;
    	Sum+=a+b+c; //非静态成员函数可以访问静态数据成员
    }
    
    void Myclass::GetSum() //静态成员函数的实现
    {
    //	cout<<a<<endl; //错误代码,a是非静态数据成员
    	cout<<"Sum="<<Sum<<endl;
    }
    
    void main()
    {
    	Myclass M(1,2,3);
    	M.GetSum();
    	Myclass N(4,5,6);
    	N.GetSum();
    	Myclass::GetSum();
    }
    

    关于静态成员函数,可以总结为以下几点:

    • 出现在类体外的函数定义不能指定关键字static;
    • 静态成员之间可以相互访问,包括静态成员函数访问静态数据成员和访问静态成员函数;
    • 非静态成员函数可以任意地访问静态成员函数和静态数据成员;
    • 静态成员函数不能访问非静态成员函数和非静态数据成员;
    • 由于没有this指针的额外开销,因此静态成员函数与类的全局函数相比速度上会有少许的增长;
    • 调用静态成员函数,可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数,也可以直接使用如下格式:
      <类名>::<静态成员函数名>(<参数表>)
      调用类的静态成员函数。
    展开全文
  • 1、为什么局部变量不能使用static关键字修饰? 内存分为三大块,占内存,堆内存和方法区内存。栈内存主要存放局部变量和对象的内存地址(通过引用保存起来),堆内存主要存放对象本身以及成员变量,方法区内存主要...

    1、为什么局部变量不能使用static关键字修饰?
    内存分为三大块,栈内存,堆内存和方法区内存。栈内存主要存放局部变量和对象的内存地址(通过引用保存起来),堆内存主要存放对象本身以及成员变量,方法区内存主要存放class相关信息以及static修饰的静态变量。由于staitc关键字修饰的变量是属于类共有的,因此不可能修饰局部变量,因为局部变量仅隶属于一个方法当中,出了这个方法就不能访问了。当栈内存中的方法执行完成,该方法以及方法内的局部变量所占据的内存空间就会释放。关于静态变量为什么属于类,而不属于对象,可以参考以下实例:
    在这里插入图片描述
    如图所示,栈内存中有个main方法,在main方法中如果调用m1()方法,在m1()方法中调用m2()方法,会发生压栈。栈活动的原则是:后进先出,先进后出。在发生弹栈过程的时候,栈内存中的方法,局部变量全部得到释放。假如现在有一个专门调查中国人口的Person类,这个类里的成员方法有名字,身份证号和国籍,当然,每个人的姓名,身份证号都不一样,但是国籍都是一样的。如果我们在国籍上不加static,那么国籍这个成员变量是属于对象的,也就是,每创建一次对象,都要为国籍赋值,这样,每个对象中都会保存一份String nationality的成员变量,但事实是,String nationality的值都是“中国”,如果让每个对象都持有一份的话,太浪费内存了。因此,如果在String nationality前用static关键字修饰,让它变成静态变量,属于这个类共有的变量,以后创建对象的时候就不用专门为国籍赋值了,访问不需要用引用.变量名的方式,而是用类名.变量名的方式去访问即可。这个时候,这个变量会从堆内存转移到方法区内存中,为所有的对象所共有,内存布局会变成这样:
    在这里插入图片描述
    这也从一定意义上解释了为什么局部变量不能使用static关键字修饰。

    2、关于静态数据既可以使用类名.变量名的方式访问,也可以用引用.变量名的方式访问。
    在这里插入图片描述
    如上图,静态方法正规方法是通过类名.变量名的方式去访问,但是也可以通过引用.变量名的方式去访问。如下图:
    在这里插入图片描述
    实际上,虽然创建了对象,但在编译阶段,JVM检查出s是StaticTest类型,并且m1方法是静态方法,因此还是采用了类名.变量名的方式执行。整个过程并没用到对象。这个理论可以通过一个实例去验证,大家都知道空指针异常,也就是空引用访问成员会出现异常。这个时候,我们先让s的值为null,再去调m1()方法,结果如下:
    在这里插入图片描述
    如果所示,结果并没有出现空指针异常。原因是m1方法是静态的,程序会自动通过类去访问,而不是通过引用,因此就不存在空指针的说法。

    展开全文
  • static关键字

    2019-09-27 00:06:56
    static关键字 原文地址http://www.cnblogs.com/xrq730 感谢博主分享,谢谢! 之前讲到final关键字的作用是每次面试的时候我必问求职者的两个问题之一,另外一个问题就是文本会写到的static。final和...

    原文地址http://www.cnblogs.com/xrq730     感谢博主分享,谢谢!

     

    之前讲到final关键字的作用是每次面试的时候我必问求职者的两个问题之一,另外一个问题就是文本会写到的static。final和static一样,都是一个小问题可以看到一个人的基础是否扎实以及平时是否有钻研精神。

    静态变量和静态方法

    static关键字最基本的用法是:

    1、被static修饰的变量属于类变量,可以通过类名.变量名直接引用,而不需要new出一个类来

    2、被static修饰的方法属于类方法,可以通过类名.方法名直接引用,而不需要new出一个类来

    被static修饰的变量、被static修饰的方法统一属于类的静态资源,是类实例之间共享的,换言之,一处变、处处变。JDK把不同的静态资源放在了不同的类中而不把所有静态资源放在一个类里面,很多人可能想当然认为当然要这么做,但是是否想过为什么要这么做呢?个人认为主要有三个好处:

    1、不同的类有自己的静态资源,这可以实现静态资源分类。比如和数学相关的静态资源放在java.lang.Math中,和日历相关的静态资源放在java.util.Calendar中,这样就很清晰了

    2、避免重名。不同的类之间有重名的静态变量名、静态方法名也是很正常的,如果所有的都放在一起不可避免的一个问题就是名字重复,这时候怎么办?分类放置就好了。

    3、避免静态资源类无限膨胀,这很好理解。

    OK,再微微深入一下,也是有些人容易混淆的一个问题:静态方法能不能引用非静态资源?静态方法里面能不能引用静态资源?非静态方法里面能不能引用静态资源?比如就以这段代码为例,是否有错?

    复制代码
    1 public class A
    2 {
    3     private int i = 1;
    4     
    5     public static void main(String[] args)
    6     {
    7         i = 1;
    8     }
    9 }
    复制代码

    当然有错,在第7行的地方。不妨这么思考这个问题:

    静态资源属于类,但是是独立于类存在的。从JVM的类加载机制的角度讲,静态资源是类初始化的时候加载的,而非静态资源是类new的时候加载的。 类的初始化早于类的new,比如Class.forName(“xxx”)方法,就是初始化了一个类,但是并没有new它,只是加载这个类的静态资源罢 了。所以对于静态资源来说,它是不可能知道一个类中有哪些非静态资源的;但是对于非静态资源来说就不一样了,由于它是new出来之后产生的,因此属于类的 这些东西它都能认识。所以上面的几个问题答案就很明确了:

    1、静态方法能不能引用非静态资源?不能,new的时候才会产生的东西,对于初始化后就存在的静态资源来说,根本不认识它。

    2、静态方法里面能不能引用静态资源?可以,因为都是类初始化的时候加载的,大家相互都认识。

    3、非静态方法里面能不能引用静态资源?可以,非静态方法就是实例方法,那是new之后才产生的,那么属于类的内容它都认识。

     

    静态块

    静态块也是static的重要应用之一。也是用于初始化一个类的时候做操作用的,和静态变量、静态方法一样,静态块里面的代码只执行一次,且只在初始化类的时候执行。静态块很简单,不过提三个小细节:

    复制代码
     1 public class A
     2 {
     3     private static int a = B();
     4     
     5     static
     6     {
     7         System.out.println("Enter A.static block");
     8     }
     9     
    10     public static void main(String[] args)
    11     {
    12         new A();
    13     }
    14     
    15     public static int B()
    16     {
    17         System.out.println("Enter A.B()");
    18         return 1;
    19     }
    20 }
    复制代码

    打印结果是

    Enter A.B()
    Enter A.static block

    得出第一个结论:静态资源的加载顺序是严格按照静态资源的定义顺序来加载的。这和周志明老师《深入理解Java虚拟机:JVM高级特性与最佳实践》中类初始化中的说法“<clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态语句块(static{}块)中的语句合并产生的,编译器收集的顺序是由语句在源文件中出现的顺序所决定的”是一致的。

    再看一个例子:

    复制代码
     1 public class A
     2 {
     3     static
     4     {
     5         c = 3;
     6         System.out.println(c);
     7     }
     8     
     9     private static int c;
    10 }
    复制代码

    这段代码的第6行是有错误的“Cannot reference a field before it is defined”。从这个例子得出第二个结论:静态代码块对于定义在它之后的静态变量,可以赋值,但是不能访问。

    最后一个小例子:

    复制代码
     1 public class A
     2 {
     3     static
     4     {
     5         System.out.println("A.static block");
     6     }
     7     
     8     public A()
     9     {
    10         System.out.println("A.constructor()");
    11     }
    12 }
    复制代码
    复制代码
     1 public class B extends A
     2 {
     3     static 
     4     {
     5         System.out.println("B.static block");
     6     }
     7     
     8     public B()
     9     {
    10         System.out.println("B.constructor()");
    11     }
    12     
    13     public static void main(String[] args)
    14     {
    15         new B();
    16         new B();
    17     }
    18 }
    复制代码

    结果是

    A.static block
    B.static block
    A.constructor()
    B.constructor()
    A.constructor()
    B.constructor()

    这个例子得出第三个结论:静态代码块是严格按照父类静态代码块->子类静态代码块的顺序加载的,且只加载一次。

     

    static修饰类

    这个用得相对比前面的用法少多了,static一般情况下来说是不可以修饰类的, 如果static要修饰一个类,说明这个类是一个静态内部类(注意static只能修饰一个内部类),也就是匿名内部类。像线程池 ThreadPoolExecutor中的四种拒绝机制CallerRunsPolicy、AbortPolicy、DiscardPolicy、 DiscardOldestPolicy就是静态内部类。静态内部类相关内容会在写内部类的时候专门讲到。

     

    import static

    这个比较冷门,基本很少看见有地方用,使用JUnit可能会用到,写assert的时候会方便些。import static是JDK1.5之后的新特性,这两个关键字连用可以指定导入某个类中的指定静态资源,并且不需要使用类名.资源名,可以直接使用资源名。注意一下,import static必须这么写,而不能写成static import。举个例子来看一下:

    复制代码
    1 import static java.lang.Math.*;
    2 
    3 public class A
    4 {
    5     public static void main(String[] args)
    6     {
    7         System.out.println(sin(2.2));
    8     }
    9 }
    复制代码

    这么写意味着我导入了Math下的所有静态资源,main函数里面我就可以直接用sin(2.2)而不需要使用Math.sin(2.2)了。注意一下,要写import static java.lang.Math.*, 最后的“.*”不可少,有了这两个字符才意味着导入的是Math下的所有静态资源,写成import static java.lang.Math是有问题的。当然,我们也可以指定只导入某个静态资源,比如只导入Math下sin这个方法而不导入Math下的所有静态资 源:

    复制代码
    1 import static java.lang.Math.sin;
    2 
    3 public class A
    4 {
    5     public static void main(String[] args)
    6     {
    7         System.out.println(sin(2.2));
    8     }
    9 }
    复制代码

    这么写也是没问题的。导入静态变量也是一样,有兴趣的可以自己试一下。对于import static,个人的态度是:

    1、简化了一些操作,比如静态导入Math下的所有静态资源,在频繁使用Math类下静态资源的地方,可以少些很多“Math.”

    2、降低了代码的可读性

    建议在某些场景下导入特定的静态资源,不建议使用“.*”的导入方式。

     

    posted on 2016-03-25 11:14 ChenJLang 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/ChenLLang/p/5318707.html

    展开全文
  • static 关键字的作用

    2018-11-28 16:04:27
    Static关键字static关键字可以修饰变量方法代码块内部类 java中的static关键字主要用于内存管理。我们可以应用java static关键字在变量,方法,块和嵌套类中。 static关键字属于类,而不是类的实例。 static关键字...
  • static静态  可以修饰属性,方法,语句块,(类,暂时不管)  通过类名访问静态属性和方法  类名.静态属性  类名.静态方法  静态数据被所有对象共享。  静态数据只初始化一次。  静态...
  • static关键字的用法

    2019-12-12 17:33:45
    下面我们先来了解一下static关键字及其用法。 static关键字 开始啰嗦一些, 平时的使用当中,static最常用的功能就是修饰类的属性和方法,让他们成为类的成员属性和方法,我们通常将用static修饰的成员称为类成员、...
  • static关键字作用

    2019-10-06 05:06:53
    之前讲到final关键字的作用是每次面试的时候我必问求职者的两个问题之一,...static关键字最基本的用法是: 1、被static修饰的变量属于类变量,可以通过类名.变量名直接引用,而不需要new出一个类来 2、被stati...
  • 学习java过程中,不得不说一下static关键字. 1.修饰变量(静态变量) 1.1)与final一起使用 static final String path = "这是一个常量"; 代表一个不可改变的常量 1.2)单独使用 public class Teacher{...
  • static关键字作用总结

    2019-02-13 17:25:52
    static关键字作用总结 静态变量和静态方法 static关键字最基本的用法是: 1、被static修饰的变量属于类变量,可以通过类名.变量名直接引用,而不需要new出一个类来 2、被static修饰的方法属于类方法,可以通过类名....
  • 一般来说,我们用new来创建对象,这时,数据的存储空间才会被分配,它的方法才能被外界调用 ...而当我们通过static关键字则可以解决这方面的需求 当声明一个事物是static时,就意味着这个域或方法
  • Java static关键字

    2019-10-19 17:19:46
    static static字段 (1)静态字段最本质特点:它们是类的字段,不属于任何一个对象实例。 (2)它不保存在某个对象实例的内存区间中,而是保存在类的内存区域的公共存储单元。 (3)类变量可以通过类名直接访问,也...
  • 下面就先讲述一下static关键字的用法和平常容易误解的地方,最后列举了一些面试笔试中常见的关于static的考题。以下是本文的目录大纲: 一.static关键字的用途 二.static关键字的误区 三.常见的笔试面试题 若有...
  • static关键字的作用

    2020-02-14 14:23:05
    static关键字最基本的用法是: 1、被static修饰的变量属于类变量,可以通过类名.变量名直接引用,而不需要new出一个类来 2、被static修饰的方法属于类方法,可以通过类名.方法名直接引用,而不需要new出一个类来 被...
  • Java的static关键字万字详解第一节 什么是static关键字第二节 修饰成员变量第三节 修饰修饰成员方法第四节 静态代码块第四节 静态导包第五节 静态内部类第六节 常见问题①、静态变量能存在于普通方法中吗?...
  • Java中的static关键字

    2018-03-19 15:12:22
    static关键字基本用法: 1.被static修饰的变量为静态变量,通过类名.变量名可以直接访问。 2.被static修饰的方法为静态方法,通过类名.方法名可以直接访问。 静态变量和静态方法属于类自身,被类对象实例共享。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,121
精华内容 6,448
关键字:

关于static关键字的说法错误的是