局部变量与全局变量区别,栈、堆和静态存储区的区别
C++变量根据定义位置的不同，具有不同的作用域，作用域可分为6种：全局作用域，局部作用域，语句作用域，类作用域，命名作用域和文件作用域。
从作用域看：全局变量具有全局作用域。
全局变量只需在一个源文件中定义，就可以作用于所有的源文件。
当然，其他不包括全局变量定义的源文件需要用extern关键字再次声明这个全局变量。
静态局部变量具有局部作用域。
它只被初始化一次，自从第一次初始化直到程序与你新内阁结束都一直存在，他和全局变量的区别在于全局变量对所有的函数都是可见的，而静态局部变量只对定义自己的函数体始终可见。
局部变量也只有局部作用域，他是自动对象，他在程序运行期间不是一直存在，而是只在函数执行期间存在，函数的一次调用结束后，变量就被撤销，其所占用的内存也被收回。
静态全局变量也具有全局作用域，他与全局变量的区别在于如果程序包含多个文件的话，他作用于定义它的文件里，不能作用到其他文件里，即被static关键字修饰过的变量具有文件作用域。
这样即使两个不同的源文件都定义了相同的静态全局变量，他们也是不同的变量。
从分配内存空间看：全局变量、静态局部变量、静态全局变量都在静态存储区分配空间，而局部变量在栈分配空间。
全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。
这两者在存储方式上没有什么不同。
区别在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其他源文件中不能使用它。
由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其他源文件中引起错误。
1、静态变量会被放在程序的静态数据存储区里，这样可以在下一次调用的时候还可以保持原来的赋值。
这一点是他与堆栈变量和堆变量的区别2、变量用static告知编译器，自己仅仅在变量的作用域范围内可见。
这一点是他与全局变量的区别。
从以上分析可以看出，把局部变量改变为静态变量后是改变了他的存储方式，即改变了他的生存期。
把全局变量改变为静态变量后是改变了他的作用域，限制了他的使用范围，因此static这个说明符在不同的地方起的作用是不同的。
TIPS：1、若全局变量仅在单个文件中访问，则可以讲这个变量修改为静态全局变量。
2、若全局变量仅在单个函数中使用，则可以将这个变量修改为该函数的静态局部变量。
3、全局变量、静态局部变量、静态全局变量都存放在静态数据存储区。
4、函数中必须要使用static变量的情况：当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。
预备知识—程序的内存分配一个由C/C++编译的程序占用的内存分为以下几个部分栈区（stack）—由编译器自动分配释放，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
堆区（heap）—一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量、未初始化的静态变量在相邻的另一块区域。
- 程序结束后有系统释放文字常量区—常量字符串就是放在这里的。
程序结束后由系统释放程序代码区—存放函数体的二进制代码。
一个正常的程序在内存中通常分为程序段、数据端、堆栈三部分。
程序段里放着程序的机器码、只读数据，这个段通常是只读，对它的写操作是非法的。
数据段放的是程序中的静态数据。
动态数据则通过堆栈来存放。
在内存中，它们的位置如下：+------------------+ 内存低端| 程序段||------------------|| 数据段||------------------|| 堆栈|+------------------+ 内存高端堆栈是内存中的一个连续的块。
一个叫堆栈指针的寄存器（SP）指向堆栈的栈顶。
堆栈的底部是一个固定地址。
堆栈有一个特点就是，后进先出。
也就是说，后放入的数据第一个取出。
它支持两个操作，PUSH和POP。
PUSH是将数据放到栈的顶端，POP是将栈顶的数据取出。
在高级语言中，程序函数调用、函数中的临时变量都用到堆栈。
为什么呢？因为在调用一个函数时，我们需要对当前的操作进行保护，也为了函数执行后，程序可以正确的找到地方继续执行，所以参数的传递和返回值也用到了堆栈。
通常对局部变量的引用是通过给出它们对SP的偏移量来实现的。
另外还有一个基址指针（FP，在Intel 芯片中是BP），许多编译器实际上是用它来引用本地变量和参数的。
通常，参数的相对FP的偏移是正的，局部变量是负的。
当程序中发生函数调用时，计算机做如下操作：首先把参数压入堆栈；然后保存指令寄存器(IP)中的内容，做为返回地址(RET)；第三个放入堆栈的是基址寄存器(FP)；然后把当前的栈指针(SP)拷贝到FP，做为新的基地址；最后为本地变量留出一定空间，把SP减去适当的数值。
在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。
在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区），在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用；在函数体内定义的static表示只在该函数体内有效。
另外，函数中的"adgfdf"这样的字符串存放在常量区。
对比：1 性能栈：栈存在于RAM中。
栈是动态的，它的存储速度是第二快的。
stack堆：堆位于RAM中，是一个通用的内存池。
所有的对象都存储在堆中。
heap2 申请方式stack【栈】:由系统自动分配。
例如，声明在函数中一个局部变量int b; 系统自动在栈中为b开辟空间。
heap【堆】:需要程序员自己申请，并指明大小，在c中malloc函数如p1 = (char *)malloc(10); 在C++中用new 运算符如p2 = (char *)malloc(10); 但是注意：p1、p2本身是在栈中的。
3 申请后系统的响应栈【stack】：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆【heap】：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序；另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。
另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
4 申请大小的限制栈【stack】：在Windows下，栈是向低地址扩展的数据结构，是一块连续的内存的区域。
这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。
因此，能从栈获得的空间较小。
堆【heap】：堆是向高地址扩展的数据结构，是不连续的内存区域。
这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。
堆的大小受限于计算机系统中有效的虚拟内存。
由此可见，堆获得的空间比较灵活，也比较大。
5 申请效率的比较栈【stack】：由系统自动分配，速度较快。
但程序员是无法控制的。
堆【heap】：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便.另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。
但是速度快，也最灵活。
6 堆和栈中的存储内容栈【stack】：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。
注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆【heap】：一般是在堆的头部用一个字节存放堆的大小。
堆中的具体内容有程序员安排。
7 存取效率的比较char s1[] = "aaaaaaaaaaaaaaa";char *s2 = "bbbbbbbbbbbbbbbbb";aaaaaaaaaaa是在运行时刻赋值的；而bbbbbbbbbbb是在编译时就确定的；但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：#includevoid main(){char a = 1;char c[] = "90";char *p ="90";a = c[1];a = p[1];return;}对应的汇编代码10: a = c[1];00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]0040106A 88 4D FC mov byte ptr [ebp-4],cl11: a = p[1];0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]00401070 8A 42 01 mov al,byte ptr [edx+1]00401073 88 45 FC mov byte ptr [ebp-4],al第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。
小结：堆和栈的区别可以用如下的比喻来看出：使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
C C++语言变量声明内存分配
C/C++语言变量声明内存分配2010-11-08 07:10:20| 分类：编程|字号订阅一个由c/C++编译的程序占用的内存分为以下几个部分1、栈区（stack）—程序运行时由编译器自动分配，存放函数的参数值，局部变量的值等。
其操作方式类似于数据结构中的栈。
程序结束时由编译器自动释放。
2、堆区（heap）—在内存开辟另一块存储区域。
一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—编译器编译时即分配内存。
全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
- 程序结束后由系统释放4、文字常量区—常量字符串就是放在这里的。
程序结束后由系统释放5、程序代码区—存放函数体的二进制代码。
例子程序这是一个前辈写的，非常详细//main.cppint a = 0; 全局初始化区char *p1; 全局未初始化区main(){int b;// 栈char s[] = "abc"; //栈char *p2; //栈char *p3 = "123456"; //"123456/0"在常量区，p3在栈上。
static int c =0；//全局（静态）初始化区p1 = (char *)malloc(10);p2 = (char *)malloc(20);//分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); //123456/0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}===============C语言程序的内存分配方式1.内存分配方式内存分配方式有三种：[1]从静态存储区域分配。
嵌入式实时系统中局部变量和全局变量
嵌入式实时系统中局部变量和全局变量一、首先简要介绍局部变量和全局变量区别（1）作用域全局变量具有全局作用域，适用于所有源文件。
但在不包含全局变量定义的文件中，需使用extern关键字声明这个全局变量后，方可正常使用。
静态全局变量也具有全局作用域。
它与全局变量的区别是，它仅仅作用于定义它的文件，程序中其他文件不可用。
局部变量只有局部作用域。
只在函数执行期间存在，当函数调用结束后，变量将被撤销，其所占用内存被收回。
静态局部变量只有局部作用域。
它从初始化到函数运行结束一直存在，在整个程序运行期间一直有效。
它与全局变量的区别在于，全局变量对所有函数可见，而静态局部变量只对自己的函数始终可见。
（2）存储空间全局变量、静态全局变量、静态局部变量都在静态存储区分配空间，而局部变量在栈分配空间。
二、Cortex-M3内核中MSP/PSP1、在CM3处理器中有两个堆栈指针MSP/PSP，这两个都是R13/SP，R13是Banked。
MSP：它有OS内核、异常服务历程以及所有需要特权访问的应用程序代码访问。
程序复位默认使用MSP。
PSP：用于常规的应用程序代码。
通过CM3的CONTROL寄存器可选择当前使用哪个堆栈指针。
2、图1上图1所示为未使用OS时，堆栈的使用情况。
图2上图2所示为使用OS时，堆栈的使用情况。
3、使用OS时，MSP及PSP跳转状态及任务堆栈切换时变化1）任务切换前的状态假设系统中有两个任务，Task1和Task2，Task1是当前正在运行的任务（由OSTCBCur指出），Task2处于挂起状态。
那么进入OS_CPU_PendSVHandler中断前，堆栈状态如下图所示。
CPU处于线程状态，使用PSP堆栈工作，PSP指向Task1的堆栈。
CPU中的各寄存器是Task1当前任务的寄存器值。
Task2处于挂起状态，Task2的堆栈指针由TCB2的SP变量保存着。
在Task2的堆栈底部，保存有两部分数据，一部分是CPU中断时自动保存到堆栈的寄存器变量（包括xPSR,PC,LR,R12,R0~R3），另一部分是uCOS额外保存的寄存器变量(R4~R11)，这些寄存器保存了Task2挂起前的所有数据。
单片机C语言 必知的数据存储与程序编写知识 附单片机应用编程知识介绍
一、五大内存分区内存分成5个区，它们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
1、栈区（StaCk）：FIFo就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。
里面的变量通常是局部变量、函数参数等。
2、堆区（heap）：就是那些由new分配的内存块，它们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
3、自由存储区：就是那些由malloc等分配的内存块，它和堆是十分相似的，不过它是用free 来结束自己的生命。
4、全局/静态存储区：全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
5、常量存储区：这是一块比较特殊的存储区，它们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）code/data/stack内存主要分为代码段，数据段和堆栈。
代码段放程序代码，属于只读内存。
数据段存放全局变量，静态变量，常量等，堆里存放自己malloc或new出来的变量，其他变量就存放在栈里，堆栈之间空间是有浮动的。
数据段的内存会到程序执行完才释放。
调用函数先找到函数的入口地址，然后计算给函数的形参和临时变量在栈里分配空间，拷贝实参的副本传给形参，然后进行压栈操作，函数执行完再进行弹栈操作。
字符常量一般放在数据段，而且相同的字符常量只会存一份。
二、C语言程序的存储区域1、由C语言代码（文本文件）形成可执行程序（二进制文件），需要经过编译-汇编-连接三个阶段。
编译过程把C语言文本文件生成汇编程序，汇编过程把汇编程序形成二进制机器代码，连接过程则将各个源文件生成的二进制机器代码文件组合成一个文件。
2、C语言编写的程序经过编译-连接后，将形成一个统一文件，它由几个部分组成。
堆栈及静态数据区详解
堆、栈及静态数据区详解五大内存分区在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。
栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。
里面的变量通常是局部变量、函数参数等。
堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。
如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free 来结束自己的生命的。
全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改，而且方法很多）明确区分堆与栈在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
首先，我们举一个例子：void f() { int* p=new int[5]; }这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p。
在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：00401028 push 14h0040102A call operator new (00401060)0040102F add esp,400401032 mov dword ptr [ebp-8],eax00401035 mov eax,dword ptr [ebp-8]00401038 mov dword ptr [ebp-4],eax这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie 信息去进行释放内存的工作。
堆与栈,静态变量和全局变量的区别
堆与栈，静态变量和全局变量的区别堆与栈，静态变量和全局变量的区别对和栈的主要的区别由以下几点：1、管理方式不同；2、空间大小不同；3、能否产生碎片不同；4、生长方向不同；5、分配方式不同；6、分配效率不同；管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak。
空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。
但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。
当然，我们可以修改：打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。
对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以参考数据结构，这里我们就不再一一讨论了。
生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
分配方式：堆都是动态分配的，没有静态分配的堆。
栈有2种分配方式：静态分配和动态分配。
静态分配是编译器完成的，比如局部变量的分配。
动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。
C语言内存分配问题(整理)
我查了下资料，有说分四个，有说分五个加一个程序代码区，我没查到参考的专业书籍。所 以麻烦知道的告知一下，完善一下。
2、 内存分配方式 内存分配方式有三种：
1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整 个运行期间都存在。例如全局变量，static 变量。
4、动态分配释放内存举例 用 malloc 动态分配内存后一定要判断一下分配是否成功，判断指针的值是否为 NULL。 内存分配成功后要对内存单元进行初始化。 内存分配成功且初始化后使用时别越界了。 内存使用完后要用 free（p）释放，注意，释放后，p 的值是不会变的，仍然是一个地址值， 仍然指向那块内存区，只是这块内存区的值变成垃圾了。为了防止后面继续使用这块内存， 应在 free(p)后，立即 p=NULL，这样后面如果要使用，判断 p 是否为 NULL 时就会判断出 来。
NO.2
char *GetMemory(void) {
char Байду номын сангаас[] = hello world; retrun p; } void Test(void) { char *str = NULL; str = GetMemory(); printf(str); }
问题同 NO.1
NO.3
void GetMemory(char **p, int num) {
free(str); if(str != NULL) {
strcpy(str,"world"); printf(str); } }
问题同 NO.1 我对以上问题的分析：
NO.1：程序首先申请一个 char 类型的指针 str,并把 str 指向 NULL（即 str 里存的是 NULL 的地址，*str 为 NULL 中的值为０），调用函数的过程中做了如下动作： 1、申请一个 char 类型的指针 p， 2、把 str 的内容 copy 到了 p 里（这是参数传递过程中系统所做的）, 3、为 p 指针申请了 100 个空间， 4、返回 Test 函数．最后程序把字符串 hello world 拷贝到 str 指向的内存空间里．到这里错 误出现了！ str 的空间始终为 NULL 而并没有实际的空间．深刻理解函数调用的第 2 步，将不难发现问 题所在！（注意：传递的参数和消除的参数） NO.2：程序首先申请一个 char 类型的指针 str,并把 str 指向 NULL．调用函数的过程中做了 如下动作： １申请一数组 p[]并将其赋值为 hello world(数组的空间大小为 12)， ２返回数组名 p 付给 str 指针（即返回了数组的首地址）． 那么这样就可以打印出字符串＂hello world＂了么？当然是不能的！ 因为在函数调用的时候漏掉了最后一步．也就是在第２步 return 数组名后，函数调用还要 进行一步操作，也就是释放内存空间．当一个函数被调用结束后它会释放掉它里面所有的变 量所占用的空间．所以数组空间被释放掉了，也就是说 str 所指向的内容将不确定是什么东 西． NO.3：正确答案为可以打印出 hello．但内存泄漏了！ 需要用 free（）函数进行释放。
堆和栈，malloc分配的空间是堆，局部变量都在栈中
堆和栈，malloc分配的空间是堆，局部变量都在栈中堆和栈的区别⼀个由C/C++编译的程序占⽤的内存分为以下⼏个部分1、栈区（stack）— 由编译器⾃动分配释放，存放函数的参数值，局部变量的值等。
其操作⽅式类似于数据结构中的栈。
2、堆区（heap） — ⼀般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。
注意它与数据结构中的堆是两回事，分配⽅式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在⼀块的，初始化的全局变量和静态变量在⼀块区域，未初始化的全局变量和未初始化的静态变量在相邻的另⼀块区域。
- 程序结束后由系统释放。
4、⽂字常量区 —常量字符串就是放在这⾥的。
程序结束后由系统释放5、程序代码区—存放函数体的⼆进制代码。
例⼦：#include <stdio.h>int a = 0; 全局初始化区char *p1; 全局未初始化区main(){ int b; 栈 char s[] = "abc"; 栈 char *p2; 栈 char *p3 = "123456"; 123456\0在常量区，p3在栈上。
static int c =0；全局（静态）初始化区 p1 = (char *)malloc(10); p2 = (char *)malloc(20); //分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); //123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成⼀个地⽅。
}。
java中的全局变量、局部变量与静态常量的区别
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关键字声明，但必须在⽅法构造⽅法和语句块之外。
内存分配的三种方式
内存分配的三种⽅式⼀、内存基本分配可编程内存在基本上分为这样的⼏⼤部分：静态存储区、堆区和栈区。
静态存储区：内存在程序编译的时候就已经分配好，这块内存在程序的整个运⾏期间都存在。
它主要存放静态数据、全局数据和常量。
栈区：在执⾏函数时，函数内局部变量的存储单元都可以在栈上创建，函数执⾏结束时这些存储单元⾃动被释放。
堆区：亦称动态内存分配。
程序在运⾏的时候⽤malloc或new申请任意⼤⼩的内存，程序员⾃⼰负责在适当的时候⽤free或delete释放内存。
动态内存的⽣存期可以由我们决定，如果我们不释放内存，程序将在最后才释放掉动态内存。
但是，良好的编程习惯是：如果某动态内存不再使⽤，需要将其释放掉，否则，我们认为发⽣了内存泄漏现象。
⼆、三者之间的区别我们通过代码段来看看对这样的三部分内存需要怎样的操作和不同，以及应该注意怎样的地⽅。
例⼀：静态存储区与栈区char* p = “Hello World1”;char a[] = “Hello World2”;p[2] = ‘A’;a[2] = ‘A’;char* p1 = “Hello World1;”这个程序是有错误的，错误发⽣在p[2] = ‘A’这⾏代码处，为什么呢？是指针变量p和变量数组a都存在于栈区的（任何临时变量都是处于栈区的，包括在main（）函数中定义的变量）。
但是，数据“Hello World1”和数据“Hello World2”是存储于不同的区域的。
因为数据“Hello World2”存在于数组中，所以，此数据存储于栈区，对它修改是没有任何问题的。
因为指针变量p仅仅能够存储某个存储空间的地址，数据“Hello World1”为字符串常量，所以存储在静态存储区。
虽然通过p[2]可以访问到静态存储区中的第三个数据单元，即字符‘l’所在的存储的单元。
但是因为数据“Hello World1”为字符串常量，不可以改变，所以在程序运⾏时，会报告内存错误。
局部变量和全局变量的区别
局部变量和全局变量的区别1.定义的位置不同：
局部变量定义在⽅法内部。
成员变量定义在⽅法的外部，直接在类中。
2.作⽤范围不同：
局部变量只有在⽅法当中才能使⽤，出了⽅法就不能⽤了。
成员变量在整个类中全都可以使⽤。
3.默认值不同：
局部变量没有默认值，如果想要使⽤，必须要⼿动进⾏赋值。
成员变量如果没有赋值会有默认值，规则和数组⼀样。
4.⽣命周期不同：
局部变量随着⽅法进栈⽽诞⽣，随着⽅法的出栈⽽消失。
成员变量随着对象的创建⽽诞⽣，随着对象被垃圾回收机制回收⽽消失。