精华内容
下载资源
问答
  • 静态变量
    千次阅读
    2021-03-15 10:46:39

    静态变量又称类变量,静态方法又称类方法,它们统称为静态成员或类成员。静态成员由static修饰,是属于整个类的,所有的对象共享这些静态成员。不需要创建任何对象,静态成员在类装载时就已初始化了,整个运行期间其内存位置不变,直到类卸载。鉴于静态成员的这些特性,访问静态变量以及定义或调用静态方法时与非静态成员也有不同之处。下面分别做出说明。

    1.静态变量

    类的非静态方法、静态方法都可以直接访问静态变量

    其他类要访问某个类的静态变量,既可以通过实例名访问,也可以直接用类名来访问,推荐用类名访问的方式,这样能更直观的说明访问的变量是静态变量

    2.静态方法

    不能直接访问非静态变量,也不能直接调用非静态方法,需要实例化一个对象,再通过该对象来访问要访问的非静态变量或要调用的非静态方法。也就是说,静态方法不能直接使用非静态成员。个人理解是,非静态成员是依托对象而存在的,当没有实例一个对象时,非静态成员是没有分配内存空间的,静态方法要使用非静态成员不知道要到哪里去找,当然就不能直接使用非静态成员了。

    其他类要调用某个类的静态方法,既可以通过实例名调用,也可以直接用类名来调用,推荐用类名调用的方式,这样能更直观的说明调用的方法是静态方法

    3.下面以简单的代码验证上面的结论

    定义了一个Person类,类的代码见最后面。

    (1).类的静态方法可以直接访问静态变量

    静态方法staticMethod访问了静态变量citizenship

    定义并使用了局部变量testY

    staticMethod()方法如下:

    public static void staticMethod() {

    int testY = 20;

    System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access

    System.out.println("She‘s now " + testY + " years old"); //local variable access

    }

    main()方法如下:

    public static void main(String[] args) {

    Person xiaoxi = new Person("xiaoxi",29,"female","piano");

    xiaoxi.informationPrint();

    staticMethod();

    }

    输出结果如下:

    My name is xiaoxi

    I am 29 years old

    I am a girl

    My hobby is piano

    I am a chinese

    She has applied for Chinese citizenship

    She‘s now 20 years old

    结果分析:

    静态方法可以直接访问静态变量

    静态方法可以自定义局部变量

    (2),静态方法不可以直接访问非静态变量

    [1].staticMethod直接访问静态变量citizenship,出现错误

    静态方法staticMethod访问了静态变量citizenship

    定义并使用了局部变量testY

    访问了非静态变量hobby

    staticMethod()方法如下:

    public static void staticMethod() {

    int testY = 20;

    System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access

    System.out.println("She‘s now " + testY + " years old"); //local variable access

    System.out.println("She doesn‘t like " + hobby); //nonstatic variable access

    }

    main方法同上。

    输出结果如下:

    My name is xiaoxi

    I am 29 years old

    I am a girl

    My hobby is piano

    I am a chinese

    Exception in thread "main" java.lang.Error: Unresolved compilation problem:

    Cannot make a static reference to the non-static field hobby

    at human.Person.staticMethod(Person.java:99)

    at human.Person.main(Person.java:107)

    结果分析:

    静态方法不能直接访问非静态变量,否则会出现“Cannot make a static reference to the non-static field hobby” 的错误。

    [2].staticMethod()创建一个对象testP,由testP访问非静态变量hobby,成功执行

    静态方法staticMethod使用了静态变量citizenship

    定义并使用了局部变量testY

    创建一个Person实例testP,并使用了testP的变量hobby

    staticMethod()方法如下:

    public static void staticMethod() {

    int testY = 20;

    Person testP = new Person();

    System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access

    System.out.println("She‘s now " + testY + " years old"); //local variable access

    System.out.println("She doesn‘t like " + testP.hobby); // nonstatic variable access via object instance testP

    }

    main方法同上。

    输出结果如下:

    My name is xiaoxi

    I am 29 years old

    I am a girl

    My hobby is piano

    I am a chinese

    She has applied for Chinese citizenship

    She‘s now 20 years old

    She doesn‘t like null

    结果分析:

    静态方法要访问非静态变量,可以先实例化一个对象,再通过对象访问。

    (3),静态方法不可以直接调用非静态方法

    [1].staticMethod()直接访问非静态方法informationPrint(),出现错误

    静态方法staticMethod使用了静态变量citizenship

    定义并使用了局部变量testY

    创建一个Person实例testP,并使用了testP的hoppy变量

    直接调用非静态方法informationPrint()

    staticMethod()方法如下:

    public static void staticMethod() {

    int testY = 20;

    Person testP = new Person();

    System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access

    System.out.println("She‘s now " + testY + " years old"); //local variable access

    //System.out.println("She doesn‘t like " + testP.hobby); //nonstatic variable access

    System.out.println("She doesn‘t like " + testP.hobby); // nonstatic variable access via object instance testP

    System.out.println("Her personal information is as follows:");

    informationPrint();

    }

    main()方法同上。

    输出结果如下:

    My name is xiaoxi

    I am 29 years old

    I am a girl

    My hobby is piano

    I am a chinese

    Exception in thread "main" java.lang.Error: Unresolved compilation problem:

    Cannot make a static reference to the non-static method informationPrint() from the type Person

    at human.Person.staticMethod(Person.java:103)

    at human.Person.main(Person.java:111)

    结果分析:

    静态方法不能直接调用非静态方法,否则会出现与直接访问非静态变量类似的错误,Cannot make a static reference to the non-static method informationPrint() from the type Person。

    [2].通过已有对象testP来调用informationPrint()方法,成功执行

    静态方法staticMethod使用了静态变量citizenship

    定义并使用了局部变量testY

    创建一个Person实例testP,并使用了testP的hoppy变量

    通过testP调用非静态方法informationPrint()

    staticMethod()方法如下:

    public static void staticMethod() {

    int testY = 20;

    Person testP = new Person();

    System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access

    System.out.println("She‘s now " + testY + " years old"); //local variable access

    System.out.println("She doesn‘t like " + testP.hobby); // nonstatic variable access via object instance testP

    System.out.println("Her personal information is as follows:");

    //informationPrint();

    testP.informationPrint();

    }

    main()方法同上。

    输出结果如下:

    My name is xiaoxi

    I am 29 years old

    I am a girl

    My hobby is piano

    I am a chinese

    She has applied for Chinese citizenship

    She‘s now 20 years old

    She doesn‘t like null

    Her personal information is as follows:

    My name is null

    I am 0 years old

    Something is wrong!

    My hobby is null

    I am a chinese

    结果分析:

    静态方法要调用非静态方法,可以先实例化一个对象,再通过该对象来调用。

    附Person类:

    package human;

    public class Person {

    String name;

    int age;

    String gender;

    private String hobby;

    protected String residence;

    static String citizenship = "Chinese";

    public Person() {

    }

    public Person(String n, String g) {

    this.name = n;

    this.gender = g;

    }

    public Person(String n, int a, String g, String h) {

    this.name = n;

    this.age = a;

    this.gender = g;

    this.hobby = h;

    //test:静态变量初始化的时机是否在构造方法之前

    System.out.println("constructor:");

    System.out.println("change value of the static variable citizenship " + "\"" + citizenship + "\"");

    citizenship = "US";

    System.out.println(" to " + "\"" + citizenship + "\"");

    }

    public Person(String n, int a, String g, String h, String r) {

    this.name = n;

    this.age = a;

    this.gender = g;

    this.hobby = h;

    this.residence = r;

    }

    public void setName(String n) {

    this.name = n;

    }

    public void setAge(int a) {

    this.age = a;

    }

    public void setGender(String g) {

    this.gender = g;

    }

    public void setHobby(String h) {

    this.hobby = h;

    }

    public void setResidence(String r) {

    this.residence = r;

    }

    public String getName() {

    return this.name;

    }

    public int getAge() {

    return this.age;

    }

    public String getGender() {

    return this.gender;

    }

    public String getHobby() {

    return this.hobby;

    }

    public String getResidence() {

    return this.residence;

    }

    public void informationPrint() {

    System.out.println("My name is " + getName());

    System.out.println("I am " + getAge() + " years old");

    if(getGender() == "female")

    System.out.println("I am a girl");

    else

    if(getGender() == "male")

    System.out.println("I am a boy");

    else

    System.out.println("Something is wrong!");

    System.out.println("My hobby is " + hobby);

    if(citizenship == "Chinese")

    System.out.println("I am a chinese");

    //test:静态变量是否在构造方法之前初始化

    else

    if(citizenship == "US")

    System.out.println("I am an American");

    else

    System.out.println("Oh,something is wrong");

    }

    public static void staticMethod() {

    int testY = 20;

    Person testP = new Person();

    System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access

    System.out.println("She‘s now " + testY + " years old"); //local variable access

    System.out.println("She doesn‘t like " + testP.hobby); // nonstatic variable access via object instance testP

    System.out.println("Her personal information is as follows:");

    //informationPrint();

    testP.informationPrint();

    }

    public static void main(String[] args) {

    Person xiaoxi = new Person("xiaoxi",29,"female","piano");

    xiaoxi.informationPrint();

    staticMethod();

    }

    }

    原文:http://www.cnblogs.com/chanchan/p/7707554.html

    更多相关内容
  • 静态变量

    千次阅读 2021-02-20 09:02:00
    静态变量的作用域 是文件 ,只在这个文件中有效 静态局部变量 如果在某个块中,声明了某个静态变量,无论该块是否被访问,该静态变量都在内存中存在。 只有访问该块时,才能使用,Static内部变量 保存了上一次使用...

    静态变量的作用域 是文件 ,只在这个文件中有效


    静态局部变量

    如果在某个块中,声明了某个静态变量,无论该块是否被访问,该静态变量都在内存中存在。
    只有访问该块时,才能使用,Static内部变量 保存了上一次使用后的值
    Static类型的内部变量是一种只能在某个特定函数中使用,但一 直占据存储空间的变量(可以通过指针 在该块的外部进行访问)
    静态局部变量 只会进行一次初始化 如果最后再次调用Fun1函数 静态局部变量不会再次初始化成10

    void Fun1(void);
    void Fun2(void);
    void Fun3(void);
    int *Sp = NULL;
    int *p = NULL;
    
    int main(int argc, char* argv[])
    {
    	Fun1();
    	Fun2();
    
    	Fun3();
    	Fun2();
    	return 0;
    }
    
    
    void Fun1(void)
    {
    	static int a = 10;
    	int b = 20;
    
    	Sp = &a;
    	p = &b;
    }
    
    
    void Fun2()
    {
    	printf("Sp = %d  p = %d\n",*Sp,*p);
    }
    
    
    void Fun3(void)
    {
    	*Sp = 30;
    	*p = 20;
    }
    

    在这里插入图片描述

    静态全局变量

    全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。
    全局变量本身就是静态存储方式,静态全局变量当然也是静态存储方式。
    这两者在存储方式上并无不同。

    这两者的区别虽在于:
    1、非静态全局变量的作用域是整个源程序 ,当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。
    2、静态全局变量则限制了其作用域, 即只在定义该变量的源文件 内有效,在同一源程序的其它源文件(即声明了该变量的CPP文件,或包含该变量声明头文件的CPP文件)中不能使用它。

    由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用,因此可以避免在其它源文件中引起错误。

    从以上分析可以看出————
    把局部变量改变为静态变量后是改变了它的存储方式,即改变了它的生存期。
    把全局变量改变为静态变量后是改变了它的作用域,限制了它的使用范围。

    因此static这个说明符在不同的地方所起的作用是不同的。应予以注意。

    关于Static关键字
    1.静态变量,分配在静态存储区,在数据段中。函数退出之后,变量值不变。
    2.作用域,全局的静态变量、静态函数只能在本文件中使用。(不同于一般全局变量)
    局部的静态变量同函数的局部变量

    展开全文
  • 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==

    已赞过

    已踩过<

    你对这个回答的评价是?

    评论

    收起

    展开全文
  • 静态变量和实例变量的区别

    千次阅读 2022-01-12 14:18:43
    静态变量和实例变量的区别

    静态变量和实例变量的区别

    大家好,我是酷酷的韩~
    酷酷的韩金群
    1.在语法定义上的区别:

    静态变量前要加static关键字,而实例变量前则不加。

    2.在程序运行时的区别:

    (1)实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才会被分配空间,才能使用这个实例变量。

    (2)静态变量不属于某个实例对象,而是属于类,所以也称为类变量,只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被分配空间,静态变量就可以被使用了。

    (3)总之,实例变量必须创建对象后才可以通过这个对象来使用,静态变量则可以直接使用类名来引用。

    (4)举例:对于下面的程序,无论创建多少个实例对象,永远都只分配了一个staticVar变量,并且每创建一个实例对象,这个staticVar就会加1;但是,每创建一个实例对象,就会分配一个instanceVar,即可能分配多个instanceVar,并且每个instanceVar的值都只自加了1次。

    public class TestUtils {
        public static int staticVar = 0;
        public int instanceVar = 0;
    
        public static void main(String[] args) {
            for (int i = 0; i < 10; i++) {
                TestUtils testUtils = new TestUtils();
            }
            System.out.println(TestUtils.staticVar);
        }
    
        public TestUtils() {
            staticVar++;
            instanceVar++;
        }
    }
    

    只有经历沧桑,才能遇见曙光。 ------酷酷的韩~

    展开全文
  • Java中的static———静态变量

    千次阅读 2021-09-05 18:15:40
    引言 static 是 java 语言中的关键字,意思是“静态的”,它可以用来修饰变量、方法、代码块等,修饰的变量叫做静态变量,修饰的方法叫做静态方法,修饰的代码块叫做静态代码块。 初学static的最大的问题就是:...
  • 先上实例public classTestStatic {public static String staticString = "this ... //静态变量public String instanceString = "this is a instance String";//实例变量//静态方法public static voidstaticMethod()...
  • Matlab/Simulink中的静态变量和全局变量1、静态变量(persistent)1)Matlab中使用静态变量2、全局变量(global)1)Matlab中使用全局变量2)Simulink中使用全局变量(1)使用 Data Store Memory 模块存储数据(2)使用 ...
  • 静态变量有什么特点

    千次阅读 2021-05-21 17:28:17
    静态变量是属于静态存储方式,但是属于静态存储方式的量不一定就是静态变量,以下是由学习啦小编整理关于静态变量的用法的内容,希望大家喜欢!静态变量的用法静态变量也可以用于存储常数。具体来说,静态变量(全局...
  • 局部变量、全局变量和静态变量之间的区别 (1)局部变量 定义: 在一个函数内部定义的变量是局部变量,它只在本函数范围内有效。 1.主函数main定义的变量也只在主函数有效; 2.不同函数中可以使用名字相同的变量,...
  • C/C++中静态变量

    千次阅读 2022-01-10 22:26:41
    C/C++中的静态变量1. 静态全局变量2.静态局部变量3. 静态函数4.类内静态成员变量5. 类内静态局部变量6.类内静态函数 C语言中与“静态”相关的词包括,静态全局变量,静态局部变量和静态函数,关键词是static。C语言...
  • python中静态变量 Python中的静态变量和方法 (Static Variables and Methods in Python) Defining static variable and method is a common programming concept and is widely used in C++, Java, ...
  • Java中的静态变量和静态方法

    千次阅读 2022-03-21 22:08:00
    所以在一个对象中修改静态变量的值,同时也就修改了其他所有对象中该静态变量的值。保留字static是用来声明静态变量的修饰符。静态变量的内存空间是在程序第一次使用该变量所在的类时分配的。在方法内声明的局部变量...
  • 局部变量、全局变量、静态变量

    千次阅读 2019-09-16 09:52:33
    局部变量 定义:局部变量指在程序中只在...定义:在函数外定义的变量是外部变量,外部变量就是全局变量,全局变量可以为本文件中其它函数所共用,它的有效范围从定义变量的位置开始到本源文件结束。 局部变量与全局变...
  • python ——静态变量

    千次阅读 2022-01-27 20:57:48
    Python语言并不支持静态变量。因为Python是动态语言,不存在完全静态的变量。 Python中,静态成员变量称为类变量,非静态成员变量称为实例变量 class A: ## 静态变量 a = 12 def __init__(self, a): ##成员...
  • 由static修饰的变量称为静态变量,其实质上就是一个全局变量。如果某个内容是被所有对象所共享,那么该内容就应该用静态修饰;没有被静态修饰的内容,其实是属于对象的特殊描述。 不同的对象的实例变量将被分配不同...
  • JNI静态变量

    千次阅读 2021-11-16 01:30:31
    JNI静态变量 在上一篇中介绍了JNI实例类型。本文是JNI系列的第六篇,介绍JNI中的如何访问类静态变量。 系列文章的大纲如下: JNI 简介 JNI 基本类型 JNI String JNI 数组 JNI 实例变量 JNI 静态变量 JNI 回调实例...
  • C语言中static静态变量

    千次阅读 2022-02-22 10:00:11
    静态变量的说明符是static static静态变量属于静态存储方式,其存储空间是 静态数据区(也就是存入全局存储区),静态数据区的数据在整个程序运行期间一直占用这些内存。也可以认为他的内存地址一直不变。(静态变量...
  • sv 静态变量

    千次阅读 2020-08-22 15:09:39
    静态变量赋值 函数中的变量按照作用域可以分为全局变量和局部变量,按照生命周期可以分为静态变量和动态变量。静态变量在函数编译过程即分配存储空间,链接在数据段,在整个工程运行期间一直存在。动态变量一般在...
  • C++静态变量

    千次阅读 2021-02-15 13:00:41
    本篇主要讲述类中静态变量相关基础: 静态变量的特点 局域作用域中静态变量并不会随着函数的每一次调用而产生一个副本,也不会随着函数的返回而导致变量的失效。 静态变量的意义 在一个class类中,private修饰的...
  • 前言同事来找我,说自己想使用@Value注解来注入值,但是发现注入不进去,想让我帮忙看看。研究了一番,最后发现是@Value注解无法注入静态变量。下面我们一起来回顾一下本次的bug。普通变...
  • c语言静态函数调用静态变量 C中的静态变量 (Static Variables in C) Basically, when static variables are declared, they create only a single copy of them and are also termed as Class Variables. 基本上,...
  • 静态变量static和全局变量global

    千次阅读 2021-03-04 05:42:25
    静态变量static ,全局变量global静态变量在java也叫类变量从名字可以看出它是属于某个类的而不是类的实例。它的关键字是static存储在静态存储区,当程序执行,类的代码被加载到内存,类的静态变量就分配了内存空间,...
  • static--静态变量与普通变量的区别

    万次阅读 多人点赞 2019-03-12 09:59:09
    静态变量与普通变量的区别 全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式, 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽...
  • 可能刚学java对这些变量很懵,直接上图,接下来进行代码解释 ...2:静态变量被所有的对象所共享,在内存中只有一个副本,它当且仅当在类初次加载时会被初始化。 3:简单来说就是被static修饰后的值可以直接类...
  • C中静态变量的默认值

    千次阅读 2021-05-20 14:52:57
    静态变量仅初始化一次。编译器将变量保留到程序结束。可以在函数内部或外部定义静态变量。它们是本地的。静态变量的默认值为零。静态变量在程序执行之前一直有效。这是C语言中的静态变量的语法,...
  • 线程之间是否共享静态变量

    千次阅读 2021-03-06 05:04:51
    根据他的说法,两个线程不一定共享静态变量,特别是在每个线程(主线程与ReaderThread)在其自己的处理器上运行并因此不共享相同的寄存器/缓存/等的情况下CPU不会更新另一个。基本上,他说有可能ready在主线程中更新,...
  • * java规定,变量没有初始化不能使用,全局变量也就是类的属性,java会在编译的时候,自动将他们初始化, * 所以可以不进行变量初始化的操作,☆☆☆☆☆但是(局部)变量必须初始化☆☆☆☆☆ * * 静态数据的...
  • Java中的静态变量、静态方法问题

    千次阅读 2021-03-04 06:32:56
    由关键字static所定义的变量与方法,分别称为静态变量和静态方法,它们又都被称为静态成员1.静态方法无需本类的对象也可以调用此方法,调用形式为“类名.方法名”,静态方法常常为其他类提供一些方法而被定义。但是...
  • python 类中静态变量 Python类/静态变量 (Python Class / Static Variables) Class or Static variables are class-related variables that are shared among all objects but the instance or non-static variable ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,313,985
精华内容 525,594
关键字:

静态变量

友情链接: GuidedFilter_ECCV10.rar