学习笔记1“局部变量静态变量与成员变量的区别”

成员变量、实例变量、类变量和局部变量区别
⼀、成员变量、实例变量、类变量和局部变量区别
1：：变量电议部分所定义的变量被称为类的。

也就是说在整个类中都有效，类中的⽅法可以直接调⽤成员变量使⽤。

然⽽成员变量⼜分为实例成员变量（简称）和类变量（简称）
1.1：：就是我们正常定义的变量，⽐如int a； a就是
1.2：：定义前要加上Static ⽐如static int a；这个a就是静态变量，当在变量定义前加上static的时候就代表着该变量在使⽤的时候有⼀处改变则各个⽤到这个变量的地⽅，该变量都发⽣改变，就是所谓的⼀处改变处处改变，静态变量的⽣存期为整个，但是只能在定义该变量的函数内使⽤该变量。

退出该函数后，尽管该变量还继续存在，但不能使⽤它。

2：：在⽅法体中定义的变量和⽅法的参数称。

也就是说只在定义它的⽅法内有效，⽽⽅法外部的其他⽅法⽆法使⽤局部变量。

当局部变量名字与成员变量名字相同，则成员变量被隐藏，即这个成员变量在这个⽅法内暂时失效，以局部变量定义的为准。

⼆.长提到的⽅法有，类⽅法，实例⽅法。

就是名字和类名相同，⽽且没有类型。

类⽅法和实例⽅法的区别就是类⽅法前⾯有static修饰，⽽实例⽅法没有static修饰。

实例⽅法既能对类变量操作，也能对实例变量操作，⽽类⽅法只能对类变量进⾏操作。

成员变量（实例变量）局部变量静态变量（类变量）的区别成员变量（实例变量）&局部变量区别：
(1)作⽤域
成员变量：针对整个类有效。

局部变量：只在某个范围内有效。

(⼀般指的就是⽅法,语句体内)
(2)存储位置
成员变量：随着对象的创建⽽存在，随着对象的消失⽽消失，存储在堆内存中。

局部变量：在⽅法被调⽤，或者语句被执⾏的时候存在，存储在栈内存中。

当⽅法调⽤完，或者语句结束后，就⾃动释放。

(3)初始值
成员变量：有默认初始值。

局部变量：没有默认初始值，使⽤前必须赋值。

成员变量（实例变量）&静态变量（类变量）区别：
A：调⽤⽅式
静态变量也称为类变量，可以直接通过类名调⽤。

也可以通过对象名调⽤。

这个变量属于类。

成员变量也称为实例变量，只能通过对象名调⽤。

这个变量属于对象。

B：存储位置
静态变量存储在⽅法区长中的静态区。

成员变量存储在堆内存。

C：⽣命周期
静态变量随着类的加载⽽存在，随着类的消失⽽消失。

⽣命周期长。

成员变量随着对象的创建⽽存在，随着对象的消失⽽消失。

D：与对象的相关性
静态变量是所有对象共享的数据。

成员变量是每个对象所特有的数据。

Java：成员变量、局部变量和静态变量
梳理⼀下：
根据定义变量位置的不同，可以将变量分成两⼤类：成员变量和局部变量。

成员变量（俗称全局变量）：在类⾥定义的变量。

⼜分为实例变量和类变量（也成为静态变量）。

实例变量：不以static修饰，需要先将类实例化，才能通过实例访问，不能通过类.实例变量来访问实例变量，也就是只要实例存在，程序就可以访问该实例的实例变量
类变量：以static修饰，只要类存在，程序就可以访问该类的类变量
下⾯的⽰例讲述了关于静态内部类以及本类的实例变量和类变量的访问规则：
局部变量：在⽅法⾥定义的变量。

根据定义形式不同可以分为三种：形参、⽅法局部变量、代码块局部变量
形参：在定义⽅法签名时定义的变量，形参的作⽤域在整个⽅法内有效；
⽅法局部变量：在⽅法体内定义的局部变量，作⽤域是从定义该变量的地⽅⽣效，到该⽅法结束时失效；
代码块局部变量：在代码块中定义的局部变量，这个局部变量的作⽤域从定义该变量的地⽅⽣效，带该代码块结束时失效。

静态变量是使⽤static修饰的变量，跟类变量是⼀对⼀的关系么。

For personal use only in study and research; not for commercial use静态变量,全局变量,局部变量的区别1.C++变量根据定义的位置的不同的生命周期，具有不同的作用域，作用域可分为6种：全局作用域，局部作用域，语句作用域，类作用域，命名空间作用域和文件作用域。

从作用域看：1>全局变量具有全局作用域。

全局变量只需在一个源文件中定义，就可以作用于所有的源文件。

当然，其他不包含全局变量定义的源文件需要用extern关键字再次声明这个全局变量。

2>静态局部变量具有局部作用域，它只被初始化一次，自从第一次被初始化直到程序运行结束都一直存在，它和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。

3>局部变量也只有局部作用域，它是自动对象（auto），它在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用执行结束后，变量被撤销，其所占用的内存也被收回。

4>静态全局变量也具有全局作用域，它与全局变量的区别在于如果程序包含多个文件的话，它作用于定义它的文件里，不能作用到其它文件里，即被static 关键字修饰过的变量具有文件作用域。

这样即使两个不同的源文件都定义了相同名字的静态全局变量，它们也是不同的变量。

2.从分配内存空间看：1>全局变量，静态局部变量，静态全局变量都在静态存储区分配空间，而局部变量在栈里分配空间2>全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。

这两者在存储方式上并无不同。

这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。

而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。

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

全局变量、局部变量和静态变量区别变量是程序运行时在内存中所申请的存储单元，根据所要存储的数据大小，申请的内存单元数量是不同的。

当某个程序加载后，会在内存中占据三个区域，分别为代码段、堆栈段和数据段。

代码段用于存放程序的所有指令；堆栈段用于存放临时数据；而数据段则用于存放长期数据。

堆栈段和数据段都是用于存放数据的，也就是可以用于定义变量。

堆栈段存放的是临时数据，主要用于函数调用时的参数传递、寄存器保存以及局部变量的保存。

某个变量存放在其中的位置不确定，跟堆栈的使用情况有关，所有的非静态局部变量都是定义在堆栈段中。

由于每次进入函数时堆栈的使用情况不同，为某个局部变量所申请的内存单元位置是不同的。

例如：某程序有一个名为abc的函数，其中包含一个unsigned char类型的局部变量x。

当第一次调用abc函数时，堆栈的栈顶位置是1000（表示堆栈中还有1000个单元没有被使用），则x存放在堆栈内偏移地址为999单元中，当执行完abc后，堆栈的栈顶又恢复到之前的位置。

当第二次调用abc函数时，栈顶的位置可能不再是1000，存放x的单元也不再是上次的999号单元，原来存放在999号单元的内容与本次的x没有任何关系。

一句话，局部变量之所以不能将数据保留下来，就是因为其所申请的内存单元不是固定的位置。

而全局变量以及函数内部的静态变量，则是申请在数据段。

数据段在程序加载到内存后，就为每个全局变量和静态变量申请了固定的位置，一直到该程序结束之前，这些全局变量和静态变量所占据的位置都是固定的，它们的内容也就没有保留下来。

全局变量与静态变量都是占据固定位置，内容可以保留。

区别在于：程序的所有函数都可以访问全局变量，而只能定义某个静态变量的函数可以访问该静态变量，其它函数不能访问它。

java中的全局变量、局部变量与静态常量的区别java中的变量类型分类：类变量：独⽴于⽅法之外的变量，⽤ static 修饰。

实例变量：独⽴于⽅法之外的变量，不过没有 static 修饰。

局部变量：类的⽅法中的变量。

⽐如:public class Variable{static int allClicks=0; // 类变量String str="hello world"; // 实例变量public void method(){int i =0; // 局部变量}}Java 局部变量局部变量声明在⽅法、构造⽅法或者语句块中；局部变量在⽅法、构造⽅法、或者语句块被执⾏的时候创建，当它们执⾏完成后，变量将会被销毁；访问修饰符不能⽤于局部变量；局部变量只在声明它的⽅法、构造⽅法或者语句块中可见；局部变量是在栈上分配的。

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使⽤。

实例变量实例变量声明在⼀个类中，但在⽅法、构造⽅法和语句块之外；当⼀个对象被实例化之后，每个实例变量的值就跟着确定；实例变量在对象创建的时候创建，在对象被销毁的时候销毁；实例变量的值应该⾄少被⼀个⽅法、构造⽅法或者语句块引⽤，使得外部能够通过这些⽅式获取实例变量信息；实例变量可以声明在使⽤前或者使⽤后；访问修饰符可以修饰实例变量；实例变量对于类中的⽅法、构造⽅法或者语句块是可见的。

⼀般情况下应该把实例变量设为私有。

通过使⽤访问修饰符可以使实例变量对⼦类可见；实例变量具有默认值。

数值型变量的默认值是0，布尔型变量的默认值是false，引⽤类型变量的默认值是null。

变量的值可以在声明时指定，也可以在构造⽅法中指定；实例变量可以直接通过变量名访问。

但在静态⽅法以及其他类中，就应该使⽤完全限定名：ObejectReference.VariableName。

类变量（静态变量）类变量也称为静态变量，在类中以static关键字声明，但必须在⽅法构造⽅法和语句块之外。

从作用域看：全局变量具有全局作用域.全局变量只需在一个源文件中定义，就可以作用于所有地源文件.当然，其他不包括全局变量定义地源文件需要用关键字再次声明这个全局变量.个人收集整理勿做商业用途静态局部变量具有局部作用域.它只被初始化一次，自从第一次初始化直到程序与你新内阁结束都一直存在，他和全局变量地区别在于全局变量对所有地函数都是可见地，而静态局部变量只对定义自己地函数体始终可见.个人收集整理勿做商业用途局部变量也只有局部作用域，他是自动对象，他在程序运行期间不是一直存在，而是只在函数执行期间存在，函数地一次调用结束后，变量就被撤销，其所占用地内存也被收回.个人收集整理勿做商业用途静态全局变量也具有全局作用域，他与全局变量地区别在于如果程序包含多个文件地话，他作用于定义它地文件里，不能作用到其他文件里，即被关键字修饰过地变量具有文件作用域.这样即使两个不同地源文件都定义了相同地静态全局变量，他们也是不同地变量.个人收集整理勿做商业用途从分配内存空间看：全局变量、静态局部变量、静态全局变量都在静态存储区分配空间，而局部变量在栈分配空间.全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式.这两者在存储方式上没有什么不同.区别在于非静态全局变量地作用域是整个源程序，当一个源程序由多个源文件组成时，非静态地全局变量在各个源文件中都是有效地.而静态全局变量则限制了其作用域，即只在定义该变量地源文件内有效，在同一源程序地其他源文件中不能使用它.由于静态全局变量地作用域局限于一个源文件内，只能为该源文件内地函数公用，因此可以避免在其他源文件中引起错误.个人收集整理勿做商业用途、静态变量会被放在程序地静态数据存储区里，这样可以在下一次调用地时候还可以保持原来地赋值.这一点是他与堆栈变量和堆变量地区别个人收集整理勿做商业用途、变量用告知编译器，自己仅仅在变量地作用域范围内可见.这一点是他与全局变量地区别.从以上分析可以看出，把局部变量改变为静态变量后是改变了他地存储方式，即改变了他地生存期.把全局变量改变为静态变量后是改变了他地作用域，限制了他地使用范围，因此这个说明符在不同地地方起地作用是不同地.个人收集整理勿做商业用途：、若全局变量仅在单个文件中访问，则可以讲这个变量修改为静态全局变量.、若全局变量仅在单个函数中使用，则可以将这个变量修改为该函数地静态局部变量.、全局变量、静态局部变量、静态全局变量都存放在静态数据存储区.、函数中必须要使用变量地情况：当某函数地返回值为指针类型时，则必须是地局部变量地地址作为返回值，若为类型，则返回为错指针.个人收集整理勿做商业用途个人收集整理勿做商业用途预备知识—程序地内存分配一个由编译地程序占用地内存分为以下几个部分栈区（）—由编译器自动分配释放，存放函数地参数值，局部变量地值等.其操作方式类似于数据结构中地栈. 个人收集整理勿做商业用途堆区（）—一般由程序员分配释放，若程序员不释放，程序结束时可能由回收 .注意它与数据结构中地堆是两回事，分配方式倒是类似于链表. 个人收集整理勿做商业用途全局区（静态区）（）—，全局变量和静态变量地存储是放在一块地，初始化地全局变量和静态变量在一块区域，未初始化地全局变量、未初始化地静态变量在相邻地另一块区域. 程序结束后有系统释放个人收集整理勿做商业用途文字常量区—常量字符串就是放在这里地.程序结束后由系统释放程序代码区—存放函数体地二进制代码.一个正常地程序在内存中通常分为程序段、数据端、堆栈三部分.程序段里放着程序地机器码、只读数据，这个段通常是只读，对它地写操作是非法地.数据段放地是程序中地静态数据.动态数据则通过堆栈来存放.个人收集整理勿做商业用途在内存中，它们地位置如下：内存低端程序段数据段堆栈内存高端个人收集整理勿做商业用途堆栈是内存中地一个连续地块.一个叫堆栈指针地寄存器（）指向堆栈地栈顶.堆栈地底部是一个固定地址.堆栈有一个特点就是，后进先出.也就是说，后放入地数据第一个取出.它支持两个操作，和.是将数据放到栈地顶端，是将栈顶地数据取出.在高级语言中，程序函数调用、函数中地临时变量都用到堆栈.为什么呢？因为在调用一个函数时，我们需要对当前地操作进行保护，也为了函数执行后，程序可以正确地找到地方继续执行，所以参数地传递和返回值也用到了堆栈.通常对局部变量地引用是通过给出它们对地偏移量来实现地.另外还有一个基址指针（，在芯片中是），许多编译器实际上是用它来引用本地变量和参数地.通常，参数地相对地偏移是正地，局部变量是负地.当程序中发生函数调用时，计算机做如下操作：首先把参数压入堆栈；然后保存指令寄存器()中地内容，做为返回地址()；第三个放入堆栈地是基址寄存器()；然后把当前地栈指针()拷贝到，做为新地基地址；最后为本地变量留出一定空间，把减去适当地数值.在函数体中定义地变量通常是在栈上，用, , 等分配内存地函数分配得到地就是在堆上.在所有函数体外定义地是全局量，加了修饰符后不管在哪里都存放在全局区（静态区），在所有函数体外定义地变量表示在该文件中有效，不能到别地文件用；在函数体内定义地表示只在该函数体内有效.另外，函数中地""这样地字符串存放在常量区.对比：个人收集整理勿做商业用途性能栈：栈存在于中.栈是动态地，它地存储速度是第二快地.堆：堆位于中，是一个通用地内存池.所有地对象都存储在堆中.申请方式【栈】: 由系统自动分配. 例如，声明在函数中一个局部变量; 系统自动在栈中为开辟空间 .【堆】: 需要程序员自己申请，并指明大小，在中函数如( *)(); 在中用运算符如( *)(); 但是注意：、本身是在栈中地.申请后系统地响应栈【】：只要栈地剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出. 个人收集整理勿做商业用途堆【】：首先应该知道操作系统有一个记录空闲内存地址地链表，当系统收到程序地申请时，会遍历该链表，寻找第一个空间大于所申请空间地堆结点，然后将该结点从空闲结点链表中删除，并将该结点地空间分配给程序；另外，对于大多数系统，会在这块内存空间中地首地址处记录本次分配地大小，这样，代码中地语句才能正确地释放本内存空间.另外，由于找到地堆结点地大小不一定正好等于申请地大小，系统会自动地将多余地那部分重新放入空闲链表中.申请大小地限制栈【】：在下，栈是向低地址扩展地数据结构，是一块连续地内存地区域.这句话地意思是栈顶地地址和栈地最大容量是系统预先规定好地，在下，栈地大小是（也有地说是，总之是一个编译时就确定地常数），如果申请地空间超过栈地剩余空间时，将提示.因此，能从栈获得地空间较小. 个人收集整理勿做商业用途堆【】：堆是向高地址扩展地数据结构，是不连续地内存区域.这是由于系统是用链表来存储地空闲内存地址地，自然是不连续地，而链表地遍历方向是由低地址向高地址.堆地大小受限于计算机系统中有效地虚拟内存.由此可见，堆获得地空间比较灵活，也比较大.申请效率地比较栈【】：由系统自动分配，速度较快.但程序员是无法控制地. 个人收集整理勿做商业用途堆【】：是由分配地内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便.另外，在下，最好地方式是用分配内存，他不是在堆，也不是在栈是直接在进程地地址空间中保留一快内存，虽然用起来最不方便.但是速度快，也最灵活.堆和栈中地存储内容栈【】：在函数调用时，第一个进栈地是主函数中后地下一条指令（函数调用语句地下一条可执行语句）地地址，然后是函数地各个参数，在大多数地编译器中，参数是由右往左入栈地，然后是函数中地局部变量.注意静态变量是不入栈地. 个人收集整理勿做商业用途当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存地地址，也就是主函数中地下一条指令，程序由该点继续运行.堆【】：一般是在堆地头部用一个字节存放堆地大小.堆中地具体内容有程序员安排.存取效率地比较[] "";* "";是在运行时刻赋值地；而是在编译时就确定地；但是，在以后地存取中，在栈上地数组比指针所指向地字符串(例如堆)快.比如：(){;[] "";* "";[];[];;}对应地汇编代码: [];[][]: [];[][][]第一种在读取时直接就把字符串中地元素读到寄存器中，而第二种则要先把指针值读到中，在根据读取字符，显然慢了.小结：堆和栈地区别可以用如下地比喻来看出：使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他地好处是快捷，但是自由度小.使用堆就象是自己动手做喜欢吃地菜肴，比较麻烦，但是比较符合自己地口味，而且自由度大.个人收集整理勿做商业用途。

Java成员变量与局部变量成员变量我们来研究一个事物：属性：外在特征；例如人的身高，体重行为：能够做什么；例如人有说话，打球等行为。

而在Java语言中，最基本的单位是类，类就是用来体现事物的。

用类class来描述事物也是如此：属性：对应类中的成员变量行为：对应类中的成员函数定义类其实就是在定义类中的成员（成员变量和成员函数）拓展：类是一个抽象的概念，而对象就是类的具体的存在，体现。

例如：生活中的汽车，可以看做一个类，我们称之为汽车类，每一台车都有颜色和轮胎数（可以定义为属性，即成员变量），每一台车都可以跑（即车的行为，对应类总的成员函数），我们把汽车实例化一下，即会产生一个对象，比如奔驰、宝马（BMW）。

Demo1：运行结果：4个轮子的黑色轿车在马路上行驶着其中color和numLuntai就称为Car 类的成员变量，这个属性能够用来描述一个类的属性，否则，它就应该定义为局部变量。

例如一个for循环中的i即是局部变量。

for(int i = 0; i < args.length; i++) {......}又例如写在成员方法中变量是局部变量。

结果：4个轮子的黑色宝马牌轿车在马路上行驶着成员变量和局部变量的区别成员变量：①成员变量定义在类中，在整个类中都可以被访问。

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

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

局部变量：①局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

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

③局部变量没有默认初始化值在使用变量时需要遵循的原则为：就近原则首先在局部范围找，有就使用；接着在成员位置找。

列表对比：成员变量、局部变量的区别小结：尽管两者者的本质都是变量，可是使用时却有相当大的区别，稍不留神就可能陷入陷阱。

且先记住：在一个类中，如果一个变量能够用来描述一个类的属性，那就定义为成员变量，否则，它就应该定义为局部变量。

Java成员变量、局部变量、静态变量、成员方法、全局方法等概念的区别在Java中，一个类体由2部分构成:一部分是变量的定义;一部分是方法的定义(一个类中可以有多个方法)Java中的变量可以分为成员变量，全局变量成员变量和局部变量的区别成员变量：(类似于C中的全局变量的概念，所以也可以说是全局变量)①成员变量定义在类中，在整个类中都可以被访问。

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

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

局部变量：①局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

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

③局部变量没有默认初始化值在使用变量时需要遵循的原则为：就近原则首先在局部范围找，有就使用；接着在成员位置找。

静态变量（也叫做类变量，类属性）由static修饰的变量称为静态变量，其实质上就是一个全局变量。

如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。

成员变量和静态变量的区别1、两个变量的生命周期不同成员变量随着对象的创建而存在，随着对象被回收而释放。

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

2、调用方式不同成员变量只能被对象调用。

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

3、别名不同成员变量也称为实例变量。

静态变量也称为类变量。

4、数据存储位置不同成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

列表对比：[java] view plain copyclass Demo{int x;// 非静态成员变量，又称为属性，对该类不同的对象来说，属性是不同的static int y;// 静态成员变量，一个类中只有一个该变量，该类不同的对象共享同一个静态成员变量public static void main(String[] args){int m = 0;// 局部变量，是方法内部定义的变量，只在方法内部可见，在该方法结束后，由垃圾回收器自动回收}}Java中的方法可以分为成员方法，全局方法，构造方法[java] view plain copypublic class Test {private int age; //这是成员变量public Test(int age) { //这是构造方法this.age = age;}public void setAge(int age) { //这是成员方法this.age = age;}public static int getAge() { //这是全局方法，加了static关键字，成员方法就变成了全局方法return this.age;}}成员方法必须用类的实例化对象进行访问，而全局方法是直接可以用类名.方法名来访问的，构造方法则是实例化对象时进行初始化的。

局部变量,局部静态变量,全局变量,全局静态变量分别c++内存到底分几个区？一：1、栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。

其操作方式类似于数据结构中的栈。

2、堆区（heap）—一般由程序员分配释放，若程序员不释放，程序结束时可能由os回收。

注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。

- 程序结束后有系统释放。

4、文字常量区—常量字符串就是放在这里的。

程序结束后由系统释放。

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

二：1、栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。

里面的变量通常是局部变量、函数参数等。

2、堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。

如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

3、自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。

4、全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的c语言中，全局变量又分为初始化的和未初始化的，在c++里面没有这个区分了，他们共同占用同一块内存区。

5、常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。

三：1、bss是英文block started by symbol的简称，通常是指用来存放程序中未初始化的全局变量的一块内存区域，在程序载入时由内核清0。

bss段属于静态内存分配。

它的初始值也是由用户自己定义的连接定位文件所确定，用户应该将它定义在可读写的ram区内，源程序中使用malloc分配的内存就是这一块，它不是根据data大小确定，主要由程序中同时分配内存最大值所确定，不过如果超出了范围，也就是分配失败，可以等空间释放之后再分配。

c语⾔局部变量静态局部变量全局变量与静态全局变量基本概念：作⽤域：起作⽤的区域，也就是可以⼯作的范围。

代码块：所谓代码块，就是⽤{}括起来的⼀段代码。

数据段：数据段存的是数，像全局变量就是存在数据段的代码段：存的是程序代码，⼀般是只读的。

栈(stack)：先进后出。

C语⾔中局部变量就分配在栈中。

局部变量 普通的局部变量定义的时候直接定义或者在前⾯加上autovoid 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++内存到底分⼏个区？⼀： 1、栈区（stack）---由编译器⾃动分配释放，存放函数的参数值，局部变量的值等。

其操作⽅式类似于数据结构中的栈。

2、堆区（heap）---⼀般由程序员分配释放（如new,delete），若程序员没有释放，程序结束时可能由os⾃动回收。

注意它与数据结构中的堆是两回事，分配⽅式倒是类似于链表。

3、全局区（静态区、static）---全局变量和静态变量的存储是放在⼀块的，初始化的全局变量和静态变量在⼀块区域，未初始化的全局变量和未初始化的静态变量在相邻的另⼀块区域。

程序结束后由系统释放。

4、常量存储区---存放的是常量，不允许修改。

程序结束后由系统释放。

5、程序代码区---存放函数体的⼆进制代码。

6、⾃由存储区---由malloc等分配的内存块，和堆是⼗分相似，不过它是⽤free来释放的。

⼆：1、bss是英⽂block started by symbol的简称，通常是指⽤来存放程序中未初始化的全局变量的⼀块内存区域，在程序载⼊时由内核清0。

bss段属于静态内存分配。

它的初始值也是由⽤户⾃⼰定义的连接定位⽂件所确定，⽤户应该将它定义在可读写的ram区内，源程序中使⽤malloc分配的内存就是这⼀块，它不是根据data⼤⼩确定，主要由程序中同时分配内存最⼤值所确定，不过如果超出了范围，也就是分配失败，可以等空间释放之后再分配。

2、text段是程序代码段，在at91库中是表⽰程序段的⼤⼩，它是由编译器在编译连接时⾃动计算的，当你在链接定位⽂件中将该符号放置在代码段后，那么该符号表⽰的值就是代码段⼤⼩，编译连接时，该符号所代表的值会⾃动代⼊到源程序中。

3、data包含静态初始化的数据，所以有初值的全局变量和static变量在data区。

段的起始位置也是由连接定位⽂件所确定，⼤⼩在编译连接时⾃动分配，它和你的程序⼤⼩没有关系，但和程序使⽤到的全局变量，常量数量相关。

Java成员变量、局部变量，静态成员变量、⾮静态成员变量的
区别
成员变量和局部变量的区别
1.定义位置上看
成员变量定义在类中，局部变量定义在⽅法中、或者语句中
2.内存的存储
成员变量跟随对象在堆中存储
局部变量跟着⽅法在栈内存存储
3.⽣命周期
成员变量堆内存存储，声明周期较长
局部变量栈内存存储，使⽤完毕后就消失，声明周期较短
4.作⽤范围
成员变量作⽤范围是整个类，最⼤
局部变量只在⽅法、语句中有效，最⼩
5.初始化赋值
成员变量堆内存，有默认值
局部变量栈内存，必须⼿动赋值
静态成员变量和⾮静态成员变量的区别
1.static修饰成员变量、类变量 ------- 属于类
⾮静态成员变量、实例变量、对象变量 ------- 属于对象
2.内存位置
静态，跟随类的加载⽽加载，随着类的消亡⽽消亡，⽅法区
⾮静态，跟随对象在堆中，没有引⽤变量后，成为垃圾
3.⽣命周期
静态随着类的加载⽽加载，⽣命最长
⾮静态成员变量，随着对象加载，⽣命相对较短
4.调⽤⽅式
静态，可以被类名、对象调⽤，使⽤类名
⾮静态，只能对象调⽤
5.作⽤意义
静态是所有对象共享数据
⾮静态是每个对象的特有数据。

Java线程安全问题之静态成员变量、实例成员变量、局部变量java多线程编程中，存在很多线程安全问题，至于什么是线程安全呢，给出一个通俗易懂的概念还是蛮难的，如同《java并发编程实践》中所说：写道此处不赘述了，首先给出静态变量、实例变量、局部变量在多线程环境下的线程安全问题结论，然后用示例验证，请大家擦亮眼睛，有错必究，否则误人子弟！静态成员变量：线程非安全（无论单例或者非单例皆不安全）。

静态变量即类变量，位于方法区，为所有对象共享，共享一份内存，一旦静态变量被修改，其他对象均对修改可见，故线程非安全。

实例成员变量：单例模式（只有一个对象实例singleton存在）线程非安全，非单例线程安全。

实例变量为对象实例私有，在虚拟机的堆heap中分配，若在系统中只存在一个此对象的实例，在多线程环境下，“犹如”静态变量那样，被某个线程修改后，其他线程对修改均可见，故线程非安全（如，springmvc controller是单例的，非线程安全的）；如果每个线程执行都是在不同的对象中，那对象与对象之间的实例变量的修改将互不影响，故线程安全（如，struts2 action默认是非单例的，每次请求在heap中new新的action实例，故struts2 action可以用实例成员变量）。

局部变量：线程安全（线程封闭性Thread Confinement）。

每个线程执行时将会把局部变量放在各自栈帧的工作内存中，线程间不共享，故不存在线程安全问题。

〖by self：上述所有的变量均指，共享的（Shared）和可变的（Mutable，进行了'read''write'操作）状态变量，只有对这样的变量讨论线程安全才有意义，所有实际上上述的“局部变量”一定是线程安全的，因为其不是共享的（Not Shared），至于非状态变量，毫无疑问，是线程安全的。

〗静态成员变量线程安全问题模拟：----------------------------------------------------------------------------------[java] view plain copy1./**2.* 线程安全问题模拟执行3.* ------------------------------4.* 线程1 | 线程25.* ------------------------------6.* static_i = 4; | 等待7.* static_i = 10; | 等待8.* 等待 | static_i = 4;9.* static_i * 2; | 等待10.* -----------------------------11.* */12.public class Test implements Runnable13.{14.private static int static_i;//静态变量15.16.public void run()17.{18.static_i = 4;19.System.out.println("[" + Thread.currentThread().getNa me()20.+ "]获取static_i 的值:" + static_i);21.static_i = 10;22.System.out.println("[" + Thread.currentThread().getNa me()23.+ "]获取static_i*2的值:" + static_i * 2);24.}25.26.public static void main(String[] args)27.{28.Test t = new Test();29.//启动尽量多的线程才能很容易的模拟问题30.for (int i = 0; i < 3000; i++)31.{32.//t可以换成new T est(),保证每个线程都在不同的对象中执行，结果一样33.new Thread(t, "线程" + i).start();34.}35.}36.}根据代码注释中模拟的情况，当线程1执行了static_i = 4; static_i = 10; 后，线程2获得执行权，static_i = 4; 然后当线程1获得执行权执行static_i * 2; 必然输出结果4*2=8，按照这个模拟，我们可能会在控制台看到输出为8的结果。

浅谈静态变量、成员变量、局部变量三者的区别
静态变量和成员变量的区别：
A:所属不同
静态变量：属于类，类变量
成员变量：属于对象，对象变量，实例变量
B:内存位置不同
静态变量：⽅法区的静态区
成员变量：堆内存
C:⽣命周期不同
静态变量：静态变量是随着类的加载⽽加载，随着类的消失⽽消失
成员变量：成员变量是随着对象的创建⽽存在，随着对象的消失⽽消失
D:调⽤不同
静态变量：可以通过对象名调⽤，也可以通过类名调⽤
成员变量：只能通过对象名调⽤
成员变量和局部变量的区别：
A:在类中的位置不同
成员变量：在类中⽅法外
局部变量：在⽅法定义中或者⽅法声明上
B:在内存中的位置不同
成员变量：在堆内存
局部变量：在栈内存
C:⽣命周期不同
成员变量：随着对象的创建⽽存在，随着对象的消失⽽消失
局部变量：随着⽅法的调⽤⽽存在，随着⽅法的调⽤完毕⽽消失
D:初始化值不同
成员变量：有默认初始化值
局部变量：没有默认初始化值，必须定义，赋值，然后才能使⽤。

注意事项：
局部变量名称可以和成员变量名称⼀样，在⽅法中使⽤的时候，采⽤的是就近原则。

以上就是⼩编为⼤家带来的浅谈静态变量、成员变量、局部变量三者的区别的全部内容了，希望对⼤家有所帮助，多多⽀持~。

Java知识6局部变量、成员变量和类变量的区别【多测师】⼀、局部变量、成员变量、类变量静态变量：由static修饰的变量为静态变量本质为全局变量成员变量、类变量区别：1、成员变量随着对象创建存在对象回收⽽释放2、静态变量随着类加载⽽存在类消失⽽消失3、成员变量只能被对象调⽤4、静态变量可以被对象和类调⽤5、成员变量也称实例变量、数据存储在堆内存的对象中称对象的特有数据6、静态变量也称类变量、数据存储在⽅法区称对象的共享数据7、类变量声明在类中、⽅法体之外但必须声明为static类型8、静态⽅法不能使⽤this 因为this代表对象举例如下：局部变量：在⽅法、构造⽅法、语句块中定义的变量。

其声明和初始化在⽅法中实现，在⽅法结束后⾃动销毁public class ClassName{public void printNumber(){int a;}// 其他代码}成员变量：定义在类中，⽅法体之外。

变量在创建对象时实例化。

成员变量可被类中的⽅法、构造⽅法以及特定类的语句块访问。

public class ClassName{int a;public void printNumber(){// 其他代码}}类变量：定义在类中，⽅法体之外，但必须要有static来声明变量类型。

静态成员属于整个类，可通过对象名或类名来调⽤。

public class ClassName{static int a;public void printNumber(){// 其他代码}}⼆、类构造⽅法1、构造⽅法名字和类相同没有返回值2、不能直接调⽤构造⽅法要通过new关键字来⾃动调⽤、从⽽创建类的实例3、Java类必须要有构造⽅法如果没有Java编译器会⾃动提供不带参数的构造⽅法4、New关键字的作⽤：为对象分配内存空间引起对象构造⽅法的调⽤5、使⽤java类实例化⼀个对象的时候，如果在类中不显式的声明其构造函数，则会使⽤⼀个默认的构造函数来初始化对象。

Jαvα变量类型
Java共有三种变量，分别是类变量（也叫静态变量）、成员变量（也叫实例变量）、局部变量。

三种变量的使用范围不相同。

1、类变量
类变量是定义在类内、方法外的变量，用static修饰，可以被方法调用，也可以被类调用。

可以用访问修饰符来修饰。

2、成员变量
成员变量也是定义在类内、方法外的变量，不能用static修饰（这也是与类变量做区分最直接的方式），只能被实例对象调用，随着实例对象的出现而出现，随着实例对象的消失而消失，也可以用访问修饰符来修饰。

3、局部变量
局部变量是定义在类内、方法内的变量，不可以用访问修饰符来修饰。

在方法执行时局部变量被调用，方法执行完成后消失。