static的作用

static像在VB，C，C++，Java中我们可以看到static最为关键字和函数出现，在其他的高级计算机语言如FORTRAN、ALGOL、COBOL、BASIC、LISP、SNOBOL、PL/1、Pascal、PROLOG、Ada等语

言中也是有出现的，只是有着不同的作用，对于其具体作用，读者有需要的时候是可以具体查阅的鉴

于时间问题今天我就不一一罗列了。

目录

简介

分类

static 函数内部函数和外部函数

当一个源程序由多个源文件组成时，C语言根据函数能否被其它源文件中的函数调用，将函数分为内部函数和外部函数。

内部函数

（又称静态函数）

如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数称为内部函数。

定义一个内部函数，只需在函数类型前再加一个“static”关键字即可，如下所示：

static 函数类型函数名(函数参数表)

{……}

关键字“static”，译成中文就是“静态的”，所以内部函数又称静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件。

使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名，因为同名也没有关系。

外部函数

外部函数的定义：在定义函数时，如果没有加关键字“static”，或冠以关键字“extern”，表示此函数是外部函数：

[extern] 函数类型函数名(函数参数表)

{……}

调用外部函数时，需要对其进行说明：

[extern] 函数类型函数名(参数类型表)[，函数名2(参数类型表2)……]；

[案例]外部函数应用。

（1）文件mainf.c

main()

{ extern void input(…),process(…),output(…);

input(…); process(…); output(…);

}

（2）文件subf1.c

……

extern void input(……) /*定义外部函数*/

{……}

（3）文件subf2.c

……

extern void process(……) /*定义外部函数*/

{……}

（4）文件subf3.c

……

extern void output(……) /*定义外部函数*/

{……}

C++的static有两种用法：面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。

面向过程设计中的static

1、静态全局变量

在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子，如下：

//Example 1

#include

void fn();

static int n; //定义静态全局变量

void main()

{ n=20;

cout<

fn();

}

void fn()

{ n++;

cout<

}

静态全局变量有以下特点：

该变量在全局数据区分配内存；

未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）；

静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的；

静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。对于一个完整的程序，在内存中的分布情况如下图：

代码区 //low address

全局数据区

堆区

栈区 //high address

一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不

会因为函数的退出而释放空间。细心的读者可能会发现，Example 1中的代码中将

static int n; //定义静态全局变量

改为

int n; //定义全局变量

程序照样正常运行。

的确，定义全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处：

静态全局变量不能被其它文件所用；

其它文件中可以定义相同名字的变量，不会发生冲突；

您可以将上述示例代码改为如下：

//Example 2//File1

#include

void fn();

static int n; //定义静态全局变量

void main()

{ n=20;

cout<

fn();

}

//File2

#include

extern int n;

void fn()

{ n++;

cout<

}

编译并运行Example 2，您就会发现上述代码可以分别通过编译，但运行时出现错误。试着将

static int n; //定义静态全局变量

改为

int n; //定义全局变量

再次编译运行程序，细心体会全局变量和静态全局变量的区别。

注意：全局变量和全局静态变量的区别

1）全局变量是不显式用static修饰的全局变量，但全局变量默认是静态的，作用域是整个工程，在一个文件内定义的全局变量，在另一个文件中，通过extern 全局变量名的声明，就可以使用全局变量。

2）全局静态变量是显式用static修饰的全局变量，作用域是所在的文件，其他的文件即使用extern声明也不能使用。

2、静态局部变量

在局部变量前，加上关键字static，该变量就被定义成为一个静态局部变量。

我们先举一个静态局部变量的例子，如下：

//Example 3

#include

void fn();

void main()

{ fn();

fn();

fn();

}

void fn()

{ static int n=10;

cout<

n++;

}

通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。

但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。

静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。

静态局部变量有以下特点：

该变量在全局数据区分配内存；

静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；

静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0；

它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；

3、静态函数

在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。

静态函数的例子：

//Example 4

#include

static void fn();//声明静态函数

void main()

{

fn();

}

void fn()//定义静态函数

{ int n=10;

cout<

}

定义静态函数的好处：

静态函数不能被其它文件所用；

其它文件中可以定义相同名字的函数，不会发生冲突；

面向对象的static关键字

（类中的static关键字）

1、静态数据成员

在类内数据成员的声明前加上关键字static，该数据成员就是类内的

静态数据成员。先举一个静态数据成员的例子。

//Example 5

#include

class Myclass

{

public:

Myclass(int a,int b,int c);

void GetSum();

private:

int a,b,c;

static int Sum;//声明静态数据成员

};

int Myclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)

{ this->a=a;

this->b=b;

this->c=c;

Sum+=a+b+c;}

void Myclass::GetSum()

{ cout<<"Sum="<

}

void main()

{ Myclass M(1,2,3);

M.GetSum();

Myclass N(4,5,6);

N.GetSum();

M.GetSum();}

可以看出，静态数据成员有以下特点：

对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；

静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员；

静态数据成员和普通数据成员一样遵从public,protected,private访问规则；

因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；

静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：

<数据类型><类名>::<静态数据成员名>=<值>

类的静态数据成员有两种访问形式：

<类对象名>.<静态数据成员名> 或 <类类型名>::<静态数据成员名>

如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员；

静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；

同全局变量相比，使用静态数据成员有两个优势：

静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；

可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；

2、静态成员函数

与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this 是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。

//Example 6

#include

class Myclass

{public:

Myclass(int a,int b,int c);

static void GetSum();/声明静态成员函数

private:

int a,b,c;

static int Sum;//声明静态数据成员

};

int Myclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)

{ this->a=a;

this->b=b;

this->c=c;

Sum+=a+b+c; //非静态成员函数可以访问静态数据成员

}

void Myclass::GetSum() //静态成员函数的实现

{// cout<

cout<<"Sum="<

}

void main()

{ Myclass M(1,2,3);

M.GetSum();

Myclass N(4,5,6);

N.GetSum();

Myclass::GetSum();

}

关于静态成员函数，可以总结为以下几点：

出现在类体外的函数定义不能指定关键字static；

静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；

非静态成员函数可以任意地访问静态成员函数和静态数据成员；

静态成员函数不能访问非静态成员函数和非静态数据成员；

由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；

调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：<类名>::<静态成员函数名>（<参数表>）

调用类的静态成员函数。

作用

static静态变量声明符。在声明它的程序块，子程序块或函数内部有效，值保持，在整个程序期间分配存储器空间，编译器默认值0。

是C++中很常用的修饰符，它被用来控制变量的存储方式和可见性。

为什么要引入static

函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，大家知道，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。

什么时候用static

需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。

static的内部机制

静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。

这样，它的空间分配有三个可能的地方，一是作为类的外部接口的头文件，那里有类声明；二是类定义的内部实现，那里有类的成员函数定义；三是应用程序的main（）函数前的全局数据声明和定义处。

静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的“尺寸和规格”，并不进行实际的内存分配，所以在类声明中写成定义是错误的。它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。

static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态

数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。

static的优势

可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。

应用格式

引用静态数据成员时，采用如下格式：

<类名>::<静态成员名>

如果静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式来引用静态数据成员。

注意事项

(1)类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致了它仅能访问类的静态数据和静态成员函数。

(2)不能将静态成员函数定义为虚函数。

(3)由于静态成员声明于类中，操作于其外，所以对其取地址操作，就多少有些特殊，变量地址是指向其数据类型的指针，函数地址类型是一个“nonmember函数指针”。

(4)由于静态成员函数没有this指针，所以就差不多等同于nonmember 函数，结果就产生了一个意想不到的好处：成为一个callback函数，使得我们得以将C++和C-based X Window系统结合，同时也成功的应用于线程函数身上。

(5)static并没有增加程序的时空开销，相反她还缩短了子类对父类静态成员的访问时间，节省了子类的内存空间。

(6)静态数据成员在<定义或说明>时前面加关键字static。

(7)静态数据成员是静态存储的，所以必须对它进行初始化。

(8)静态成员初始化与一般数据成员初始化不同:

初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆；

初始化时不加该成员的访问权限控制符private，public等；

初始化时使用作用域运算符来标明它所属类；

所以我们得出静态数据成员初始化的格式：

<数据类型><类名>::<静态数据成员名>=<值>

(9)为了防止父类的影响，可以在子类定义一个与父类相同的静态变量，以屏蔽父类的影响。这里有一点需要注意：我们说静态成员为父类和子类共享，但我们有重复定义了静态成员，这会不会引起错误呢？不会，我们的编译器采用了一种绝妙的手法：name-mangling 用以生成唯一的标志。在各通信公司的笔试面试中经常出现的考题就是static的作用及功能。

编辑本段vb中的static语句

语句

在过程级别中使用，用于声明变量并分配存储空间。在整个代码运行期间都能保留使用 Static 语句声明的变量的值。

static语句声明的变量，与dim语句声明的变量的主要区别是：前者只能在sub或function过程中使用，在退出sub或function过程后变量的值保留；后者使用在sub或function过程中时，退出sub或function过程后变量的值不保留。

语法

Static varname[([subscripts])] [As [New] type] [,

varname[([subscripts])] [As [New] type]] . . .

Static 语句的语法包含下面部分：

部分描述

varname 必需的。变量的名称；遵循标准变量命名约定。

subscripts 可选的。数组变量的维数；最多可以定义 60 维的多维数组。subscripts 参数使用下面的语法：

[lower To] upper [,[lower To] upper] . . .

如果不显式指定 lower，则数组的下界由 Option Base 语句控制。如果没有 Option Base 语句则下界为 0。

New 可选的。用它可以隐式地创建对象的关键字。如果使用 New 声明对象变量，则在第一次引用该变量时将新建该对象的实例，因此不必使用Set 语句来对该对象引用赋值。New 关键字不能用来声明任何内部数据类型的变量，也不能用来声明从属对象的实例。

type 可选的。变量的数据类型；可以是 Byte、Boolean、Integer、Long、Currency、Single、Double、Decimal（目前尚不支持）、Date、String（对变长的字符串）、String * length（对定长的字符串）、Object、Variant、用户定义类型或对象类型。所声明的每个变量都要有一个单独的 As type 子句。

说明

模块的代码开始运行后，使用 Static 语句声明的变量会一直保持其值，直至该模块复位或重新启动。可以在非静态的过程中使用 Static 语句显式声明只在该过程内可见，但具有与包含该过程定义的模块相同生命期的变量。

可以在过程中使用 Static 语句来声明在过程调用之间仍能保持其值

的变量的数据类型。例如，下面的语句声明了一个定长的整型数组：Static EmployeeNumber(200) As Integer

下面的语句为 worksheet 的新实例声明了一个变量：

Static X As New Worksheet

如果在定义对象变量时没有使用 New 关键字，则在使用该变量之前，

必须使用 Set 语句将一个已有的对象赋给这个引用对象的变量。在被赋值

之前，所声明的这个对象变量有一个特定值 Nothing，这个值表示该变量没有指向任何对象的实例。若在声明中使用了 New 关键字，则在第一次引用

对象时将新建一个该对象的实例。

如果不指定数据类型或对象类型，且在模块中没有使用 Deftype 语句，则按缺省情况，定义该变量为 Variant 类型。

注意

Static 语句与 Static 关键字很相似，但是针对不同的效果来使用的。如果使用 Static 关键字（如 Static Sub CountSales ()）来声明一个过程，则该过程中的所有局部变量的存储空间都只分配一次，且这些变量的值在整个程序运行期间都存在。对非静态过程而言，该过程每次被调用时都要为其变量分配存储空间，当该过程结束时都要释放其变量的存储空间。Static 语句则用来在非静态的过程中声明特定的变量，以使其在程序运行

期间能保持其值。

在初始化变量时，数值变量被初始化为 0，变长的字符串被初始化为一个零长度的字符串 ("")，而定长的字符串则用 0 填充。Variant 变量被初始化为 Empty。用户自定义类型的变量的每个元素作为各自独立的变量进行初始化。

注意如果在过程中使用 Static 语句，应和其它的声明语句（如 Dim）一样将其放在过程的开始。

编辑本段JAVA中的static

作用

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。

声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共同拥有一个static变量。声明为static的方法有以下几条限制：

·

它们仅能调用其他的static 方法。

·

它们只能访问static数据。

·

它们不能以任何方式引用this 或super（关键字super 与继承有关）。举例

如果你需要通过计算来初始化你的static变量，你可以声明一个

static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：// Demonstrate static variables，methods，and blocks.

class UseStatic {

static int a = 3;

static int b;

static void meth(int x) {

System.out.println("x = " + x);

System.out.println("a = " + a);

System.out.println("b = " + b);

}

static {

System.out.println("Static block initialized.");

b = a * 4;

}

public static void main(String args[]) {

meth(42);

}

}

一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。

注意：在一个static 方法中引用任何实例变量都是非法的。

下面是该程序的输出：

Static block initialized.

x = 42

a = 3

b = 12

编辑本段C#中的static

使用static修饰符声明属于类型本身而不是属于特定对象的静态成员。static修饰符可用于类、字段、方法、属性、运算符、事件和构造函数，但不能用于索引器、析构函数或类以外的类型。例如，下面的类声明为static，并且只包含static方法。

例如：

static class CompanyEmployee

{

public static string GetCompanyName(string name) { ... }

public static string GetCompanyAddress(string address) { ... } }

java static 的使用方法

类方法 方法被声明为static后，则称为类方法。类方法相对于实例方法，前者区别于后者的地方：前者为属于该类的所有实例对象共享，无须实例化对象，仅通过类名即可访问(当然，是否能够直接访问，还取决于所声明的访问权限)。 因为被static化后产生上述特殊性，所以static变量都会在类被加载时初始化，而类方法也同时随类加载而进驻内存。先来段代码热热身吧～ 上段代码，输出结果为: null A Class 由结果可知，即字符串prvateStr的值为空。嘿，可别认为值应该是下面那样啊。那样 的话，进行下去就太具挑战性了。 A Class A Class 请记住一点，类变量初始化的顺序与其在类中的赋值顺序一致。

重写(覆盖) 或许大家对于面向对象编程语言最初的印象就是其语言单元是以父类、子类的关系存在着，而构建这一关系的就是继承机制了。子类可以继承父类一切非private的变量与方法，并且可以添加自己的变量与方法。在构建一个系统时，这机制让我们强烈地感觉到编程是一 门优雅的艺术。 来段小小的代码简单地展示下： 结果如下： Jack I am a thinking animal, and a Programmer

如上，子类Programmer中并没定义字符串characteristic，但我们却在其方法printProfession()中调用了;同样，我们正常使用了父类定义的printName()方法。而这就 是继承的简单实现。 继承不仅仅带来以上特性。它还赋予子类重写(覆盖)父类方法的能力(因为旨在讲类方法的重写，所以这儿就不讲重载以及变量在继承机制中的问题了)。方法的重写(覆盖)：继承父类的子类，可以通过拟具有相同方法名与参数组的方法来重写父类中对应的方法，从而让子类更个性化。又因为重写(覆盖)的出现，多态也随之产生。多态：通过父类变量可以引用其子类对象，从而调用子类中那些继承自自己并被重写(覆盖)的方法。

C++中static的作用

C++的static有两种用法：面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。 一、面向过程设计中的static 1、静态全局变量 在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子，如下： //Example 1 #include void fn(); static int n; //定义静态全局变量 void main() { n=20; cout<

C语言特殊符号意义

C语言中像%D &%f符号的作用说一下 最佳答案 C语言中的符号 运算符的种类C语言的运算符可分为以下几类： 1.算术运算符 用于各类数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余(或称模运算，%)、自增(++)、自减(–)共七种。 2.关系运算符 用于比较运算。包括大于(>)、小于(<)、等于(==)、大于等于(>=)、小于等于(<=)和不等于(!=)六种。 3.逻辑运算符 用于逻辑运算。包括与(&&)、或(||)、非(!)三种。 4.位操作运算符 参与运算的量，按二进制位进行运算。包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)六种。 5.赋值运算符 用于赋值运算，分为简单赋值(=)、复合算术赋值(+=,-=,*=,/=,%=)和复合位运算赋值(&=,|=,^=,>>=,<<=)三类共十一种。 6.条件运算符 这是一个三目运算符，用于条件求值(?:)。 7.逗号运算符 用于把若干表达式组合成一个表达式(，)。 8.指针运算符 用于取内容(*)和取地址(&)二种运算。 9.求字节数运算符 用于计算数据类型所占的字节数(sizeof)。 10.特殊运算符 有括号()，下标[]，成员(→，.)等几种。 1.C的数据类型 基本类型，构造类型，指针类型，空类型 2.基本类型的分类及特点 类型说明符字节数值范围 字符型char 1 C字符集 基本整型int 2 -32768～32767 短整型short int 2 -32768～32767 长整型 long int 4 -214783648～214783647 无符号型 unsigned 2 0～65535

Java--static关键字的

static关键字 如果使用一个类则会在实例化对象时分别开辟栈内存及堆内存，在堆内存中要保存对象中的属性，每个对象都有自己的属性，如果你现在有些属性希望被共享，则就必行将其声明为static属性，而且一个属性声明为static属性，可以直接使用类名称进行调用，如果一个类中的方法想由类调用，则可以声明为static方法。 一．使用static声明属性 如果程序中使用static声明属性，则属性成为全局属性（有些也称为静态属性），那么声明为全局属性到底有什么用吶？观察以下代码： class Person{ // 定义Person类 String name ; // 定义name属性，暂时不封装 int age ; // 定义age属性，暂时不封装 String country = "A城" ; // 定义城市属性，有默认值 public Person(String name,int age){ https://www.sodocs.net/doc/5d10994210.html, = name ; this.age = age; } public void info(){ // 得到信息 System.out.println("姓名：" + https://www.sodocs.net/doc/5d10994210.html, + "，年龄：" + this.age + "，城市：" + country) ; } }; public class StaticDemo01{ public static void main(String args[]){ Person p1 = new Person("张三",30) ; // 实例化对象 Person p2 = new Person("李四",31) ; // 实例化对象 Person p3 = new Person("王五",32) ; // 实例化对象 https://www.sodocs.net/doc/5d10994210.html,() ; https://www.sodocs.net/doc/5d10994210.html,() ; https://www.sodocs.net/doc/5d10994210.html,() ; } }; 运行结果： 姓名：张三，年龄：30，城市：A城 姓名：李四，年龄：31，城市：A城 姓名：王五，年龄：32，城市：A城 以上代码，为了观察方便没有使用private关键字进行封装。以上的程序是一个简单的程序，但是代码中有些不妥之处。 实际上，如果现在假设此城市不叫A城，而改为了B城，而且此类产生了200个对象，那么就意味着要把这些对象的城市属性全部修改一边。这样显然是不行的。最好的方法是修改一次就可以，此时可以把城市属性使用static关键字进行声明，将其变为公共属性。 使用static声明属性： class Person{ // 定义Person类

static变量三个作用

static的作用 在C语言中，static的字面意思很容易把我们导入歧途，其实它的作用有三条。 （1）先来介绍它的第一条也是最重要的一条：隐藏。 当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话，我举例来说明。我们要同时编译两个源文件，一个是a.c，另一个是main.c。 下面是a.c的内容 char a = 'A'; // global variable void msg() { printf("Hello\n"); } 下面是main.c的内容 int main(void) { extern char a; // extern variable must be declared before use printf("%c ", a); (void)msg(); return 0; } 程序的运行结果是： A Hello 你可能会问：为什么在a.c中定义的全局变量a和函数msg能在main.c中使用？前面说过，所有未加static前缀的全局变量和函数都具有全局可见性，其它的源文件也能访问。此例中，a

是全局变量，msg是函数，并且都没有加static前缀，因此对于另外的源文件main.c是可见的。 如果加了static，就会对其它源文件隐藏。例如在a和msg的定义前加上static，main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。Static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏，而对于变量，static还有下面两个作用。 （2）static的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。虽然这种用法不常见，但我还是举一个例子。 #include int fun(void){ static int count = 10; // 事实上此赋值语句从来没有执行过 return count--; } int count = 1; int main(void) { printf("global\t\tlocal static\n"); for(; count <= 10; ++count) printf("%d\t\t%d\n", count, fun()); return 0; }

c语言关键字的用法详解

1. Static用法 1.1 static声明的变量在C语言中有两方面的特征： 1)、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 1.2 特点 A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度； B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度； C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题； D.如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数) E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static 的局部变量的地址作为返回值，若为auto类型，则返回为错指针。 函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。 扩展分析:术语static有着不寻常的历史.起初，在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后，static在C中有了第二种含义：用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字，所以仍使用static关键字来表示这第二种含义。最后，C++重用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。 1.3 关键字static的作用是什么？ 这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：

java基础知识点总结

Created by AIwen on 2017/5/14. java是面向对象的程序设计语言；类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，它们将会引用到类的对象。类用于描述客观世界里某一类对象的共同特征，而对象则是类的具体存在，java程序使用类的构造器来创建该类的对象。 java也支持面向对象的三大特征：封装、继承、和多态。java提供了private、protected、和public三个访问控制修饰符来实现良好的封装，提供了extends关键字让子类继承父类，子类继承父类就可以继承到父类的成员变量和和方法，如果访问控制允许，子类实例可以直接调用父类里定义的方法。继承是实现类复用的重要手段。使用继承关系来实现复用时，子类对象可以直接赋给父类变量，这个变量具有多态性。 面向对象的程序设计过程中有两个重要的概念：类（Class)和对象（object，也被称为实例，instance）。类可以包含三种最常见的成员：构造器、成员变量、和方法。 构造器用于构造该类的实例，java语言通过new关键字类调用构造器，从而返回该类的实例。构造器是一个类创建对象的根本途径，如果一个类没有构造器，这个类通常无法创建实例。因此java语言提供了一个功能：如果程序员没有为一个类编写构造器，则系统会为该类提供一个默认的构造器，这个构造器总是没有参数的。一旦程序员为一个类提供了构造器，系统将不再为该类提供构造器。 构造器用于对类实例进行初始化操作，构造器支持重载，如果多个重载的构造器里包含了相同的初始化代码，则可以把这些初始化代码放置在普通初始化块里完成，初始化块总在构造器执行之前被调用。静态初始化块代码用于初始化类，在类初始化阶段被执行。如果继承树里某一个类需要被初始化时，系统将会同时初始化该类的所有父类。 构造器修饰符：可以是public、protected、private其中之一，或者省略构造器名：构造器名必须和类名相同。 注意：构造器既不能定义返回值类型，也不能使用void声明构造器没有返回值。如果为构造器定义了返回值类型，或使用void声明构造器没有返回值，编译时不会出错，但java会把这个所谓的构造器当成方法来处理——它就不再是构造器。 实际上类的构造器是有返回值的，当使用new关键字来调用构造器时，构造器返回该类的实例，可以把这个类的实例当成构造器的返回值。因此构造器的返回值类型总是当前类，无须定义返回值类型。不要在构造器里显式的使用return来返回当前类的对象，因为构造器的返回值是隐式的。 java类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。 成员变量： 成员变量的修饰符：public、protected、private、static、final前三个只能出现一个再和后面的修饰符组合起来修饰成员变量，也可省略。 成员变量：由一个或者多个有意义的单词连缀而成，第一个单词首字母小写，后面每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。 类型：可以是java语言允许的任何数据类型，包括基本类型和引用类型。 成员方法： 方法修饰符：public、protected、private、static、final、abstract，前三个只能出现一个，static和final最多只能出现其中的一个，和abstract组合起来使用。也可省略。 返回值类型：可以是java语言的允许的任何数据类型，包括基本类型和引用类型。 方法名：和成员变量的方法命名规则相同，通常建议方法名以英文动词开头。 方法体里多条可执行语句之间有严格的执行顺序，排在方法体前面的语句总先执行，排在方法体后面的语句总是后执行。 static是一个特殊的关键字，它可用于修饰方法、成员变量等成员。static修饰的成员表明它属于这个类本身，而

java中如何使用Static的变量和方法

如何使用Static的变量和方法 有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。 声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制： 1.它们仅能调用其他的static 方法。 2.它们只能访问static数据。 它们不能以任何方式引用this 或super（关键字super 与继承有关）。 如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块： // Demonstrate static variables，methods，and blocks. class UseStatic { static int a = 3; static int b; static void meth(int x) { System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b); } static { System.out.println("Static block initialized."); b = a * 4; } public static void main(String args[]) { meth(42); } } 一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。 注意：在一个static 方法中引用任何实例变量都是非法的。 下面是该程序的输出： Static block initialized. x = 42 a = 3 b = 12

C语言中auto,register,static,const,volatile的区别

C语言中auto，register，static，const，volatile的区别 (1)auto 这个关键字用于声明变量的生存期为自动，即将不在任何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义的变量视为局部变量。这个关键字不怎么多写，因为所有的变量默认就是auto的。 (2)register 这个关键字命令编译器尽可能的将变量存在CPU内部寄存器中而不是通过内存寻址访问以提高效率。 (3)static 常见的两种用途: 1>统计函数被调用的次数; 2>减少局部数组建立和赋值的开销.变量的建立和赋值是需要一定的处理器开销的，特别是数组等含有较多元素的存储类型。在一些含有较多的变量并且被经常调用的函数中，可以将一些数组声明为static类型，以减少建立或者初始化这些变量的开销. 详细说明: 1>、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与栈变量和堆变量的区别。 2>、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 3>当static用来修饰全局变量时，它就改变了全局变量的作用域，使其不能被别的程序extern，限制在了当前文件里，但是没有改变其存放位置，还是在全局静态储存区。 使用注意: 1>若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度； 2>若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度； 3>设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题(只要输入数据相同就应产生相同的输出)。 (4)const 被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。它可以修饰函数的参数、返回值，甚至函数的定义体。 作用: 1>修饰输入参数 a.对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。 b.对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。 2>用const修饰函数的返回值 a.如果给以“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const修饰的同类型指针。 如对于：const char * GetString(void); 如下语句将出现编译错误： char *str = GetString();//cannot convert from 'const char *' to 'char *'； 正确的用法是：

static变量和static函数的各自的特点

static变量和static函数的各自的特点 static变量大致分为三种用法 一、用于局部变量中,成为静态局部变量. 静态局部变量有两个用法,记忆功能和全局生存期. 二、用于全局变量,主要作用是限制此全局变量被其他的文件调用. 三、用于类中的成员.表示这个成员是属于这个类但是不属于类中任意特定对象 static 声明的变量. 在C语言中有两方面的特征： 1、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 2、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 Tips: A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度； B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度； C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题； D.如果我们需要一个可重入的函数，那么，我们一定

要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数) E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。 函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。 扩展分析:术语static有着不寻常的历史.起初，在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后，static在C中有了第二种含义：用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字，所以仍使用static关键字来表示这第二种含义。最后，C++重用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。

Java 中的 static 使用之静态方法

Java 中的static 使用之静态方法 与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。静态方法的使用如： 需要注意： 1、静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如： 如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。如： 、在普通成员方法中，则可以直接访问同类的非静态变量和静态变量，如下所示：

3、静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。如： ava 中的static 使用之静态初始化块 Java 中可以通过初始化块进行数据赋值。如： 在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。 需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。 我们来看一段代码：

运行结果： 通过输出结果，我们可以看到，程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。 封装 1、概念： 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 2、好处 a:只能通过规定的方法访问数据 b:隐藏类的实例细节，方便修改和实现。 什么是Java 中的内部类 问：什么是内部类呢？ 答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。 问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！ 答：内部类的主要作用如下：

Java中super的几种用法并与this的区别

4．super和this的异同： 1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句） 2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句） 3)super:它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名super.成员函数据名（实参） 4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名） 5）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。 6）super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。 7）super()和this()均需放在构造方法内第一行。 8）尽管可以用this调用一个构造器，但却不能调用两个。 9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。 10）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static 变量,static方法，static语句块。 11）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。1.静态方法 通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法声明为static的方法有以下几条限制： 1）它们仅能调用其他的static 方法。 2）它们只能访问static数据。 3）它们不能以任何方式引用this 或super。 class Simple { static void Go() { System.out.println("Welcome"); } } public class Cal { public static void main(String[] args) { Simple.go(); } } 调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。 2. 静态变量 声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例

static的作用

static像在VB，C，C++，Java中我们可以看到static最为关键字和函数出现，在其他的高级计算机语言如FORTRAN、ALGOL、COBOL、BASIC、LISP、SNOBOL、PL/1、Pascal、PROLOG、Ada等语 言中也是有出现的，只是有着不同的作用，对于其具体作用，读者有需要的时候是可以具体查阅的鉴 于时间问题今天我就不一一罗列了。 目录 简介 分类 static 函数内部函数和外部函数 当一个源程序由多个源文件组成时，C语言根据函数能否被其它源文件中的函数调用，将函数分为内部函数和外部函数。 内部函数 （又称静态函数） 如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数称为内部函数。 定义一个内部函数，只需在函数类型前再加一个“static”关键字即可，如下所示： static 函数类型函数名(函数参数表) {……} 关键字“static”，译成中文就是“静态的”，所以内部函数又称静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件。

使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名，因为同名也没有关系。 外部函数 外部函数的定义：在定义函数时，如果没有加关键字“static”，或冠以关键字“extern”，表示此函数是外部函数： [extern] 函数类型函数名(函数参数表) {……} 调用外部函数时，需要对其进行说明： [extern] 函数类型函数名(参数类型表)[，函数名2(参数类型表2)……]； [案例]外部函数应用。 （1）文件mainf.c main() { extern void input(…),process(…),output(…); input(…); process(…); output(…); } （2）文件subf1.c …… extern void input(……) /*定义外部函数*/ {……} （3）文件subf2.c …… extern void process(……) /*定义外部函数*/ {……} （4）文件subf3.c …… extern void output(……) /*定义外部函数*/ {……} C++的static有两种用法：面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。 面向过程设计中的static 1、静态全局变量 在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子，如下： //Example 1 #include void fn(); static int n; //定义静态全局变量

static和this的理解和用法总结

static和this的理解和用法小结 关键字static和this是初学者比较头疼的知识点，自己也一直比较模糊．现在整理一下，既可以加深自己的印象也可以便于以后查询． 其实在think in java里关于为什么要使用static写的比较详细，不明白的多读几遍会有很大的收获．一般在两钟情形下需要使用static关键字：一种情形是只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创建对象。另一种情形是我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能调用的方法。一旦将什么东西设为static，数据或方法就不会同那个类的任何对象实例联系到一起.所以尽管从未创建那个类的一个对象，仍能调用一个static方法，或访问一些static数据。而在这之前，对于非static数据和方法，我们必须创建一个对象，并用那个对象访问数据或方法。这是由于非static数据和方法必须知道它们操作的具体对象.有这样的一个类，其中定义一个静态数据： class Test { Static int i = 47; } Test st1 = new StaticTest();Test st2 = new StaticTest();即使们new了两个Test对象,但它们仍然只占据Test.i的一个存储空间。这两个对象都共享同样的i。对方法来说，static一项重要的用途就是帮助我们在不必创建对象的前提下调用那个方法. 静态变量）一个静态对象属于一个类，但它不属于实例对象，也不是实例对象状态的一部分．每一个静态变量只存在一份．静态变量通常称为类变量（class variable)．在实际中，经常需要这样的一个变量，它被一个类的所有实例对象所共享，如果它同时又是公有的，那么它就可以被这个类的任意访问者所使用．静态变量存在于类的作用域之内．通常声明为private.java中许多时候会用到public static final 这样的变量。静态变量可以被位于同一个作用域内的任意方或静态方法访问，访问时使用变量名称即可。如果在类作用域以外访问类，则要使用一个含有类名的表达式访问静态变量，例如： Integer.MAX_VALUE, 其中MAX_VALUE是在类库中声明过的。 静态方法）静态方法或类方法属于一个而不是属于某个实例对象实现的一部分。可以直接通过类来调用这种方法，而并不是只能由某个特定的实例对象调用。静态的方法不能用abstract声明，而且无论是否明确地指定实际上都是final型的。静态方法的声明格式： modifiers static typeName methodName (parameterList){ statementSequence } modifiers(可以从public,protect,private中选择一个），后面可以加上 final,nativc,synchronized中的一个或几个的组合。 static main是静态方法的一个特殊用法，用static main 方法来建立程序的初始状态，创建一组初始对象，并进行合理的方法调用，使得程序能够继续执行下去，static main方法使用String数组型参数包含了用户在运行时给出的任意命令行参数。

C语言关键字static

C语言关键字-static 用法1：在一个函数体内使用static定义一个变量，保证该变量只进行一次初始化 例：#include "stdio.h" int test(void) { static int i=0; //对应 int i=0 结果为i=1 i=1 i=1 i=1 i=1 i++; return i; } int main( ) { for(int j=0;j<5;j++) printf("test=%d\n",test()); return 0; } 输出结果：i=1 i=2 i=3 i=4 i=5 用法2：在模块内，函数体外声明的static变量，只能 被模块内函数调用，而模块是无效的（其中模块即：一个.c文件和一个.h文件的结合，其中在STM32单片机

C设计中经常使用）。同样的一个在模块内被声明为static的函数也只能在模块内被其它函数调用，而模块外是无权调用的。一句话总结就是保护一些不能被其它文件访问的全局变量和函数；防止了不同人定义的文件变量名和函数名的重复引起的错误 例：//file1.cpp int VarA=0; static int VarB=0; extern void FunB(void) //其中函数前面加extern表示定义为外部函数，其实可以省略，因为C语言默认省略为外部可 //调用 { ; } static int FunA (void) //加了static为静态函数，只能在本模块使用 { int i=0; i++; return i; } //file2.cpp

extern int VarA; //可以 extern int VarB;//错误，为静态变量 extern int FunB;//可以 extern int FunA;//错误，为静态函数 总结：众所周知局部变量在存储方式上可以分为auto (默认的，可省略) static register这3种其中auto 是分配在栈上，占用动态存储空间，在函数调用结束后自动释放；static 分配在静态存储空间，两者的作用域相同，但是生存周期不同，static在所处模块初期初始化一次，其后不再进行初始化，同时如果没有初始化则默认是0或者空字符，但是auto的无初始化的值是随机的数；其中针对C++系统不管是否有static修饰都会调用默认构造函数进行初始化。

JAVA学习总结

1、Print、Println、Printf的区别 Print: 将信息显示在命令窗口中，输出光标定位在最后一个字符之后； Println：将信息显示在命令窗口中，输出光标换行定位在下一行开头； Printf: 将信息进行格式化显示在命令窗口中，输出光标定位在最后一个字符之后,其来自C语言，产生格式化输出的函数（来自stdio.h中）； 2、异常 如果有多个catch 语句，那么捕获父类异常的catch 语句必须放在后面，否则它会捕获它的所有子类异常，而使得子类异常catch 语句永远不会执行。 一般情况下 finally 语句块一般放在最后一个catch 语句块后，不管程序是否抛出异常，它都会执行。 throw与throws的区别 区别一：throw 是语句抛出一个异常；throws 是方法抛出一个异常； throw语法：throw <异常对象> 在方法声明中，添加throws子句表示该方法将抛出异常。 throws语法： [<修饰符>]<返回值类型><方法名>（[<参数列表>]）[throws<异常类>] 其中：异常类可以声明多个，用逗号分割。 区别二：throws可以单独使用，但throw不能； 区别三：throw要么和try-catch-finally语句配套使用，要么与throws配套使用。 但throws可以单独使用，然后再由处理异常的方法捕获。 可检测异常和非检测异常 Java的可检测异常和非检测异常泾渭分明。 可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理 或声明规则。 非检测异常不遵循处理或声明规则。在产生此类异常时，不一定非要采取任何适当 操作，编译器不会检查是否已解决了这样一个异常。有两个主要类定义非检测异常：RuntimeException和Error。 对于未检查异常，在方法抛出时可以不用throws 来声明，而检查异常则必须在throws声明后才能进行throw 抛出异常。 为什么Error子类属于非检测异常？这是因为无法预知它们的产生时间。若Java应用程序内存不足，则随时可能出现OutOfMemoryError；起因一般不是应用 程序中的特殊调用，而是JVM自身的问题。另外，Error类一般表示应用程序无法 解决的严重问题，故将这些类视为非检测异常。 RuntimeException类也属于非检测异常，一个原因是普通JVM操作引发的运行时异常随时可能发生。与Error不同，此类异常一般由特定操作引发。但这些操 作在Java应用程序中会频繁出现。例如，若每次使用对象时，都必须编写异常处 理代码来检查null引用，则整个应用程序很快将变成一个庞大的try-catch块。 因此，运行时异常不受编译器检查与处理或声明规则的限制。 将RuntimeException类作为未检测异常还有一个原因：它们表示的问题不一定作为异常处理。可以在try-catch结构中处理NullPointerException，但若在 使用引用前测试空值，则更简单，更经济。同样，可以在除法运算时检查0值，而 不使用ArithmeticException。

static静态变量的理解

C语言中，static的字面意思很容易把我们导入歧途，其实它的作用有三条。（1）先来介绍它的第一条也是最重要的一条：隐藏。 当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话，我举例来说明。我们要同时编译两个源文件，一个是a.c，另一个是main.c。 下面是a.c的内容 char a = 'A'; // global variable void msg() { printf("Hello\n"); } 下面是main.c的内容 int main(void) { extern char a; // extern variable must be declared before use printf("%c ", a); (void)msg(); return 0; } 程序的运行结果是： A Hello 你可能会问：为什么在a.c中定义的全局变量a和函数msg能在main.c中使用？前面说过，所有未加static前缀的全局变量和函数都具有全局可见性，其它的源文件也能访问。此例中，a是全局变量，msg是函数，并且都没有加static 前缀，因此对于另外的源文件main.c是可见的。 如果加了static，就会对其它源文件隐藏。例如在a和msg的定义前加上static，main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。Static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏，而对于变量，static还有下面两个作用。（2）static的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。虽然这种用法不常见，但我还是举一个例子。 #include int fun(void){ static int count = 10; // 事实上此赋值语句从来没有执行过 return count--; } int count = 1; int main(void) { printf("global\t\tlocal static\n"); for(; count <= 10; ++count)