static有什么用途

静态构造函数： （1）用于对静态字段、只读字段等的初始化。 （2）添加static关键字，不能添加访问修饰符，因为静态构造函数都是私有的。 （3）类的静态构造函数在给定应用程序域中至多执行一次：只有创建类的实例或者引用类的任何静态成员才激发静态构造函数 （4）静态构造函数是不可继承的，而且不能被直接调用。 （5）如果类中包含用来开始执行的 Main 方法，则该类的静态构造函数将在调用 Main 方法之前执行。 （6）任何带有初始值设定项的静态字段，则在执行该类的静态构造函数时，先要按照文本顺序执行那些初始值设定项。 （7）如果没有编写静态构造函数，而这时类中包含带有初始值设定的静态字段，那么编译器会自动生成默认的静态构造函数。*************************************************** 静 态 构 造 函 数 练 习* （1）①②③……为执行顺序* （2）输出结果： static A()* static B()* X = 1, Y = 2***************************************************/using System;class A{public static int X;static A() //④ 执行完后返回到③{X = B.Y + 1;Console.WriteLine("static A()");}}class B{public static int Y = A.X + 1; //③ 调用了A的静态成员,// 转到A的静态构造函数---->static B() //② 如果带有初始值设定项的静态字段,// 执行该类的静态构造函数时,// 先要按照文本顺序执行那些初始值设定项。// 转到初始值设定项---->{Console.WriteLine("static B()");}static void Main() //① 程序入口,// 如果类中包含用来开始执行的 Main 方法,// 该类的静态构造函数将在调用 Main 方法之前执行。// 转到B的静态构造函数---->{Console.WriteLine("X = {0}, Y = {1}", A.X, B.Y);//⑤ 输出结果Console.ReadLine();}}

二、static修饰的变量 1. 全局静态变量 在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。 1）内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在） 2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是 任意的，除非他被显示初始化） 3）作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。 定义全局静态变量的好处： <1>不会被其他文件所访问，修改 <2>其他文件中可以使用相同名字的变量，不会发生冲突。 2. 局部静态变量 在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。 1）内存中的位置：静态存储区 2）初始化：未经初始化的局部静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化） 3）作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。 注：当static用来修饰局部变量的时候，它就改变了局部变量的存储位置，从原来的栈中存放改为静态存储区。但是局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对他进行访问。

一、 定义全局静态变量 ：在全局变量前面加上关键字static，该全局变量变成了全局静态变量。全局静态变量有以下特点：（1） 在全局数据区内分配内存（2） 如果没有初始化，其默认值为0（3） 该变量在本文件内从定义开始到文件结束可见 二、 定义局部静态变量：在局部静态变量前面加上关键字static，该局部变量便成了静态局部变量。静态局部变量有以下特点:（1） 该变量在全局数据区分配内存（2） 如果不显示初始化，那么将被隐式初始化为0（3） 它始终驻留在全局数据区，直到程序运行结束（4） 其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。 三、 定义静态函数：在函数的返回类型加上static关键字，函数即被定义成静态函数。静态函数有以下特点：（1） 静态函数只能在本源文件中使用（2） 在文件作用域中声明的inline函数默认为static 说明：静态函数只是一个普通的全局函数，只不过受static限制，他只能在文件坐在的编译单位内使用，不能呢个在其他编译单位内使用。在C++语言中新增了两种作用：定义静态数据成员或静态函数成员 一， 定义静态数据成员。静态数据成员有如下特点：（1） 内存分配：在程序的全局数据区分配（2） 初始化和定义：静态数据成员定义时要分配空间，所以不能在类声明中初始化。 二， 静态成员函数。静态成员函数与类相联系，不与类的对象相联系。静态成员函数不能访问非静态数据成员。原因很简单，非静态数据成员属于特定的类实例，静态成员函数主要用于对静态数据成员的操作。（1） 静态成员函数没有this指针。

关注此问题

static关键字至少有下列n个作用：（1）设置变量的存储域，函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；（2）限制变量的作用域，在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；（3）限制函数的作用域，在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；（4）在类中的static成员变量意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见；（5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

在c中全局变量的说明之前再加以static 就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出，把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围java类的成员变量有俩种：一种是被static关键字修饰的变量，叫类变量或者静态变量；另一种没有static修饰，为实例变量。　　在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。　　在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

都是不会改变的...区别在于: 常量本身就是值的形式,内存中是不分空间的而静态变量,是变量形式,内存中是要分空间的用途:常量一般是用在程序总体某些公式的最前定义的.比如: 数据库的SEVER,USER,PSW之类的静态变量,是用在参于不变值计算的比如:用户登陆的几种状态可以定义几个静态变量来加以区分.

auto 局部变量 auto 变量是用堆栈(stack)方式占用储存器空间，因此，当执行此区段是，系统会立即为这个变量分配存储器空间，而程序执行完后，这个堆栈立即被系统收回．在大括号{}内声明． 自动变量就是指在函数内部定义使用的变量。他只是允许在定义他的函数内部使用它。在函数外的其他任何地方都不能使用的变量。自动变量是局部变量，即它的区域性是在定义他的函数内部有效。当然这说明自动变量也没有链接性，因为它也不允许其他的文件访问他。由于自动变量在定义他的函数的外面的任何地方都是不可见的，所以允许我们在这个函数外的其他地方或者是其他的函数内部定义同名的变量，他们之间不会发生冲突的。因为他们都有自己的区域性，而且它没有链接性（即：不允许其他的文件访问他的）。来看看自动量的持续性。计算机在执行这个函数的时候，创建并为它分配内存，当函数执行完毕返回后，自动变量就会被销毁。这个过程是通过一个堆栈的机制来实现的。为自动变量分配内存就压栈，而函数返回时就退栈。static 静态变量一、局部静态变量局部变量按照存储形式可分为三种auto, static, register。 与auto类型(普通)局部变量相比, static局部变量有三点不同：1. 存储空间分配不同auto类型分配在栈上, 属于动态存储类别, 占动态存储区空间, 函数调用结束后自动释放, 而static分配在静态存储区, 在程序整个运行期间都不释放. 两者之间的作用域(有效范围)相同, 但生存期不同.2. static局部变量在所处模块在初次运行时进行初始化工作, 且只操作一次。3. 对于局部静态变量, 如果不赋初值, 编译期会自动赋初值0或空字符, 而auto类型的初值是不确定的.特点: static局部变量的”记忆性”与生存期的”全局性”所谓”记忆性”是指在两次函数调用时, 在第二次调用进入时, 能保持第一次调用退出时的值. 注意事项:1. “记忆性”, 程序运行很重要的一点就是可重复性, 而static变量的”记忆性”破坏了这种可重复性, 造成不同时刻至运行的结果可能不同.2. “生存期”全局性和唯一性. 普通的local变量的存储空间分配在stack上, 因此每次调用函数时, 分配的空间都可能不一样, 而static具有全局唯一性的特点, 每次调用时, 都指向同一块内存, 这就造成一个很重要的问题 ---- 不可重入性!!!二、外部静态变量/函数在C中static有了第二种含义：用来表示不能被其它文件访问的全局变量和函数。, 但为了限制全局变量/函数的作用域, 函数或变量前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。注意此时, 对于外部(全局)变量, 不论是否有static限制, 它的存储区域都是在静态存储区, 生存期都是全局的. 此时的static只是起作用域限制作用, 限定作用域在本模块(文件)内部.使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。

静态关键字.........

我来告诉你吧。。哈哈非静态的方法 比如 void test(int a)有几个参数呢。。两个。。一个是int类型 一个就是调用这个方法的对象。。在方法体内可以用this使用它。。这个对象是作为隐式参数传进这个方法的。。所谓隐式参数就是可以不用写明的。。比如你调用这个方法。。你需要一个对象去调用他。。调用的时候还需要传一个int类型的参数。。所以这个方法有两个参数。。静态方法 比如static void test(int a)有几个参数呢。。只有一个int类型了。。因为静态方法不需要实例对象就能直接调用。。所以他的参数只有一个a。。所以你在里面不能使用this。因为他并没有将这个对象作为参数传进去。。所以如果你在静态方法里调用了非静态方法的话。比如static void test(int a) { test1(a);//test1是非静态方法}那么test1需要两个参数是吧。。现在有一个你给他了。。还有一个呢。。就是调用它的对象呢。。你并没有给他。。也没法给他。。因为静态方法里没有那个隐式参数。。所以明白了吗。。静态变量也是一样了撒。

对，你说对了， 比如静态代码块，是程序进行周期最长的，在类加载的时候（没有new对象的时候就进行初始化），因为是静态（即在程序进行时都存在），所以值赋值一次···

（1）函数体内 static 变量的作用范围为该函数体，不同于 auto 变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值； （2）在模块内的 static 全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；（3）在模块内的 static 函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内； （4）在类中的 static 成员变量属于整个类所拥有，对类的所有对象只有一份拷贝； （5）在类中的 static 成员函数属于整个类所拥有，这个函数不接收 this 指针，因而只能访问类的static 成员变量。

#includeintf(intn);main(){inta=3,s;s=f(a);//s=4s=s+f(a);//f(a)=5;s=4+5=9;printf("%d ",s);}intf(intn){staticinta=1;//这里是静态变量，静态变量的特点是赋值语句仅执行一次n+=a++;//这句话相当于n=n+a;a++；后置++先返回原数值，然后自变量+1//所以第一次s=f(3)n=3,a=1;n+=1=4,a=2,f(a)=4//s=4;//第二次f(3),n=3,(a=1这句话不执行),a=2,n+=2=5,a=3,f(3)=5//s+=5=9returnn;}程序运行后的输出结果是9;

static void clrpchist __P((void));此句是申明了一个名为lrpchist __P的函数，函数无返回值，无参数，static修饰表示此函数只能在当前文件被调用，不能被其它.c文件中被调用。补充static用法：在C中，static主要定义全局静态变量、定义局部静态变量、定义静态函数。1. 定义全局静态变量：在全局变量前面加上关键字static，该全局变量变成了全局静态变量。全局静态变量有以下特点。a.在全局区分配内存。b.如果没有初始化，其默认值为0.c.该变量在本文件内从定义开始到文件结束可见。2. 定义局部静态变量：在局部变量前面加上关键字static，其特点如下：a.该变量在全局数据区分配内存。b.它始终驻留在全局数据区，直到程序运行结束。c. 其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。3. 定义静态函数：在函数返回类型前加上static关键字，函数即被定义为静态函数，其特点如下：a.静态函数只能在本源文件中使用b.在文件作用域中声明的inline函数默认为static类型

　　extern int x,y; 　　　　　　　　　 说明x,y为外部整型变量 　　下面分别介绍以上四种存储类型： 　　一、自动变量的类型说明符为auto。 　　这种存储类型是C语言程序中使用最广泛的一种类型。C语言规定， 函数内凡未加存储类型说明的变量均视为自动变量， 也就是说自动变量可省去说明符auto。 在前面各章的程序中所定义的变量凡未加存储类型说明符的都是自动变量。例如： 　　{ int i,j,k; 　　char c; 　　u2026u2026 　　}等价于： { auto int i,j,k; 　　auto char c; 　　u2026u2026 　　} 　　自动变量具有以下特点： 　　1. 自动变量的作用域仅限于定义该变量的个体内。在函数中定义的自动变量，只在该函数内有效。在复合语句中定义的自动变量只在该复合语句中有效。 例如： 　　int kv(int a) 　　{ 　　auto int x,y; 　　{ auto char c; 　　} /*c的作用域*/ 　　u2026u2026 　　} /*a,x,y的作用域*/ 　　2. 自动变量属于动态存储方式，只有在使用它，即定义该变量的函数被调用时才给它分配存储单元，开始它的生存期。函数调用结束，释放存储单元，结束生存期。因此函数调用结束之后，自动变量的值不能保留。在复合语句中定义的自动变量，在退出复合语句后也不能再使用，否则将引起错误。例如以下程序： 　　main() 　　{ auto int a,s,p; 　　printf(" input a number: "); 　　scanf("%d",&a); 　　if(a>0){ 　　s=a+a; 　　p=a*a; 　　} 　　printf("s=%d p=%d ",s,p); 　　} 　　{ auto int a; 　　printf(" input a number: "); 　　scanf("%d",&a); 　　if(a>0){ 　　auto int s,p; 　　s=a+a; 　　p=a*a; 　　} 　　printf("s=%d p=%d ",s,p); 　　} 　　s,p是在复合语句内定义的自动变量，只能在该复合语句内有效。而程序的第9行却是退出复合语句之后用printf语句输出s,p的值，这显然会引起错误。 　　3. 由于自动变量的作用域和生存期都局限于定义它的个体内( 函数或复合语句内)， 因此不同的个体中允许使用同名的变量而不会混淆。 即使在函数内定义的自动变量也可与该函数内部的复合语句中定义的自动变量同名。例5.14表明了这种情况。 　　[例5.14] 　　main() 　　{ 　　auto int a,s=100,p=100; 　　printf(" input a number: "); 　　scanf("%d",&a); 　　if(a>0) 　　{ 　　auto int s,p; 　　s=a+a; 　　p=a*a; 　　printf("s=%d p=%d ",s,p); 　　} 　　printf("s=%d p=%d ",s,p); 　　} 　　本程序在main函数中和复合语句内两次定义了变量s,p为自动变量。按照C语言的规定，在复合语句内，应由复合语句中定义的s,p起作用，故s的值应为a+ a，p的值为a*a。退出复合语句后的s,p 应为main所定义的s,p，其值在初始化时给定，均为100。从输出结果可以分析出两个s和两个p虽变量名相同， 但却是两个不同的变量。 　　4. 对构造类型的自动变量如数组等，不可作初始化赋值。 　　二、外部变量外部变量的类型说明符为extern。 　　在前面介绍全局变量时已介绍过外部变量。这里再补充说明外部变量的几个特点： 　　1. 外部变量和全局变量是对同一类变量的两种不同角度的提法。全局变是是从它的作用域提出的，外部变量从它的存储方式提出的，表示了它的生存期。 　　2. 当一个源程序由若干个源文件组成时， 在一个源文件中定义的外部变量在其它的源文件中也有效。例如有一个源程序由源文件F1.C和F2.C组成： F1.C 　　int a,b; /*外部变量定义*/ 　　char c; /*外部变量定义*/ 　　main() 　　{ 　　u2026u2026 　　} 　　F2.C 　　extern int a,b; /*外部变量说明*/ 　　extern char c; /*外部变量说明*/ 　　func (int x,y) 　　{ 　　u2026u2026 　　} 　　在F1.C和F2.C两个文件中都要使用a,b,c三个变量。在F1.C文件中把a,b,c都定义为外部变量。在F2.C文件中用extern把三个变量说明为外部变量，表示这些变量已在其它文件中定义，并把这些变量的类型和变量名，编译系统不再为它们分配内存空间。 对构造类型的外部变量， 如数组等可以在说明时作初始化赋值，若不赋初值，则系统自动定义它们的初值为0。 　　三、静态变量 　　静态变量的类型说明符是static。 静态变量当然是属于静态存储方式，但是属于静态存储方式的量不一定就是静态变量， 例如外部变量虽属于静态存储方式，但不一定是静态变量，必须由 static加以定义后才能成为静态外部变量，或称静态全局变量。 对于自动变量，前面已经介绍它属于动态存储方式。 但是也可以用static定义它为静态自动变量，或称静态局部变量，从而成为静态存储方式。 　　由此看来， 一个变量可由static进行再说明，并改变其原有的存储方式。 　　1. 静态局部变量 　　在局部变量的说明前再加上static说明符就构成静态局部变量。 　　例如： 　　static int a,b; 　　static float array[5]={1,2,3,4,5}; 　　静态局部变量属于静态存储方式，它具有以下特点： 　　(1)静态局部变量在函数内定义，但不象自动变量那样，当调用时就存在，退出函数时就消失。静态局部变量始终存在着，也就是说它的生存期为整个源程序。

static 用来说明静态变量。1、如果是在函数外面定义的，那么其效果和全局变量类似，即static说明的变量可以在当前c程序文件中使用。2、如果是在函数内部定义的，那么这个变量只初始化一次，即使再次调用这个函数，这个static变量也不会再次被初始化，于是，这个变量的取值就会一直保存着，我们再次调用该函数时，仍是保存的上一次函数调用时保存的结果。扩展资料：c语言中的static有三个主要作用：1、隐藏性。当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。2、static可以保持变量内容的持久，当static定义变量在函数内部时，改变量值的生命周期和全局变量相同。3、static可以令其定义变量内存区所有字节默认初始化为0，这一特点可以省去程序员许多麻烦，减少工作量。参考资料来源：百度百科-Static(计算机高级语言)

1、修饰函数的局部变量2、修饰全局函数和全局变量3、修饰类里面的成员变量4、修饰类的成员函数

假如一个变量存在于一个函数中,函数调用结束后,普通变量会被释放内存。而静态变量的内存则不会释放。假如后面的程序段要调用该函数，该函数中该静态变量的值可以继续使用。

static表示静态的,当程序运行时这个变量就在内存中开辟地址了.当这个变量在某函数内定义时,不象自动变量那样，当调用时就存在，退出函数时就消失。静态局部变量始终存在着，也就是说它的生存期为整个源程序。对基本类型的静态局部变量若在说明时未赋以初值，则系统自动赋予0值。而对自动变量不赋初值，则其值是不定的,非静态局部变量在函数关闭后重新打开时就会重置初始值,而静态变量的值和函数本身的调用无关,始终存在.

1、修饰函数static修饰函数使得函数只能在包含该函数定义的文件中被调用。对于静态函数，声明和定义需要放在同一个文件夹中。2、修饰成员变量用static修饰类的数据成员使其成为类的全局变量，会被类的所有对象共享，包括派生类的对象，所有的对象都只维持同一个实例。因此，static成员必须在类外进行初始化，而不能在构造函数内进行初始化，不过也可以用const修饰static数据成员在类内初始化。3、修饰成员函数用static修饰成员函数，使这个类只存在这一份函数，所有对象共享该函数，不含this指针，因而只能访问类的static成员变量。静态成员是可以独立访问的，无须创建任何对象实例就可以访问。4、修饰局部变量static修饰局部变量时，使得被修饰的变量成为静态变量，存储在静态区。存储在静态区的数据生命周期与程序相同，在main函数之前初始化，在程序退出时销毁。5、修饰全局变量全局变量本来就存储在静态区，因此static并不能改变其存储位置。但是，static限制了其链接属性。被static修饰的全局变量只能被该包含该定义的文件访问。

首先说一下int 和public int的区别：这个问题是作用域的问题，就是说这个变量的作用范围是多大。public class Text{int a ;public void toString(){......}对于这个int，他是该类的成员属性，因为没有访问修饰符，所以java默认认为他是default，也就是只有在该类中能访问，其他地方不能访问。和private相似，区别不太清楚。public class Text{public int a;.....对于这个int，由于有public修饰，所以这个变量对于所有类都是可见的，没有访问的限制。static，其实就是一个静态变量的意思。用static修饰的变量又叫类变量，他有很多特性，现在列出来。public static int a，对于这个变量，首先他不需要一个实例化对象，也就是说不需要new 对象就可以用类名+变量名来访问这个变量，当然要看访问修饰符的限制。其次，这个变量是一个全局的变量，就是这个对象被该类的其他所有对象共有。比如：public class Text {public static int a = 1;public static void main(String[] args){Text.a = 2; //这个就是static的作用，不需要new对象就可以访问。Text aa = new Text();Text bb = new Text();//new两个不同的对象aa.a = 3; //这个就是public的作用，说明该成员变量为对外可见。其实这么做 并不好//现在我们想想，bb.a是多少呢？System.out.println(bb.a);结果就是3，因为static修饰的变量时类变量，是被该类所有对象共有，所以你在aa中修改的a的值，而aa和bb是共用这个a变量的。所以bb的a值也再变化。Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

C语言中有两种存取数据的方式。顺序存取：当“打开”文件进行读或写操作时总是从文件的开头开始，从头到尾顺序读或写。直接存取：又称随机存取文件，可以通过调用C语言的库函数来指定开始读（写）的字节号，然后直接对此位置上的数据进行读或写操作。

静态方法中的变量没用static修饰的就不是静态变量，一般静态变量需要用static修饰static{}静态代码块中的变量都是静态的

这个题考的就是静态变量，它有个自动变量不具备特点的就是数值在调用结束后，其固有的值并不改变，且被带到下一次调用中去。不像自动变量在下次调用又被重新初始化了。因此，本题第一次y＝2后下次调用函数时y是从2开始而不是初始化的1。

静态时序分析（STA）可以在逻辑综合、布局布线等步骤后进行，FPGA EDA工具在布局布线完成后给出STA结果，这时的分析结果是最接近实际电路情况的，而逻辑综合时的分析结果是看不到的，也是不准确的（因为没有物理信息，所以只用于指导布局）。如果是用ASIC综合工具（比如DC），两个阶段的STA结果都可以看。

STATIC寄存器变量是一个静态变量寄存器。STATIC寄存用户下发的数据,当用户写入数据后就保存下来,并可供用户读出。static常用来修饰变量。全局变量被static修饰后，就称之为静态全局变量；局部变量被static修饰后，就称之为静态局部变量。统称为静态变量。static静态的可以用来修饰的结构：主要用来修饰类的内部结构（随着类加载而加载）属性、方法、代码块、内部类。static的注意点：在静态的方法内，不能使用this关键字、super关键字。关于静态属性和静态方法的使用，需要从生命周期的角度去理解。当static关键字修饰局部变量时，只会对该变量初始化一次。当static关键字修饰局部变量时，该变量在程序中只有一份内存。当static关键字修饰局部变量时，该变量的作用域不会改变。当static关键字修饰局部变量时，该变量的生命周期被延长，直到程序结束才销毁。当用static关键字修饰全局变量时，该变量的作用域仅限于当前文件，工程中的其他文件不可以访问到该全局变量。

请楼主说清楚下。楼主是在什么情况下，看到了这两个名词。这两个名词是多义的，如果不知道楼主要在什么背景下了解这两个名词的话，是不好解释的。有代码，最好帖代码。没代码，请楼主说明你的意思。

静态类可以被实例化的

静态变量在两个类中一样，原因如下：1、是相同的，static变量是属于类的，属于类所有对象的，当一个类调用并改变static属性时，也改变了所有对象的static属性。2、如果是普通变量的话，一个对象改变其普通属性，只是这个对象的属性发生改变，其他对象的这个属性不发生改变。

返回一个变量,只是返回这个变量的值, 不存在静态还是非静态之说, 硬要说的话,算是非静态的,因为方法体里面只能定义非静态变量. 这么回答看看你能不能懂,这是我自己的理解

静态不能。想做，就对各个属性做序列化。

我理解吧，这个动态跟静态主要是针对指针而言的。而且对于单个变量来说，动态跟静态的概念体现的不是特别清楚，下面主要介绍数组吧。如果你声明一个数组int a[100]，那么这个数组的大小就是100，在内存中的位置也固定，如果后来发现数组不够大，你就只能重新定义一个更大的数组，而不能直接改变数组a的大小。这就是静态存储。如果你声明一个指针int *p，一开始你想开辟一个100的数组，就写p = new int[100]，后面发现100不够大，你可以先delete []p，把原来的空间释放掉，然后让p = new int[200]，p就会指向一个大小为200的数组，这个数组的大小以及在内存中的位置可以根据需要不断变化。这就是动态存储。

前两个是用来修饰变量的,后两个都变量函数都可以定义的变量默认是auto类型的register 寄存器变量，老版的编译系统要手动设置，现在的新版的设定是：如果某个变量用的次数特多，就自动把他变成寄存器变量。寄存器变量运算速度快（因为是存放在CPU中运行的 ps：你应该知道CPU和内存的速度差别吧。如果这个不知道建议看看操作系统原理这类的书，还有以后要接触的多线程也会提到CPU和内存的速度差别）Static是静态变量，定义时必须初始化,很特殊的一个函数，永远占用内存空间。个人感觉是这四个函数里最有用的一个，说不大细，建议多看看资料。extern int a; 外部声明, 通常该变量在其他文件中定义, 在这里声明表示引用该变量static 修饰函数为静态函数,本文件中可以使用extern 外部声明, 改函数在其他地方有被定义过不过貌似这几个东东没多大实用性。如果想深入了解建议看看吉林大学康辉老师讲的C，他的教程我记得说的很详细。如果是参加比赛的准备的话，感觉这个出题的可能性不大，最近在准备3月份的全国比赛。这个连看也没看……如果是初学者，直接pass掉就行了，真正写程序的时候除了static，其他的本人一次也没用过

使用静态变量public static int state = 0;

如果你学习过其他的语言的话就可以理解为何你所学习的那门语言里的意译是一样的含义

C/C++经典面试题 　　面试题 1：变量的声明和定义有什么区别 　　为变量分配地址和存储空间的称为定义，不分配地址的称为声明。一个变量可以在多个地方声明， 　　但是只在一个地方定义。加入 extern修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分 　　定义。 　　说明：很多时候一个变量，只是声明不分配内存空间，直到具体使用时才初始化，分配内存空间， 　　如外部变量。 　　面试题 2：写出 bool 、int、 float、指针变量与“零值”比较的 if 语句 　　bool型数据： 　　if( flag ) 　　{ 　　A; 　　} 　　else 　　{ 　　B; 　　} 　　int型数据： 　　if( 0 != flag ) 　　{ 　　A; 　　} 　　else 　　{ 　　B; 　　} 　　指针型数： 　　if( NULL == flag ) 　　{ 　　A; 　　} 　　else 　　{ 　　B; 　　} 　　float型数据： 　　if ( ( flag >= NORM ) && ( flag <= NORM ) ) 　　{ 　　A; 　　2 　　} 　　注意：应特别注意在 int、指针型变量和“零值”比较的时候，把“零值”放在左边，这样当把“==” 　　误写成“=”时，编译器可以报错，否则这种逻辑错误不容易发现，并且可能导致很严重的后果。 　　面试题 3：sizeof 和strlen的区别 　　sizeof和 strlen 有以下区别： 　　uf071 sizeof是一个操作符，strlen是库函数。 　　uf071 sizeof的参数可以是数据的类型，也可以是变量，而 strlen只能以结尾为‘‘的字符串作参数。 　　uf071 编译器在编译时就计算出了 sizeof 的结果。而 strlen 函数必须在运行时才能计算出来。并且 sizeof 　　计算的是数据类型占内存的大小，而 strlen计算的是字符串实际的长度。 　　uf071 数组做sizeof的参数不退化，传递给strlen就退化为指针了。 　　注意：有些是操作符看起来像是函数，而有些函数名看起来又像操作符，这类容易混淆的名称一定 　　要加以区分，否则遇到数组名这类特殊数据类型作参数时就很容易出错。最容易混淆为函数的操作符就 　　是 sizeof。 　　面试题 4：C 语言的关键字 static 和 C++ 的关键字 static 有什么区别 　　在C 中static 用来修饰局部静态变量和外部静态变量、函数。而 C++中除了上述功能外，还用来定 　　义类的成员变量和函数。即静态成员和静态成员函数。 　　注意：编程时 static的记忆性，和全局性的特点可以让在不同时期调用的函数进行通信，传递信息， 　　而 C++的静态成员则可以在多个对象实例间进行通信，传递信息。 　　面试题 5：C中的 malloc 和C++中的 new有什么区别 　　malloc和 new有以下不同： 　　(1)new、 是操作符，可以重载，只能在 C++中使用。 　　(2)malloc、free是函数，可以覆盖，C、C++中都可以使用。 　　(3)new 可以调用对象的构造函数，对应的 调用相应的析构函数。 　　(4)malloc仅仅分配内存，free 仅仅回收内存，并不执行构造和析构函数 　　(5)new、 返回的是某种数据类型指针，malloc、free 返回的是void指针。 　　注意：malloc申请的内存空间要用 free释放，而 new申请的内存空间要用 释放，不要混用。 　　因为两者实现的机理不同。 　　面试题 6：写一个“标准”宏 MIN 　　#define min(a,b)((a)<=(b)?(a):(b)) 　　注意：在调用时一定要注意这个宏定义的副作用，如下调用： 　　((++*p)<=(x)?(++*p):(x)。 　　p指针就自加了两次，违背了 MIN的本意。 　　面试题 7：一个指针可以是 volatile 吗 　　可以，因为指针和普通变量一样，有时也有变化程序的不可控性。常见例：子中断服务子程序修改 　　一个指向一个 buffer的指针时，必须用 volatile来修饰这个指针。 　　说明：指针是一种普通的变量，从访问上没有什么不同于其他变量的特性。其保存的数值是个整型 　　数据，和整型变量不同的是，这个整型数据指向的是一段内存地址。 　 　面试题 8：a 和&a 有什么区别 　　请写出以下代码的打印结果，主要目的是考察 a和&a的区别。 　　#include 　　void main( void ) 　　{ 　　int a[5]={1,2,3,4,5}; 　　int *ptr=(int *)(&a+1); 　　printf(“%d,%d”,*(a+1),*(ptr-1)); 　　return; 　　} 　　输出结果：2，5。 　　注意：数组名 a可以作数组的首地址，而&a是数组的指针。思考，将原式的 int *ptr=(int *)(&a+1); 　　改为 int *ptr=(int *)(a+1);时输出结果将是什么呢? 　　面试题 9：简述 C、C++程序编译的.内存分配情况 　　C、C++中内存分配方式可以分为三种： 　　(1)从静态存储区域分配： 　　内存在程序编译时就已经分配好，这块内存在程序的整个运行期间都存在。速度快、不容易出错， 　　因为有系统会善后。例如全局变量，static变量等。 　　(2)在栈上分配： 　　在执行函数时，函数内局部变量的存储单元都在栈上创建，函数执行结束时这些存储单元自动被释 　　放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 　　(3)从堆上分配： 　　即动态内存分配。程序在运行的时候用 malloc 或 new 申请任意大小的内存，程序员自己负责在何 　　时用free 或 释放内存。动态内存的生存期由程序员决定，使用非常灵活。如果在堆上分配了空间， 　　就有责任回收它，否则运行的程序会出现内存泄漏，另外频繁地分配和释放不同大小的堆空间将会产生 　　堆内碎块。 　　一个C、C++程序编译时内存分为 5大存储区：堆区、栈区、全局区、文字常量区、程序代码区。 　　4 　　面试题 10：简述 strcpy、sprintf 与 memcpy的区别 　　三者主要有以下不同之处： 　　(1)操作对象不同，strcpy的两个操作对象均为字符串，sprintf的操作源对象可以是多种数据类型， 　　目的操作对象是字符串， memcpy 的两个对象就是两个任意可操作的内存地址，并不限于何种数据类型。 　　(2)执行效率不同，memcpy最高，strcpy次之，sprintf的效率最低。 　　(3)实现功能不同，strcpy主要实现字符串变量间的拷贝，sprintf 主要实现其他数据类型格式到字 　　符串的转化，memcpy主要是内存块间的拷贝。 　　说明：strcpy、sprintf 与memcpy都可以实现拷贝的功能，但是针对的对象不同，根据实际需求，来 　　选择合适的函数实现拷贝功能。 ;

局部内部类不能有访问说明符，因为它不是外围类的一部分；但是他可以访问当前代码块内的常量，以及此外围类的所有成员。匿名内部类：不定义类的名字，在使用的地方直接定义对象。匿名内部类的特点：唯一一种没有构造器的类；匿名内部类在编译时，编译器会自动起名xxx$1.class;匿名内部类不能存在任何静态的变量、方法等；匿名内部类是局部内部类的特例；大部分匿名内部类用于接口返回；

　　7.1 库函数的正确调用 　　1.C语言提供了丰富的库函数，包括常用数学函数、对字符和字符串处理函数、输入输出处理函数等。在调用库函数时要注意以下几点： 　　(1)调用C语言标准库函数时必须在源程序中用include命令，include命令的格式是： 　　#include″头文件名″ 　　include命令必须以#号开头，系统提供的头文件名都以.h作为后缀，头文件名用一对双引号″″或一对尖括号〈〉括起来。 　　(2)标准库函数的调用形式： 　　函数名(参数表) 　　2.在C语言中库函数的调用可以以两种形式出现：出现在表达式中；作为独立的语句完成某种操作。 　　7.2 函数的定义方法 　　1.C语言函数的一般形式为： 　　函数返回值的类型名 函数名(类型名 形参1，类型名 形参2，…) 　　{ 　　说明部分 　　语句部分 　　} 　　定义的第一行是函数的首部，{}中的是函数体。 　　2.在老的C语言版本中，函数的首部用以下形式： 　　函数返回值的类型名 函数名(形参1，形参2…) 　　形参类型说明； 　　新的ANSI标准C兼容这种形式的函数首部说明。 　　3.函数名和形参名是由用户命名的标识符。在同一程序中，函数名必须。形式参数名只要在同一函数中即可，可以与函数中的变量同名。 　　4.C语言规定不能在一个函数内部再定义函数。 　　5.若在函数的首部省略了函数返回值的类型名，把函数的首部写成： 　　函数名(类型名 形参1，类型名 形参2，…) 　　则C默认函数返回值的类型为int类型。 　　6.当没有形参时，函数名后面的一对圆括号不能省略。 　　7.3 函数的类型和返回值 　　1.函数的类型由函数定义中的函数返回值的类型名确定，函数的类型可以是任何简单类型，如整型、字符型、指针型、双精度型等，它指出了函数返回值的具体类型。当函数返回的是整型值时，可以省略函数类型名。当函数只完成特定的操作而没有或不需要返回值时，可用类型名void(空类型)。 　　2.函数返回值就是return语句中表达式的值。当程序执行到return语句时，程序的流程就返回到调用该函数的地方(通常称为退出调用函数)，并带回函数值。 　　7.4 形式参数与实际参数，参数值的传递 　　1.在函数定义中，出现的参数名称为形参(形式参数)，在调用函数时，使用的参数值称为实参(实际参数)。 　　2.调用函数和被调用函数之间的参数值的传递是″按值″进行的，即数据只能从实参单向传递给形参。也就是说，当简单变量作为实参时，用户不能在函数中改变对应实参的值。 　　7.5 函数的正确调用(嵌套调用，递归调用) 　　1.调用函数时，函数名必须与被调用的函数名字完全一样。实参的个数与类型和形参的个数与类型一致。 　　2.C语言规定：函数必须先定义，后调用，也就是被调用函数必须在调用之前加以说明，或被调用函数整个放在调用函数之前。但对返回值类型为int或char类型的函数可以放在调用函数的后面。 　　3.C语言中函数定义都是互相平行、独立的，C语言不允许嵌套定义函数，但允许嵌套调用函数，也就是说，在调用一个函数的过程中，又调用另一个函数。 　　4.在C程序中，调用一个函数的过程中又出现直接或间接地调用该函数本身，称为函数的递归调用。 　　5.递归调用函数是C语言的特点之一，有时递归调用会使求解的问题变得更简单明了。 　　7.6 局部变量和全局变量 　　1.局部变量 　　在一函数内部所定义的变量称为局部变量，局部变量只在本函数范围内有效。 　　注意： 　　①不同函数可以使用相同的局部变量名，它们将代表不同的对象，互不干扰； 　　②一个函数的形参也为局部变量； 　　③在函数内部，复合语句也可定义变量，这些变量也为局部变量，只在此复合语句中有效。 　　2.全局变量 　　在C语言中，程序的编译单位是源程序文件，一个源程序文件中包含一个或多个函数。在函数之外所定义的变量称为外部变量，也称为全局变量。全局变量可以被包含它的源程序文件中的其他函数所共用，作用域为从定义变量的位置开始到源程序文件结束，全局变量可以增加函数之间数据的联系。 　　注意：当在同一个源程序文件中，全局变量与局部变量同名时，在局部变量的作用范围内，全局变量不起作用，局部变量起作用。 　　7.7 变量的存储类别、作用域及生存期 　　1.变量的存储类别 　　在C语言中，有两类存储类别：自动类别及静态类别。 　　有4个与两种存储类别有关的说明符：auto(自动)、register(寄存器)、static(静态)和extern(外部)，这些说明符一般与类型说明一起出现，一般放在类型名的左边，例如： 　　auto long I，j; 　　也可写成： 　　long auto I，j; 　　(1)自动变量：自动变量是C程序中使用最多的一种变量，这种变量的建立和撤消都是在系统中自动进行的。 　　格式：［auto］数据类型 变量名［=初始化表达式］，…； 　　上面的说明格式中，方括号中是可省略的部分，auto为自动类别标识符，若省略auto,系统缺省的存储类别也为自动类别。 　　注意：函数的形参也为自动类别，在定义时不必加存储类别标识符。 　　(2)寄存器变量：寄存器变量与自动变量的性质相同，其区别只在于存储的位置不同，寄存器变量存储在CPU的寄存器中，而自动变量存储在内存中的动态存储区，寄存器变量的存取速度要快些。 　　格式：register数据类型，变量名［=初始化表达式］，…； 　　上面的说明格式中，register为寄存器变量的存储类别标识符。 　　说明： 　　①CPU中寄存器的数目是有限的，因此只能把少数的变量说明为寄存器变量； 　　②寄存器变量是存放在寄存器中的，而不是存放于内存中，所以，寄存器变量无地址； 　　③寄存器变量的说明应尽量放在靠近要使用的地方，用完后尽快释放，这样可提高使用效率。 　　(3)静态变量：静态类别变量的存储空间在程序的整个运行期间是固定的。 　　格式：static数据类型 变量名［=初始化表达式］，…； 　　在上面的说明格式中，static为静态变量的存储类别标识符。 　　静态变量的初始化在编译时进行，定义时可用常量或表达式进行显式初始化。对于没有初始化的静态变量，自动初始化为0(整型)或0.0(实型)。 　　注意：静态变量具有可继承性，这与自动变量有所不同。 　　(4)外部变量：使用extern可使外部变量使用范围扩充到需要使用它的函数。外部变量可作显式的初始化，若不作初始化，系统将自动地初始化为0或0.0。 　　格式：［extern］数据类型，变量名［=初始化表达式］，…； 　　上面的说明格式中，extern使外部变量的作用范围扩大到其他源程序文件中。 　　注意：局部变量既可以说明为自动类别，也可以说明为静态类别；全局变量只能说明为静态类别。 　　2.变量的作用域及生存期 　　在C语言中，变量必须先说明后使用，在程序中一个已定义的变量的使用范围就是此变量的作用域。经过赋值的变量在程序运行期间能保持其值的时间范围为该变量的生存期。 　　(1)局部变量的使用域及生存期 　　①自动变量的使用域及生存期 　　自动变量的存储单元被分配在内存的动态存储区，每当进函数体(或复合语句)时，系统自动为自动变量分配存储单元，退出时自动释放这些存储单元。自动变量的作用域为从定义的位置起，到函数体(或复合语句)结束为止。 　　自动变量在进入到定义它们的函数体(或复合语句)时生成，在退出所在的函数体(或复合语句)时消失，这就是自动变量的生存期。 　　使用自动变量的优点是使各函数之间造成信息分隔，不同函数中使用同名变量时不会相互影响。 　　②寄存器变量的使用域及生存期 　　寄存器变量的使用域及生存期与自动变量相同。 　　③静态存储类别的局部变量 　　在函数体(或复合语句)内部，用static说明的变量静态存储类别的局部变量，这种变量的作用域与自动(或寄存器)变量的作用域相同，但是生存期有所不同。 　　在整个程序运行期间，静态局部变量在内存的静态存储区中占据着永久的存储单元，甚至在退出函数后下次再进入函数时，静态局部变量仍使用原来的存储单元。由于不释放存储单元，所以这些存储单元中的值将会被保留下来。静态局部变量的生存期将一直延长到程序运行结束。 　　静态局部变量适合于在函数调用之间必须保留局部变量值的独立变量。

比如变量是strstr="this is a string"要想在判断str中是否含有"this"这个字符串，下面的语句是可行的[[ $str =~ "this" ]] && echo "$str contains this" [[ $str =~ "that" ]] || echo "$str does NOT contain this"其实这里就是用到了"[[" 判断命令和 "=~"正则式匹配符号

如果实在不清楚，可以不声明，即使用默认的variant类型；如果确实想声明一下，那么可以dim SH as object,B as String(或者integer等，看你需要什么数据）；如果还不死心，一定要搞清楚SH到底是什么类型，那么可以dim SH As Worksheet ,就是工作表类型，因为你赋值的Sheets("设置")是一个Worksheet，由于是对象，所以也可以用通用的object。 上面方法都可用，有什么区别呢，如果定义Worksheet（即真正的类型），这样写代码时会有代码提示，初学者推荐。 另外的声明没有问题。另外注意对象变量赋值用set

1、linux系统中read命令用于从标准输入中读取数据，进而给变量赋值。 2、直接使用read，不加变量名称，变量赋值给REPLY。 3、通过-p参数加入提示。 4、通过-t参数限制输入变量值的时间。 5、通过-s 选项隐藏输入的变量值，比如在屏幕输入密码。 6、通过-n参数实现限定输入变量的长度。 7、使用-r参数限制为原始字符串 8、从文件中读取变量值

使用indexOf,例如:varCts = "bblText";if(Cts.indexOf("Text") > 0 ){alert("Cts中包含Text字符串");}帕斯卡原理：杠杆的平衡条件： FL=FLF?LL或写成：F

上面是删除空工作表的代码，SH是变量，这里就相当于工作表， For Each sh In ThisWorkbook.Worksheets是遍历该工作簿的每个工作表的意思。

set 将对象引用赋给变量或属性sh 变量名，这里经set后它变成了一个对象createobject 创建对象wscript.shell 所创建的对象的名称run 这个sh对象的方法

你想知道啥，这个是安装oracle的时候设置的一些环境变量啊。oracle的一些变量信息啊

题主你好,其实答案都写在了你的提问中了.关键就在于: "子shell". 啥叫"子shell"啊, "子shell"是fork自父shell的, 也就是说父shell中的变量子shell都可以用, 但子shell中的变量父shell不可用.把上面的话理解一下, 然后再去套你提问中的代码, 看看是不是逻辑就通了.希望可以帮到题主, 欢迎追问.

第一步：配置.bash_profile 1）打开终端，输入（打开并编辑.bash_profile文件）： 2）如若提示command not found：open，输入（暂时可以使用命令，关闭后又得重新输入）： 2）如若提示文件不存在，输入（创建.bash_profile文件）： 3）继续执行输入 （打开并编辑.bash_profile文件）： 4）找到sdk位置，在.bash_profile文件中添加以下内容： 5、保存.bash_profile文件，输入（让编辑内容立即生效）： 第二步、配置 .zshrc 文件 1）输入（打开并编辑.zshrc文件）： 2）如若提示command not found：open，输入（暂时可以使用命令，关闭后又得重新输入）： 2）如若提示文件不存在，输入（创建.zshrc文件）： 3）继续执行输入 （打开并编辑.zshrc文件）： 4）在zshrc文件中添加以下内容： 5、保存.zshrc，输入（让编辑内容立即生效）： 第三步：验证 输入adb version 大功告成！

如果要查看当前所有环境变量的设置，可以用env命令，例子如下：-bash-3.00# envHZ=100LC_MONETARY=en_US.ISO8859-1SHELL=/usr/bin/bashTERM=ansiLC_NUMERIC=en_US.ISO8859-1MAIL=/var/mail/pcPATH=/usr/sbin:/usr/bin:.LC_MESSAGES=CLC_COLLATE=en_US.ISO8859-1PWD=/export/home/pcTZ=PRCSHLVL=1HOME=/export/home/pcLOGNAME=pcLC_CTYPE=en_US.ISO8859-1LC_TIME=en_US.ISO8859-1_=/usr/bin/env如果只想看指定的变量设置，如路径PATH的设置，可以用 "echo $PATH"或 “ env | grep PATH"或” env | grep -i path"来查询。前面的适合知道全名的，后面2种适合只知道部分字段或者部分关键字母（甚至不确定字符大小写）的。-bash-3.00# echo $PATH/usr/sbin:/usr/bin:.-bash-3.00# env | grep PATHPATH=/usr/sbin:/usr/bin:.

set为shell内置命令，其后的所有变量，都会被当作位置参数来处理，按顺序为 $1, $2, ... $n。$* 就是用来取得所有这些位置参数的。man set看看帮助。set [-o option] [arg ...]Any arguments remaining after the options are processed are treated as values for the positional parameters and are assigned, in order, to $1, $2, ... $n.option是可选的。

有几种可能 1、当前是在csh 或者ksh模式下 可以通过命令行输入 which bash 比如返回/usr/bin/bash，然后在命令行输入他 2、环境变量设置的PATH不对，可以env看看。