static关键字

static关键字
static关键字

static关键字

分类:C++2011-09-19 09:47 23人阅读评论(0) 收藏举报静态:不依附于任意对象

静态数据:(1)类中声明(2)类外定义

静态函数: (无this指针)只能访问静态成员(数据/函数) 类名::函数名(...)

静态对象:静态区

(1)全局静态对象:main前创建-构造,main后析构-删除

(2)局部静态对象: main退出时(创建相反顺序)析构-删除

类静态成员:所有对象共享

类静态数据成员:类中声明,类外定义.

全局静态函数只能在本文件调用,不会放入导出符号表

------------------------------------------------------------------------------------------------------------------------------------------------------

(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;

}

程序的运行结果是:

global local static

1 10

2 9

3 8

4 7

5 6

6 5

7 4

8 3

9 2

10 1

(3)static的第三个作用是默认初始化为0。其实全局变量也具备这一属性,因为全局变量也存储在静态数据区。在静态数据区,内存中所有的字节默认值都是0x00,某些时候这一

特点可以减少程序员的工作量。比如初始化一个稀疏矩阵,我们可以一个一个地把所有元素都置0,然后把不是0的几个元素赋值。如果定义成静态的,就省去了一开始置0的操作。再比如要把一个字符数组当字符串来用,但又觉得每次在字符数组末尾加’\0’太麻烦。如果把字符串定义成静态的,就省去了这个麻烦,因为那里本来就是’\0’。不妨做个小实验验证一下。

#include

int a;

int main(void)

{

int i;

static char str[10];

printf("integer: %d; string: (begin)%s(end)", a, str);

return 0;

}

程序的运行结果如下

integer: 0; string: (begin)(end)

最后对static的三条作用做一句话总结。首先static的最主要功能是隐藏,其次因为static 变量存放在静态存储区,所以它具备持久性和默认值0。

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.360docs.net/doc/ef9937049.html, = name ; this.age = age; } public void info(){ // 得到信息 System.out.println("姓名:" + https://www.360docs.net/doc/ef9937049.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.360docs.net/doc/ef9937049.html,() ; https://www.360docs.net/doc/ef9937049.html,() ; https://www.360docs.net/doc/ef9937049.html,() ; } }; 运行结果: 姓名:张三,年龄:30,城市:A城 姓名:李四,年龄:31,城市:A城 姓名:王五,年龄:32,城市:A城 以上代码,为了观察方便没有使用private关键字进行封装。以上的程序是一个简单的程序,但是代码中有些不妥之处。 实际上,如果现在假设此城市不叫A城,而改为了B城,而且此类产生了200个对象,那么就意味着要把这些对象的城市属性全部修改一边。这样显然是不行的。最好的方法是修改一次就可以,此时可以把城市属性使用static关键字进行声明,将其变为公共属性。 使用static声明属性: class Person{ // 定义Person类

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

c语言关键字的用法详解优选稿

c语言关键字的用法详 解 集团文件版本号:(M928-T898-M248-WU2669-I2896-DQ586-M1988)

1.Static用法 1.1static声明的变量在C语言中有两方面的特征: 1)、变量会被放在程序的全局存储区中,这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 2)、变量用static告知编译器,自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 1.2特点 A.若全局变量仅在单个C文件中访问,则可以将这个变量修改为静态全局变量,以降低模块间的耦合度; B.若全局变量仅由单个函数访问,则可以将这个变量改为该函数的静态局部变量,以降低模块间的耦合度; C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时,需要考虑重入问题; D.如果我们需要一个可重入的函数,那么,我们一定要避免函数中使用static变量(这样的函数被称为:带“内部存储器”功能的的函数) E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时,则必须是static的局部变量的地址作为返回值,若为auto类型,则返回为错指针。 函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式,而是指对函数的作用域仅局限于本文件(所以又称内部函

数)。使用内部函数的好处是:不同的人编写不同的函数时,不用担心自己定义的函数,是否会与其它文件中的函数同名。 扩展分析:术语static有着不寻常的历史.起初,在C中引入关键字st atic是为了表示退出一个块后仍然存在的局部变量。随后,static在C 中有了第二种含义:用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字,所以仍使用static关键字来表示这第二种含义。最后,C++重用了这个关键字,并赋予它与前面不同的第三种含义:表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java 中此关键字的含义相同)。 1.3关键字static的作用是什么? 1.4 这个简单的问题很少有人能回答完全。在C语言中,关键字static有三个明显的作用: 1.4.1在函数体,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 int testStatic() { int x=1; x++; return x; }

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有三个明显的作用:

super关键字用法

使用super来引用父类的成分,用this来引用当前对象一、super关键字 在JAVA类中使用super来引用父类的成分,用this来引用当前对象,如果一个类从另 外一个类继承,我们new这个子类的实例对象的时候,这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢?使用super来引用,this指的是当前对象的引用,super是当前对象里面的父对象的引用。 1.1.super关键字测试 1package cn.galc.test; 2 3/** 4 * 父类 5 * @author gacl 6 * 7*/ 8class FatherClass { 9public int value; 10public void f() { 11 value=100; 12 System.out.println("父类的value属性值="+value); 13 } 14 } 15 16/** 17 * 子类ChildClass从父类FatherClass继承 18 * @author gacl 19 * 20*/ 21class ChildClass extends FatherClass { 22/**

23 * 子类除了继承父类所具有的valu属性外,自己又另外声明了一个value属性, 24 * 也就是说,此时的子类拥有两个value属性。 25*/ 26public int value; 27/** 28 * 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现,即重写了f()方法的方法体。 29*/ 30public void f() { 31super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法 32 value=200;//这个value是子类自己定义的那个valu,不是从父类继承下来的那个value 33 System.out.println("子类的value属性值="+value); 34 System.out.println(value);//打印出来的是子类自定义的那个value的值,这个值是200 35/** 36 * 打印出来的是父类里面的value值,由于子类在重写从父类继承下来的f()方法时, 37 * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法, 38 * 即相当于是这个父类对象自己调用f()方法去改变自己的value 属性的值,由0变了100。 39 * 所以这里打印出来的value值是100。 40*/ 41 System.out.println(super.value); 42 } 43 } 44 45/** 46 * 测试类 47 * @author gacl 48 * 49*/ 50public class TestInherit { 51public static void main(String[] args) { 52 ChildClass cc = new ChildClass();

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 *'; 正确的用法是:

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++static关键字

C/C++中的static关键字 C/C++中的static有两种用法: 面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数,不涉及类的问题。 A. 面向过程程序设计中的stati c关键字 1) 静态全局变量 在全局变量前,加上关键字static,该变量就被定义成为一个静态全局变量。静态全局变量定义和使用类似:#include using namespace std; void fn(); static int n; //定义静态全局变量 void main() { n=20; cout< using namespace std; void fn(); void main()

{ fn(); fn(); fn(); } void fn() { static n=10; // 定义了静态局部变量,仅初始化一次! cout << n < using namespace std; static void fn(); //声明静态函数 void main() { fn(); } void fn() //定义静态函数 { int n=10;

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语言中static的用法

c语言中static的用法 c语言中static的用法的用法如下:static在c里面可以用来修饰变量,也可以用来修饰函数。 先看用来修饰变量的时候。 变量在c里面可分为存在全局数据区、栈和堆里。 其实我们平时所说的堆栈是栈而不是堆,不要弄混。 复制代码代码如下:int a ;int main(){int b ;int c* = (int *)malloc(sizeof(int));}a是全局变量,b是栈变量,c是堆变量。 static对全局变量的修饰,可以认为是限制了只能是本文件引用此变量。 有的程序是由好多.c文件构成。 彼此可以互相引用变量,但加入static修饰之后,只能被本文件中函数引用此变量。 static对栈变量的修饰,可以认为栈变量的生命周期延长到程序执行结束时。 一般来说,栈变量的生命周期由OS管理,在退栈的过程中,栈变量的生命也就结束了。 但加入static修饰之后,变量已经不再存储在栈中,而是和全局变量一起存储。 同时,离开定义它的函数后不能使用,但如再次调用定义它的函数时,它又可继续使用,而且保存了前次被调用后留下的值。

static对函数的修饰与对全局变量的修饰相似,只能被本文件中的函数调用,而不能被同一程序其它文件中的函数调用。 文件a.c复制代码代码如下:static int i; //只在a文件中用int j; //在工程里用static void init() //只在a文件中用 (1)全局变量一般用外部存储方式存储,用保留字extern加以定义。 此时,变量的作用域是构成整个程序的所有程序文件,也就是定义的外部变量可供其它程序文件使用。 (2)如果希望全局变量仅限于本程序文件使用,而其它程序文件中不能引用,这时必须将其存储方式定义为静态存储方式,用保留字static 加以定义。 此时称为静态外部变量。 例如,在上例文件filel.c中,如果作这样的定义:static int a:则变量a的作用域被缩小至本程序文件filel.c,文件file2.c中不能引用。 值得注意的是对全局变量加static,定义为静态存储方式,并不意味着是静态存储;而不加static,是动态存储。 两种形式的全局变量(外部变量)都是静态存储方式,都是编译时分配存储空间,但作用域不同。 使用静态外部变量,有利于隔离错误,有利于模块化程序设计。 (3)全局变量的缺省存储方式是外部存储方式。 前面章节中的程序没有见到变量的存储类别定义,实际上采用变量的缺省存储方式。

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修饰都会调用默认构造函数进行初始化。

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数组型参数包含了用户在运行时给出的任意命令行参数。

java笔记(super关键字的使用)

super 关键字的使用 super 关键字出现在子类中,主要功能就是完成子类调用父类中的内容,也就是调用父类中的属性或方法。 super 调用父类中的构造方法: class Person { String name; int age; public Person(String name,int age) { https://www.360docs.net/doc/ef9937049.html,=name; this.age=age; } } class Student extends Person { String school; public Student() { super("张三",27); } } public class TestPersonStudentDemo { public static void main(String args[]) { Student s=new Student(); S.shchool=”北京”; System.out.println("我是:"+https://www.360docs.net/doc/ef9937049.html,+",今年:"+s.age+"岁,学校:"+s.school) ; } } 输出结果为:我是张三,今年27岁,学校:北京 本程序在子类的构造方法中明确地指明了调用的是父类中有两个参数的构造方法,所以程序在编译时不再去找父类中无参的构造方法。 用super 调用父类中的构造方法,只能放在子类的第一行。 通过super 调用父类的属性和方法: class Person 父类构造方法 子类构造方法 调用父类构造方法

{ String name; int age; public Person() { } public String talk() { return "我是:"+https://www.360docs.net/doc/ef9937049.html,+",今年:"+this.age+"岁"; } } class Student extends Person { String school; public Student(String name,int age,String school) { //在这里用super 调用父类中的属性 https://www.360docs.net/doc/ef9937049.html,=name; super.age=age; //调用父类中的talk()方法 System.out.print(super.talk()); //调用本类中属性 this.school=school; } } public class TestPersonStudentDemo3 { public static void main(String args[]) { Student s=new Student("张三",27,"北京"); System.out.println(",学校:"+s.school); } } 输出结果为: 我是:张三,今年:27岁,学校:北京 限制子类的访问 有些时候,父类并不希望子类可以访问自己的类中全部的属性或方法,所以需要将一些属性父类构造方法 子类构造方法 父类一般方法

关于static的用法

关于static的用法: 在《Java编程思想》P86页有这样一段话: “static方法就是没有this的方法。在static方法内部不能调用非静态方法,反过来是可以的。而且可以在没有创建任何对象的前提下,仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。” 这段话虽然只是说明了static方法的特殊之处,但是可以看出static关键字的基本作用,简而言之,一句话来描述就是: 方便在没有创建对象的情况下来进行调用(方法/变量)。 很显然,被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问。 static可以用来修饰类的成员方法、类的成员变量,另外可以编写static代码块来优化程序性能。 1)static方法 static方法一般称作静态方法,由于静态方法不依赖于任何对象就可以进行访问,因此对于静态方法来说,是没有this的,因为它不依附于任何对象,既然都没有对象,就谈不上this了。并且由于这个特性,在静态方法中不能访问类的非静态成员变量和非静态成员方法,因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。 但是要注意的是,虽然在静态方法中不能访问非静态成员方法和非静态成员变量,但是在非静态成员方法中是可以访问静态成员方法/变量的。举个简单的例子:

在上面的代码中,由于print2方法是独立于对象存在的,可以直接用过类名调用。假如说可以在静态方法中访问非静态方法/变量的话,那么如果在main方法中有下面一条语句: MyObject.print2(); 此时对象都没有,str2根本就不存在,所以就会产生矛盾了。同样对于方法也是一样,由于你无法预知在print1方法中是否访问了非静态成员变量,所以也禁止在静态成员方法中访问非静态成员方法。 而对于非静态成员方法,它访问静态成员方法/变量显然是毫无限制的。 因此,如果说想在不创建对象的情况下调用某个方法,就可以将这个方法设置为static。我们最常见的static方法就是main方法,至于为什么main方法必须是static的,现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象,因此只有通过类名来访问。 另外记住,即使没有显示地声明为static,类的构造器实际上也是静态方法。 2)static变量

C语言中全局变量,局部变量,静态全局变量,静态局部变量的区别

C语言中全局变量、局部变量、静态全局变量、静态局部变量的区别 1.C++变量根据定义的位置的不同的生命周期,具有不同的作用域,作用域可分为6种: 全局作用域,局部作用域,语句作用域,类作用域,命名空间作用域和文件作用域。 从作用域看: 1>全局变量具有全局作用域。全局变量只需在一个源文件中定义,就可以作用于所有的源文件。当然,其他不包含全局变量定义的源文件需要用extern 关键字再次声明这个全局变量。 2>静态局部变量具有局部作用域,它只被初始化一次,自从第一次被初始化直到程序运行结束都一直存在,它和全局变量的区别在于全局变量对所有的函数都是可见的,而静态局部变量只对定义自己的函数体始终可见。 3>局部变量也只有局部作用域,它是自动对象(auto),它在程序运行期间不是一直存在,而是只在函数执行期间存在,函数的一次调用执行结束后,变量被撤销,其所占用的内存也被收回。 4>静态全局变量也具有全局作用域,它与全局变量的区别在于如果程序包含多个文件的话,它作用于定义它的文件里,不能作用到其它文件里,即被static 关键字修饰过的变量具有文件作用域。这样即使两个不同的源文件都定义了相同名字的静态全局变量,它们也是不同的变量。 2.从分配内存空间看: 1>全局变量,静态局部变量,静态全局变量都在静态存储区分配空间,而局部变量在栈里分配空间 2>全局变量本身就是静态存储方式,静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序,当一个源程序由多个源文件组成时,非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域,即只在定义该变量的源文件内有效,在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内,只能为该源文件内的函数公用,因此可以避免在其它源文件中引起错误。 1)静态变量会被放在程序的静态数据存储区(全局可见)中,这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。2)变量用static告知编译器,自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。

Static关键字的用法

Static关键字 一、不建立对象即想使用的两种实际情况。 程序员可能希望在没有创建对象的时候就能够为某个特定的成员分配存储空间或者可以调用某个方法等等。在Java中能否实现这个需求呢? 笔者提到的这个问题是否是无中生有呢?其实不然。在实际应用程序开发中,就经常会遇到这种情况。如现在需要三个对象,分别用来计算圆的面积、圆球的体积、圆柱的体积。在这三个对象的方法中,都需要用到一个叫做圆周率的常量,而且这个圆周率是固定不变的。所以,在程序开发中,对于这些公用的成员变量最好能够统一管理。当调整成员变量的精度时,其运算结果的精度也会随之调整。从程序员的角度来看,这就是要求在没有创建对象之前就要给成员变量分配存储空间,以方便其他的类可以因用这个变量。而这个需求如果没有Statci关键字的话就无法实现。 第二种情况就是程序员可能希望某个方法不予包含它的类的任何对象关联在一起。这个读起来可能有点拗口。简单的说,就是即使没有使用new关键字创建对象的情况下,程序员仍然能够调用这个方法。也java认证更多详细资料就是说,在创建类的时候就需要为这个方法分配存储空间。就好像造汽车时,在做汽车设计图纸时就需要把发动机准备好。那么即使汽车还没造好,这个发动起也可以先拿来看看。此时也需要采用Static关键字来完成这个需求。 二、Static关键字的用途。 简单的说,Static关键字的用途就是在创建类的时候就给特定的成员或者方法分配存储空间。当程序员在成员变量或者方法前面加上Static 关键字时,就表示这些成员与方法不会与包含它的那个类的任何对象实例关联在一起。换一句话就是说,即使没有创建这个类的对象,程序员仍然可以调用这个类中的成员或者方法。因为他们实际上已经存在,系统已经为他们分配了存储空间。不过需要注意的是,Static关键字定义的成员与方法,毕竟与传统的对象创建方法有所差异。所以无论是在定义时还是在具体的引用过程中,都有所差异。程序开发人员必须了解这种差异,并在实际的工作中要引起重视。特别是如果有其他语言开发经验的程序员,不要将Java语言的这个特性与其他语言搞混,否则的话很容易出现错误。 三、利用Static关键字来定义成员变量。 如上面那个案例中,需要定义一个类,然后在这个类中需要用到一个叫做圆周率的成员。如果我们将这个成员命名为pi,则这个类可以按照下面的方法定义成员变量。 Class circle{ Static float pi=3.14 } 这个类的定义跟其他类最大的不同,就是在成员变量前面加了一个static关键字。此时就将这个成员变量设置为了staitc状态。其实在创建这个类的时候,系统就为其分配了一份存储空间。而不是在创建对象的时候再创建的。也就是说,现在就将这个成员变量跟包含它的类独立出来。在这种情况下,如果利用new关键字来创建对象,那么这个成员变量都是指向同一个。即程序员如果利用这个类创建三个对象时,其成员变量pi都指向同一个存储空间。为此不同对象内的成员变量pi的值都是相同的,因为其实际上都指的是同一东西。所以说,要统一多个对象中成员变量的值是非常简单的。只需要在定义类的时候,在这个成员变量的前面加上关键字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; //定义静态全局变量

相关文档
最新文档