精华内容
参与话题
问答
  • 关于java成员变量和局部变量

    万次阅读 多人点赞 2018-09-14 10:46:45
    1、成员变量和局部变量简述 在Java语言里,根据定义变量位置的不同,可以将变量分成两大类:成员变量(存在于堆内存中,和类一起创建)和局部变量(存在于栈内存中,当方法执行完成,让出内存,让其他方法来使用内存)...

    1、成员变量和局部变量简述

    在Java语言里,根据定义变量位置的不同,可以将变量分成两大类:成员变量(存在于堆内存中,和类一起创建)和局部变量(存在于栈内存中,当方法执行完成,让出内存,让其他方法来使用内存)。二者的运行机制存在较大差异。

    1.1成员变量

    类变量从该类的准备阶段起开始存在,直到系统完全销毁这个类,类变量的作用域与这个类的生存范围相同;

    而实例变量则从该类的实例被创建起开始存在,直到系统完全销毁这个实例,实例变量的作用域与对应实例的生存范围相同。

    正是基于这个原因,可以把类变量和实例变量统称为成员变量。其中类变量可以理解为类成员变量,它作为类本身的一个成员,与类本身共存亡;实例变量则可以理解为实例成员变量,它作为实例的一个成员与实例共存亡。

    只要类存在,类就可以访问类变量         类.类变量

    只要实例存在,实例就可以访问实例变量        实例.实例变量

    当然实例也可以访问类变量。但是需要注意的是因为实例不拥有类变量,所以通过实例来访问类变量进行操作,实际上是对类变量进行操作 ,当有其他实例来访问类变量时,访问的类变量是被对象访问操作过的类变量。

    成员变量无需显示初始化,只要为一个类定义了类变量或实例变量,系统就会在这个类的准备阶段或创建该类的实例时进行默认初始化。

    1.2局部变量

    局部变量根据定义形式的不同,又可以分为如下三种:

    形参:在定义方法签名时定义的变量,形参的作用域在整个方法中都有效

    方法局部变量:在方法体内定义的局部变量,它的作用域是从定义该变量的地方生效,到该方法结束时失效

    代码块局部变量:这个局部变量的作用域从定义该变量的地方生效,到该代码结束时失效。

    一个变量只在一对{}中起作用。。

    java允许局部变量和成员变量同名,如果方法中局部变量和成员变量同名,局部变量就会覆盖成员变量,如果需要在这个方法中引用被覆盖成员变量,则可使用this(对于实例变量)或类名(对于类变量)作为调用者来限定访问成员变量。

    2、成员变量的初始化和内存中的运行机制

    接下来以下面代码来举例说明成员变量的初始化和内存中的运行机制

     

    复制代码

     1 public class Person {
     2     public int num;
     3     public String name;
     4     
     5     public static void main(String[] args) {
     6         Person p1 = new Person();
     7         Person p2 = new Person();
     8         p1.num = 2;
     9         p2.num = 3;
    10         p1.name = "张三";
    11         p2.name = "李四";
    12     }
    13     
    14 
    15 }

    复制代码

     

    当程序执行Person p1 = new Person();时,如果这行代码是第一次使用Person类,则系统通常会在第一次使用Person类时加载这个类,并初始化这个类,在类的准备 阶段,系统将会为该类的类变量分配内存空间,并指定默认初始值。当person类初始化完成后,系统内存中的存储示意图如下图所示。

     可以看出,当person类初始化完成后,系统将在堆内存中为Person分配一块内存空间,实际上是创建了一个类对象,在这块内存区里包含了保存num类变量的内存,并设置num的默认初始值为0。

    系统接着创建了一个Person对象,并把这个Person对象赋给p1变量,Person对象包含了名为name的实例变量,实例变量是在创建实例时分配内存空间并指定初始值的。当创建了第一个person对象后,系统内存中的存储示意图如下图所示。

    从上图可以看出num不属于对象,它属于类,所以创建第一个对象时并不需要为num分配内存空间,系统只是为name分配了内存空间,并指定初始值为null。

    创建第二个对象p2时,由于在创建第一个对象时已经对类进行了初始化,所以在创建p2时对类进行初始化,对象的创建过程与第一个对象的创建过程没有什么区别。

    第二个对象创建完成后,成员变量如上图所示在内存中存储。

    **当程序需要访问类变量时,尽量使用类来作为主调,不要使用对象作为主调,这个可以避免产生歧义。

    3、局部变量的初始化和内存中的运行机制

    *局部变量必须经过显示初始化之后才能使用,系统不会为局部变量执行初始化。定义了局部变量以后,系统并没有给局部变量进行初始化,直到程序给这个局部变量赋给初值时,系统才会为这个局部变量分配内存空间,并将初始值保存到这块内存中。

    *局部变量不属于任何类或者实例,因此它总是保存在方法的栈内存中。如果局部变量是基本数据类型,则该变量直接存储在方法的栈内存中,如果是引用变量则将引用的地址存储在方法的栈内存中。

    *栈内存中的变量无需系统垃圾回收,随着方法或者代码块的运行结束而结束。局部变量通常只保存了具体的值或者引用地址,所以所占的内存比较小。

    4、变量的使用规则

    能不使用成员变量就别使用成员变量

    能不使用方法局部变量就别使用方法局部变量

    使用代码块局部变量性能最好。

     

     

     

    展开全文
  • 1、前言 相信同学们一定懵逼过,那是,不懵逼就不正常了,现在由我为了大家在轻松的氛围... b、局部变量:在函数内、在class的方法(构造、类方法、静态方法、实例方法)内(变量未加self修饰),这就是局部变量 ...

    前言

    相信同学们一定懵逼过这些【术语】,马上在轻松的氛围下逐个说明标题中所述的【术语】名词,这些概念真的很重要!

     

    基本概念

    全局变量:在模块内、所有函数外、所有class外,这是全局变量

    局部变量:在函数内、在class的方法(类方法、静态方法、实例方法)内,且变量前面什么也未修饰,这是局部变量

    类变量:在class内,且不在class的方法内,这是类变量

    实例变量:在class的方法内,且使用self修饰的变量,这是实例变量

     

    【全局变量】与【局部变量】举例

    下面的代码位于一个模块中

    ahead = 'HelloWorld' #ahead是全局变量
    showList = []        #showList也是全局变量
    
    def print_ahead():
        print(ahead)   #因为在该函数中没有称为ahead的局部变量,这里实际调用的是全局变量ahead
    
    def print_other():
        city = 'beijing'       #city是局部变量
        print(city + ahead)  #局部变量 与 全局变量
    
    def print_list():
        global showList    #global关键字表示引用的是全局变量showList
                        
        showList.append(1)
        showList.append(2)
        print(showList)
    
    print_ahead()
    print_other()
    print_list()

    输出结果:

    HelloWorld
    beijingHelloWorld
    [1, 2]

     

    【类变量】与【实例变量】举例

    下面的代码位于一个模块中

    class Person(object):
        TAG = "Person"               #TAG是类变量
        def __init__(self, name):    #self表示当前实例对象
            print(Person.TAG)       #类变量TAG被访问
            self.personName = name   #personName是实例变量
    
        def print_name(self):
            group = "BeiJing_"      #group是局部变量
            print(group + self.personName)  # 局部变量 与 实例变量
    
    if __name__ == "__main__":
        p = Person("WangYuanWai")
        p.print_name()

    输出结果:

    Person
    BeiJing_WangYuanWai

     

    全局变量与局部变量同名冲突

    说明:命名规范点,冲突自然没了,你得知道同名冲突的后果是什么?

    firstValue = "Hello World"
    
    def print_str():
        firstValue = "hi man"
    
        print(firstValue)  #注意:这里的firstValue调用的是局部变量firstValue,在方法中直接覆盖掉同名的全局变量firstValue

    如果在print_str函数中没有使用global关键字显式的引用全局变量,此print_str函数中将优先使用的是局部变量,而不是全局变量

     

    可省略global关键字

    你的函数里只是读取全局变量的值,并没有任何的赋值行为(指a = XXX这种写法)的话,可以省略global修饰全局变量

    first = 100 #first是全局变量
    
    def my_hello():
        print(first) #只是访问全局变量first的值,无需global修饰(加上global更规范)

     

    不可省略global关键字

    name = "王员外"
    
    def change_name():
        global name
        name = "大哥大"

     上面的代码必须加上global修饰变量,说明是给全局变量name赋值,如果global修饰,说明是在创建一个局部变量

     

    Python中的一切都是对象

    全局变量:属于模块对象的属性

    类变量:属于类对象的属性

    实例变量:属于实例对象的属性

    局部变量:属于方法对象或函数对象的属性吗?不属于………函数对象或者方法对象必须显式的添加属性!

     

    展开全文
  • 静态局部变量和动态局部变量区别: 1.静态局部变量属于静态存储类别,在静态存储区分配存储单元,在整个运行期间都不释放。 而自动变量(动态局部变量)属于动态存储类别,占动态存储空间,函数调用后释放 2.静态局部...

    静态局部变量和动态局部变量区别:

    1.静态局部变量属于静态存储类别,在静态存储区分配存储单元,在整个运行期间都不释放。
    而自动变量(动态局部变量)属于动态存储类别,占动态存储空间,函数调用后释放
    2.静态局部变量在编译时赋初值,程序运次时已经有初值,以后每次调用函数不再重新赋初值而只是保留上次函数调用结束时的值。
    3.静态局部变量编译时赋初值默认是0
    而自动变量,如果不赋初值则它的值是不确定的值。
    4.静态局部变量在函数调用结束后仍然存在,但其他函数不能引用它。

    如果用static修饰全局变量,那么该全局变量不能被其他文件引用。
    不能再被extern(extern和static都是修饰符)
    如果用static修饰函数,那么该函数本文件内可以引用而其他文件不能引用。

    展开全文
  •   基本概念: 作用域:起作用的区域,也就是可以工作的范围。...C语言中局部变量就分配在栈中。   局部变量  普通的局部变量定义的时候直接定义或者在前面加上auto void func1(void){&nbs...

     

    基本概念: 作用域:起作用的区域,也就是可以工作的范围。

    代码块:所谓代码块,就是用{}括起来的一段代码。

    数据段:数据段存的是数,像全局变量就是存在数据段的

    代码段:存的是程序代码,一般是只读的。

    栈(stack):先进后出。C语言中局部变量就分配在栈中。

     

    局部变量

      普通的局部变量定义的时候直接定义或者在前面加上auto

    void func1(void)
    {
     int i = 1;
     
     i++;
     
     printf("i = %d.\n", i);
    }
    局部变量i的解析
    在连续三次调用func1中,每次调用时,在进入函数func1后都会创造一个新的变量i,
    并且给它赋初值1,然后i++时加到2,
    然后printf输出时输出2.然后func1本次调用结束,
    结束时同时杀死本次创造的这个i。这就是局部变量i的整个生命周期。
    下次再调用该函数func1时,又会重新创造一个i,经历整个程序运算,
    最终在函数运行完退出时再次被杀死。

     

    静态局部变量(static) 静态局部变量定义时前面加static关键字。

    总结:

    1、静态局部变量和普通局部变量不同。静态局部变量也是定义在函数内部的,静态局部变量定义时前面要加static关键字来标识,静态局部变量所在的函数在多调用多次时,只有第一次才经历变量定义和初始化,以后多次在调用时不再定义和初始化,而是维持之前上一次调用时执行后这个变量的值。本次接着来使用。

    2、静态局部变量在第一次函数被调用时创造并初始化,但在函数退出时它不死亡,而是保持其值等待函数下一次被调用。下次调用时不再重新创造和初始化该变量,而是直接用上一次留下的值为基础来进行操作。

    3、静态局部变量的这种特性,和全局变量非常类似。它们的相同点是都创造和初始化一次,以后调用时值保持上次的不变。不同点在于作用域不同

     

    全局变量 定义在函数外面的变量,就叫全局变量。

    普通全局变量  普通全局变量就是平时使用的,定义前不加任何修饰词。普通全局变量可以在各个文件中使 用,可以在项目内别的.c文件中被看到,所以要确保不能重名。

    静态全局变量  静态全局变量就是用来解决重名问题的。静态全局变量定义时在定义前加static关键字, 告诉编译器这个变量只在当前本文件内使用,在别的文件中绝对不会使用。这样就不用担心重名问题。所以静态的全局变量就用在我定义这个全局变量并不是为了给别的文件使用,本来就是给我这个文件自己使用的。

    跨文件引用全局变量(extern) 就是说,你在一个程序的多个.c源文件中,可以在一个.c文件中定义全局变量g_a,并且可以在别的另一个.c文件中引用该变量g_a(引用前要声明)

    函数和全局变量在C语言中可以跨文件引用,也就是说他们的连接范围是全局的,具有文件连接属性,总之意思就是全局变量和函数是可以跨文件看到的(直接影响就是,我在a.c和b.c中各自定义了一个函数func,名字相同但是内容不同,编译报错。)。

     

    局部变量和全局变量的对比
    1、定义同时没有初始化,则局部变量的值是随机的,而全局变量的值是默认为0.
    2、使用范围上:全局变量具有文件作用域,而局部变量只有代码块作用域。
    3、生命周期上:全局变量是在程序开始运行之前的初始化阶段就诞生,到整个程序结束退出的时候才死亡;而局部变量在进入局部变量所在的代码块时诞生,在该代码块退出的时候死亡。
    4、变量分配位置:全局变量分配在数据段上,而局部变量分配在栈上。

    //static

    复制代码
     1 #include <stdio.h>
     2 
     3 
     4 void func1(void);
     5 void func_static(void);
     6 void func_static2(void);
     7 void func_global(void);
     8 void func_register(void);
     9 
    10 int g_a = 1;
    11 
    12 
    13 int main(void)
    14 {
    15     //a = 4;            // 编译报错,未定义
    16     g_a = 5;            // 可以,因为g_a是全局变量,所以到处都可以用
    17 
    18     func1();        // i = 2
    19     func1();        // i = 2
    20     func1();        // i = 2
    21     
    22     func_static();    // a = 2
    23     func_static();    // a = 3
    24     func_static();    // a = 4
    25     
    26     func_static2();    // a = 4;
    27     func_static2();    // a = 7;
    28     func_static2();    // a = 10;
    29     
    30     func_global();    // g_a = 4;
    31     func_global();    // g_a = 7;
    32     func_global();    // g_a = 10;
    33     
    34     func_register();
    35     func_register();
    36     func_register();
    37     
    38     
    39     
    40     
    41 // 因为i是定义在函数func中的局部变量,所以i的作用域为代码块作用域,所以i只在func1
    42 // 函数内部有效,在func1外面是不能访问i的。所以这里i会无定义。
    43     //i = 5;        // error: ‘i’ undeclared (first use in this function)
    44     
    45     return 0;
    46 }
    47 
    48 
    49 void func1(void)
    50 {
    51     int i = 1;                // 普通的局部变量,auto可以省略的
    52     //auto int i = 0;            // 自动局部变量,其实就是普通局部变量
    53     
    54     i++;
    55     
    56     printf("i = %d.\n", i);
    57 }
    58 
    59 void func_static(void)
    60 {
    61     static int a = 1;        // 静态的局部变量
    62     
    63     a++;
    64     
    65     printf("a = %d.\n", a);
    66 }
    67 
    68 void func_static2(void)
    69 {
    70     static int a = 1;        // 静态的局部变量
    71     
    72     a += 3;
    73     
    74     printf("a = %d.\n", a);
    75 }
    76 
    77 void func_global(void)
    78 {
    79     g_a += 3;
    80     
    81     printf("g_a = %d.\n", g_a);
    82 }
    83 
    84 void func_register(void)
    85 {
    86     register int a = 1;        // 静态的局部变量
    87     
    88     a += 3;
    89     
    90     printf("a = %d.\n", a);
    91 }
    复制代码

    //globle

    复制代码
     1 #include <stdio.h>
     2 
     3 
     4 int g_i = 13;
     5 
     6 
     7 // 实验结论:
     8 // 首先,main函数是一个程序运行最开始执行的东西,所有的其他函数都只能在main函数中被
     9 // 直接或者间接的调用才能被执行。main函数的执行其实就是整个程序的生命周期,main函数
    10 // 一return返回,整个程序就结束了。
    11 // 其次,全局变量的定义和初始化是在main函数运行之前发生的。
    12 int main(void)
    13 {    
    14     printf("g_i = %d.\n", g_i);
    15     
    16     return 0;
    17 }
    复制代码
    复制代码
     1 #include <stdio.h>
     2 
     3 
     4 void func_in_a(void);
     5 extern int g_a;                // 声明了一个int变量g_a
     6 //extern int g_b;
     7 
     8 void func_in_b(void)
     9 {
    10     printf("I am func in b.c.\n");
    11 }
    12 
    13 
    14 int main(void)
    15 {
    16     printf("I am main in a.c.\n");
    17     printf("I am main in a.c, g_a = %d.\n", g_a);
    18     printf("I am main in a.c, g_a = %d.\n", g_b);
    19     
    20     
    21     //func_in_b();        // 直接调用
    22     
    23     func_in_a();        // 间接调用
    24     
    25     return 0;
    26 }
    复制代码
    复制代码
     1 #include <stdio.h>
     2 
     3 
     4 
     5 void func_in_b(void);
     6 
     7 int g_a = 12;
     8 int g_b = 111;
     9 
    10 
    11 
    12 
    13 
    14 
    15 void func_in_a(void)
    16 {
    17     
    18     g_a = 24;
    19     
    20     printf("I am in func_in_a of a.c, g_a = %d.\n", g_a);
    21     func_in_b();
    22 }
    23 
    24 /*
    25 // 定义错误
    26 // C语言中,定义函数都必须在外面,不能在一个函数里面定义别的函数
    27 // 所以没有局部函数,只有全局函数。
    28 
    29 void func1(void)
    30 {
    31     int a;
    32     
    33     
    34     void func2()
    35     {
    36         int b;
    37     }
    38 }
    39 
    40 */
    复制代码

    //最后两个分别为a.c b.c 文件目录为

     

    展开全文
  • 变量可以分为:全局变量、静态全局变量、静态局部变量局部变量。 按存储区域分,全局变量、静态全局变量和静态局部变量都存放在内存的静态 存储区域,局部变量存放在内存的栈区。 按作用域分,全局变量在整个...
  • 结论:函数可以返回局部变量的值,但是不能返回指向栈内存的指针。 原因: 局部变量的作用域为函数内部,函数执行结束,操作系统会自动释放栈上的局部变量。并且函数返回的是局部变量的值拷贝。但是如果返回局部变量...
  • 普通局部变量与static局部变量的区别 内存分配和释放 1、普通局部变量只有执行到变量定义的语句的时候才分配空间。 2、static局部变量在编译阶段(函数还没有执行),变量的空间已经分配。 3、普通局部变量离开作用...
  • 按存储区域分:全局变量、静态全局变量和静态局部变量都存放在内存的全局数据区,局部变量存放在内存的栈区 按作用域分: 1、全局变量在整个工程文件内都有效; 2、静态全局变量只在定义它的文件内有效; 3、...
  • 1、局部变量://就是定义在函数内部的变量(内部变量),局部变量起作用的范围是函数内部。//局部变量就是私有的变量2、全局变量://就是定义在函数外部的变量(外部变量),//全局变量起作用的范围是当前文件中的...
  • C++ 全局变量、静态全局变量、局部变量、静态局部变量的使用,整理表格如下:分类 全局变量 静态全局变量(static) 局部变量(auto) 静态局部变量(static) 作用域 全局作用域(extern) 文件作用域(当前文件) 局部作用域...
  • 静态局部变量与自动局部变量的区别 区别: 1、静态局部变量属于静态存储类别,在静态存储区内分配存储分配单元。在程序整个运行期间都不释放。而自动变量(即动态局部变量)属于动态存储类别,占动态存储区...
  • 全局变量局部变量静态全局变量、静态局部变量的区别   转自:http://hi.baidu.com/sindana/blog/item/06fe68171e364401c93d6ded.html 标签:全局变量 局部变量 静态全局变量 静态局部变量 ...
  • 1、局部变量能否和全局变量重名?  答:能,局部会屏蔽全局。要用全局变量,需要使用 ":: "  局部变量可以与全局变量同名,在函数内引用这个变量时,会用到同名的局部变量,而不会用到全局变量。对于有些编译器...
  • lua中全局变量,局部变量,非局部变量分别放在什么容器中,他们的快慢顺序是什么,跪求大神
  • 全局变量、局部变量、静态全局变量、静态局部变量的区别 C++变量根据定义位置的不同,具有不同的作用域,作用域可分为6种:全局作用域,局部作用域,语句作用域,类作用域,命名作用域和文件作用域。 从作用域...
  • Python的全局变量和局部变量

    万次阅读 多人点赞 2018-05-13 13:38:40
    学编程的总离不开全局变量和局部变量,那么,首先我们要知道局部变量和全局变量的定义: 局部变量:定义在函数内部的变量称为局部变量,他的作用域范围为函数内,也就是出了函数外就无效。举个简单的例子:葫芦娃在...
  • Lua全局变量与局部变量

    千次阅读 2019-04-22 16:55:52
    在lua中,局部变量(变量名前加 local)与全局变量类似于C语言中的概念: print(a) --打印变量nil a=111 --全局变量(整个lua文件中都可以使用,向下的范围) do local a=0--局部变量在语句块的结束 a=1 ...
  • python中全局变量和局部变量详解

    万次阅读 多人点赞 2018-11-13 12:18:46
    python中全局变量和局部变量的最大区别在于局部变量只能通过函数去访问,而全局变量可以直接访问。 !!! 我们先来看一个最简单的例子,事实上这并不是一个真正的全局变量,只是在类中的一个变量。 !!! 我们...
  • Java 局部变量

    千次阅读 2018-11-11 19:55:38
    局部变量声明在方法、构造方法或者语句块中; 局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将... 局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。 ...
  • 一、普通全局变量和普通局部变量的关系 通常情况下,如果有两个同名变量,一个是普通全局变量,另一个是普通局部变量,那么局部变量在其作用域内具有较高的优先权,它将屏蔽全局变量。 #include #include int ...
  • 全局变量和局部变量

    千次阅读 2017-01-01 21:37:03
    1、局部变量和全局变量变量按照作用域分为:全局变量和局部变量 全局变量的作用域:从定义位置开始到下面整个程序结束。 局部变量的作用域:在一个函数内部定义的变量只能在本函数内部进行使用。 OK,上面的...
  • 成员变量和局部变量同名 在同一个作用域内不允许定义同名的多个变量。   在一个方法内,可以定义和成员变量同名的局部变量或参数,此时成员变量被屏蔽。此时如果想要访问成员变量,可以通过 this 关键字来...
  • 变量定义以后,是有一定的使用范围,称之为变量的作用域。比如Java中,变量的使用范围是变量声明时所在的{}范围,而python的作用域对应的为同一个缩进。按着变量的使用范围给变量划分成... 局部变量作用域:只能在...
  • 我们都知道方法中的匿名/局部内部类是能够访问同一个方法中的局部变量的,但是为什么局部变量要加上一个final呢? 首先我们来研究一下变量生命周期的问题,局部变量的生命周期是当该方法被调用时在栈中被创建,当...
  • 全局变量与局部变量

    千次阅读 2019-03-18 22:22:57
    全局变量与局部变量的区别。
  • 概念首先得明白局部变量,静态局部变量,全局变量,静态全局变量这几个概念,以下面程序举例://main.cpp int a = 0; //全局变量 static int b=0;//静态全局变量 main() { int c; //局部变量 static int d;//静态...
  • python 局部变量变成全局变量

    千次阅读 2020-04-07 15:15:08
    全局变量 = global + 局部变量
  • 变量又分为局部变量和全局变量,但他们都在内存的静态区,静态变量只能被初始化一次。 静态全局变量,作用域仅限于被定义的文件中,其他文件即使用extern声明也没法使用它。准确地说作用域是从定义之处开始,到文件...
  • OOP中局部变量与成员变量

    千次阅读 2019-04-19 21:02:35
    局部变量 局部变量的定义 局部变量是定义在方法中或定义在循环体中的变量。 局部变量创建的位置 局部变量创建于栈内存中 局部变量的初始化 局部变量在创建时系统不会给出默认值,若要使用该局部变量,必须在使用...

空空如也

1 2 3 4 5 ... 20
收藏数 96,506
精华内容 38,602
关键字:

局部变量