cjavastatic

① static在C和java中的區別。

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中此關鍵字的含義相
同)。

關鍵字static的作用是什麼？
這個簡單的問題很少有人能回答完全。在C語言中，關鍵字static有三個明顯的作用：
1在函數體，一個被聲明為靜態的變數在這一函數被調用過程中維持其值不變。
2 在模塊內（但在函數體外），一個被聲明為靜態的變數可以被模塊內所用函數訪問，但不能被模塊外其它函數訪問。它是一個本地的全局變數。
3在模塊內，一個被聲明為靜態的函數只可被這一模塊內的其它函數調用。那就是，這個函數被限制在聲明它的模塊的本地范圍內使用。
大多數應試者能正確回答第一部分，一部分能正確回答第二部分，同是很少的人能懂得第三部分。這是一個應試者的嚴重的缺點，因為他顯然不懂得本地化數據和代碼范圍的好處和重要性

int testStatic()
{
int x=1;
x++;
return x;
}
main()
{
int i;
for(i=0;i<5;i++)
printf("%d\n",testStatic());
getch();
}

＝＝》2 2 2 2 2

int testStatic()
{
static int x=1;
x++;
return x;
}
main()
{
int i;
for(i=0;i<5;i++)
printf("%d\n",testStatic());
getch();
}

＝＝》2 3 4 5 6

轉載源地址為
http://blog.21ic.com/user1/2992/archives/2007/37456.html

② Java中的關鍵字static和final的作用

final

根據程序上下文環境，Java關鍵字final有「這是無法改變的」或者「終態的」含義，它可以修飾非抽象類、非抽象類成員方法和變數。你可能出於兩種理解而需要阻止改變：設計或效率。

final類不能被繼承，沒有子類，final類中的方法默認是final的。

final方法不能被子類的方法覆蓋，但可以被繼承。

final成員變數表示常量，只能被賦值一次，賦值後值不再改變。

final不能用於修飾構造方法。

注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。

1、final類

final類不能被繼承，因此final類的成員方法沒有機會被覆蓋

，默認都是final的。在設計類時候，如果這個類不需要有子類，類的實現細節不允許改變，並且確信這個類不會載被擴展，那麼就設計為final類。

2、final方法

如果一個類不允許其子類覆蓋某個方法，則可以把這個方法聲明為final方法。

使用final方法的原因有二：

第一、把方法鎖定，防止任何繼承類修改它的意義和實現。

第二、高效。編譯器在遇到調用final方法時候會轉入內嵌機制，大大提高執行效率。

例如：

publicclassTest1{
publicstaticvoidmain(String[]args){
//TODO自動生成方法存根
}
publicvoidf1(){
System.out.println("f1");
}
//無法被子類覆蓋的方法
publicfinalvoidf2(){
System.out.println("f2");
}
publicvoidf3(){
System.out.println("f3");
}
privatevoidf4(){
System.out.println("f4");
}
}
publicclassTest2extendsTest1{

publicvoidf1(){
System.out.println("Test1父類方法f1被覆蓋!");
}
publicstaticvoidmain(String[]args){
Test2t=newTest2();
t.f1();
t.f2();//調用從父類繼承過來的final方法
t.f3();//調用從父類繼承過來的方法
//t.f4();//調用失敗，無法從父類繼承獲得
}
}

3、final變數（常量）

用final修飾的成員變數表示常量，值一旦給定就無法改變！

final修飾的變數有三種：靜態變數、實例變數和局部變數，分別表示三種類型的常量。

從下面的例子中可以看出，一旦給final變數初值後，值就不能再改變了。

另外，final變數定義的時候，可以先聲明，而不給初值，這中變數也稱為final空白，無論什麼情況，編譯器都確保空白final在使用之前必須被初始化。但是，final空白在final關鍵字final的使用上提供了更大的靈活性，為此，一個類中的final數據成員就可以實現依對象而有所不同，卻有保持其恆定不變的特徵。

packageorg.leimin;
publicclassTest3{
privatefinalStringS="final實例變數S";
privatefinalintA=100;
publicfinalintB=90;
publicstaticfinalintC=80;
privatestaticfinalintD=70;
publicfinalintE;//final空白,必須在初始化對象的時候賦初值
publicTest3(intx){
E=x;
}
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
Test3t=newTest3(2);
//t.A=101;//出錯,final變數的值一旦給定就無法改變
//t.B=91;//出錯,final變數的值一旦給定就無法改變
//t.C=81;//出錯,final變數的值一旦給定就無法改變
//t.D=71;//出錯,final變數的值一旦給定就無法改變
System.out.println(t.A);
System.out.println(t.B);
System.out.println(t.C);//不推薦用對象方式訪問靜態欄位
System.out.println(t.D);//不推薦用對象方式訪問靜態欄位
System.out.println(Test3.C);
System.out.println(Test3.D);
//System.out.println(Test3.E);//出錯,因為E為final空白,依據不同對象值有所不同.
System.out.println(t.E);
Test3t1=newTest3(3);
System.out.println(t1.E);//final空白變數E依據對象的不同而不同
}
privatevoidtest(){
System.out.println(newTest3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
publicvoidtest2(){
finalinta;//final空白,在需要的時候才賦值
finalintb=4;//局部常量--final用於局部變數的情形
finalintc;//final空白,一直沒有給賦值.
a=3;
//a=4;出錯,已經給賦過值了.
//b=2;出錯,已經給賦過值了.
}
}

4、final參數
當函數參數為final類型時，你可以讀取使用該參數，但是無法改變該參數的值。

publicclassTest4{
publicstaticvoidmain(String[]args){
newTest4().f1(2);
}
publicvoidf1(finalinti){
//i++;//i是final類型的,值不允許改變的.
System.out.print(i);
}
}

二、static

static表示「全局」或者「靜態」的意思，用來修飾成員變數和成員方法，也可以形成靜態static代碼塊，但是Java語言中沒有全局變數的概念。

被static修飾的成員變數和成員方法獨立於該類的任何對象。也就是說，它不依賴類特定的實例，被類的所有實例共享。只要這個類被載入，Java虛擬機就能根據類名在運行時數據區的方法區內定找到他們。因此，static對象可以在它的任何對象創建之前訪問，無需引用任何對象。

用public修飾的static成員變數和成員方法本質是全局變數和全局方法，當聲明它類的對象市，不生成static變數的副本，而是類的所有實例共享同一個static變數。

static變數前可以有private修飾，表示這個變數可以在類的靜態代碼塊中，或者類的其他靜態成員方法中使用（當然也可以在非靜態成員方法中使用--廢話），但是不能在其他類中通過類名來直接引用，這一點很重要。實際上你需要搞明白，private是訪問許可權限定，static表示不要實例化就可以使用，這樣就容易理解多了。static前面加上其它訪問許可權關鍵字的效果也以此類推。

static修飾的成員變數和成員方法習慣上稱為靜態變數和靜態方法，可以直接通過類名來訪問，訪問語法為：

類名.靜態方法名(參數列表...)

類名.靜態變數名

用static修飾的代碼塊表示靜態代碼塊，當Java虛擬機（JVM）載入類時，就會執行該代碼塊（用處非常大，呵呵）。

1、static變數

按照是否靜態的對類成員變數進行分類可分兩種：一種是被static修飾的變數，叫靜態變數或類變數；另一種是沒有被static修飾的變數，叫實例變數。兩者的區別是：

對於靜態變數在內存中只有一個拷貝（節省內存），JVM只為靜態分配一次內存，在載入類的過程中完成靜態變數的內存分配，可用類名直接訪問（方便），當然也可以通過對象來訪問（但是這是不推薦的）。

對於實例變數，沒創建一個實例，就會為實例變數分配一次內存，實例變數可以在內存中有多個拷貝，互不影響（靈活）。

2、靜態方法

靜態方法可以直接通過類名調用，任何的實例也都可以調用，因此靜態方法中不能用this和super關鍵字，不能直接訪問所屬類的實例變數和實例方法(就是不帶static的成員變數和成員成員方法)，只能訪問所屬類的靜態成員變數和成員方法。因為實例成員與特定的對象關聯！這個需要去理解，想明白其中的道理，不是記憶！！！

因為static方法獨立於任何實例，因此static方法必須被實現，而不能是抽象的abstract。

3、static代碼塊

static代碼塊也叫靜態代碼塊，是在類中獨立於類成員的static語句塊，可以有多個，位置可以隨便放，它不在任何的方法體內，JVM載入類時會執行這些靜態的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現的先後順序依次執行它們，每個代碼塊只會被執行一次。例如：

publicclassTest5{
privatestaticinta;
privateintb;
static{
Test5.a=3;
System.out.println(a);
Test5t=newTest5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
publicstaticvoidmain(String[]args){
//TODO自動生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
publicvoidf(){
System.out.println("hhahhahah");
}
}

運行結果：
3
hhahhahah
1000
4
5

利用靜態代碼塊可以對一些static變數進行賦值，最後再看一眼這些例子，都一個static的main方法，這樣JVM在運行main方法的時候可以直接調用而不用創建實例。

4、static和final一塊用表示什麼

static final用來修飾成員變數和成員方法，可簡單理解為「全局常量」！

對於變數，表示一旦給值就不可修改，並且通過類名可以訪問。

對於方法，表示不可覆蓋，並且可以通過類名直接訪問。

特別要注意一個問題：

對於被static和final修飾過的實例常量，實例本身不能再改變了，但對於一些容器類型（比如，ArrayList、HashMap）的實例變數，不可以改變容器變數本身，但可以修改容器中存放的對象，這一點在編程中用到很多。

也許說了這么多，反倒把你搞暈了，還是看個例子吧：

publicclassTestStaticFinal{
="aaa";
=null;
privatefinalStringstrFinalVar=null;
=0;
=newInteger(8);
privatestaticfinalArrayList<String>alStaticFinalVar=newArrayList<String>();
privatevoidtest(){
System.out.println("-------------值處理前----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
//strStaticFinalVar="哈哈哈哈";//錯誤，final表示終態,不可以改變變數本身.
strStaticVar="哈哈哈哈";//正確，static表示類變數,值可以改變.
//strFinalVar="呵呵呵呵";//錯誤,final表示終態，在定義的時候就要初值（哪怕給個null），一旦給定後就不可再更改。
//intStaticFinalVar=2;//錯誤,final表示終態，在定義的時候就要初值（哪怕給個null），一旦給定後就不可再更改。
//integerStaticFinalVar=newInteger(8);//錯誤,final表示終態，在定義的時候就要初值（哪怕給個null），一旦給定後就不可再更改。
alStaticFinalVar.add("aaa");//正確，容器變數本身沒有變化，但存放內容發生了變化。這個規則是非常常用的，有很多用途。
alStaticFinalVar.add("bbb");//正確，容器變數本身沒有變化，但存放內容發生了變化。這個規則是非常常用的，有很多用途。
System.out.println("-------------值處理後----------
");
System.out.println("strStaticFinalVar="+strStaticFinalVar+"
");
System.out.println("strStaticVar="+strStaticVar+"
");
System.out.println("strFinalVar="+strFinalVar+"
");
System.out.println("intStaticFinalVar="+intStaticFinalVar+"
");
System.out.println("integerStaticFinalVar="+integerStaticFinalVar+"
");
System.out.println("alStaticFinalVar="+alStaticFinalVar+"
");
}
publicstaticvoidmain(Stringargs[]){
newTestStaticFinal().test();
}
}

看了上面這個例子，就清楚很多了，但必須明白：通過static final修飾的容器類型變數中所「裝」的對象是可改變的。這是和一般基本類型和類類型變數差別很大的地方。

③ java中static的用法

static可以修飾變數（屬性）、方法、代碼塊和內部類

1. static屬性：屬於這個類所有，即由該類創建的所有對象共享同一個static屬性。可以對象創建後通過對象名.屬性名和類名.屬性名兩種方式來訪問。也可以在沒有創建任何對象之前通過類名.屬性名的方式來訪問。

2. static方法：也可以通過對象名.方法名和類名.方法名兩種方式來訪問

3. static代碼塊：當類被第一次使用時（可能是調用static屬性和方法，或者創建其對象）執行靜態代碼塊，且只被執行一次，主要作用是實現static屬性的初始化。

4. static內部類：屬於整個外部類，而不是屬於外部類的每個對象。不能訪問外部類的非靜態成員（變數或者方法），.可以訪問外部類的靜態成員

④ java中static是什麼意思能不能通俗的講下，讓我這個菜鳥好理解一點

static英文是靜態的意思，所以它在java中也是這么用的，是一個修飾詞，在定義數據前面加上它是指這個數據是靜態不變的，在方法明加上它是指這個方法是靜態的。一般就是這些用處

⑤ 在java中什麼時候使用static ，static是不是等於全局變數

static是靜態變數，並不是常量，全局變數是相對於局部變數來說的,全局變數可以改變,在程序的任何地方都可以讀取和修改,而局部變數只能在語句塊內作用,超出作用范圍就失效了.

靜態變數(static)是相對自動變數(auto)等而言的,一旦聲明為靜態變數,在編譯時刻開始永遠存在,不受作用域范圍約束,但是如果是局部靜態變數,則此靜態變數只能在局部作用域內使用,超出范圍不能使用,但是它確實還佔用內存,還存在.自動變數就是一般的變數,在C語言中auto關鍵字可以省略.
int d;//全局變數
static int a;//靜態全局變數
void func()
{
int c;//局部變數
}
main()
{
static int d;//靜態局部變數
int b;//局部變數
}

⑥ c語言中static說明是什麼意思

在C語言中，static關鍵字的作用如下：

1、在修飾變數的時，static修飾的靜態局部變數只執行一次，而且延長了局部變數的生命周期，直到程序運行結束以後才釋放。

2、static修飾全局變數的時，這個全局變數只能在本文件中訪問，不能在其它文件中訪問，即便是extern外部聲明也不可以。

3、static修飾一個函數，則這個函數的只能在本文件中調用，不能被其他文件調用。Static修飾的局部變數存放在全局數據區的靜態變數區。

(6)cjavastatic擴展閱讀:

static關鍵字在C語言、C++、java中的作用有著相似之處，但也存在差異：

一、C++的static用法：

1、面向過程程序設計中的static和面向對象程序設計中的static。前者應用於普通變數和函數，不涉及類；後者主要說明static在類中的作用。

2、在類中，static可以用來修飾靜態數據成員和靜態成員方法

靜態數據成員

（1）靜態數據成員可以實現多個對象之間的數據共享，它是類的所有對象的共享成員，它在內存中只佔一份空間，如果改變它的值，則各對象中這個數據成員的值都被改變。

（2）靜態數據成員是在程序開始運行時被分配空間，到程序結束之後才釋放，只要類中指定了靜態數據成員，即使不定義對象，也會為靜態數據成員分配空間。

（3）靜態數據成員既可以通過對象名引用，也可以通過類名引用。

靜態成員函數

（1）靜態成員函數和靜態數據成員一樣，他們都屬於類的靜態成員，而不是對象成員。

（2）非靜態成員函數有this指針，而靜態成員函數沒有this指針。

（3）靜態成員函數主要用來方位靜態數據成員而不能訪問非靜態成員。

二、java的static用法：

1、聲明為static的變數稱為靜態變數或類變數。可以直接通過類名引用靜態變數，也可以通過實例名來引用靜態變數，但最好採用前者，因為後者容易混淆靜態變數和一般變數。

2、聲明為static的方法稱為靜態方法或類方法。靜態方法可以直接調用靜態方法，訪問靜態變數，但是不能直接訪問實例變數和實例方法。靜態方法中不能使用this關鍵字，因為靜態方法不屬於任何一個實例。

參考資料來源：網路-static（計算機高級語言）

⑦ JAVA 中的關鍵字static

static
C++的static有兩種用法：面向過程程序設計中的static和面向對象程序設計中的static。前者應用於普通變數和函數，不涉及類；後者主要說明static在類中的作用。
一、面向過程設計中的static
1、靜態全局變數
在全局變數前，加上關鍵字static，該變數就被定義成為一個靜態全局變數。我們先舉一個靜態全局變數的例子，如下：
//Example 1#include <iostream.h>void fn();static int n; //定義靜態全局變數void main(){ n=20; cout<<n<<endl; fn();}void fn(){ n++; cout<<n<<endl;}
靜態全局變數有以下特點：
該變數在全局數據區分配內存；
未經初始化的靜態全局變數會被程序自動初始化為0（自動變數的值是隨機的，除非它被顯式初始化）；
靜態全局變數在聲明它的整個文件都是可見的，而在文件之外是不可見的；
靜態變數都在全局數據區分配內存，包括後面將要提到的靜態局部變數。對於一個完整的程序，在內存中的分布情況如下圖：
代碼區
全局數據區
堆區
棧區
一般程序的由new產生的動態數據存放在堆區，函數內部的自動變數存放在棧區。自動變數一般會隨著函數的退出而釋放空間，靜態數據（即使是函數內部的靜態局部變數）也存放在全局數據區。全局數據區的數據並不會因為函數的退出而釋放空間。細心的讀者可能會發現，Example 1中的代碼中將
static int n; //定義靜態全局變數
改為
int n; //定義全局變數
程序照樣正常運行。
的確，定義全局變數就可以實現變數在文件中的共享，但定義靜態全局變數還有以下好處：
靜態全局變數不能被其它文件所用；
其它文件中可以定義相同名字的變數，不會發生沖突；
您可以將上述示例代碼改為如下：
//Example 2//File1#include <iostream.h>void fn();static int n; //定義靜態全局變數void main(){ n=20; cout<<n<<endl; fn();}//File2#include <iostream.h>extern int n;void fn(){ n++; cout<<n<<endl;}
編譯並運行Example 2，您就會發現上述代碼可以分別通過編譯，但運行時出現錯誤。 試著將
static int n; //定義靜態全局變數
改為
int n; //定義全局變數
再次編譯運行程序，細心體會全局變數和靜態全局變數的區別。
2、靜態局部變數
在局部變數前，加上關鍵字static，該變數就被定義成為一個靜態局部變數。
我們先舉一個靜態局部變數的例子，如下：
//Example 3#include <iostream.h>void fn();void main(){ fn(); fn(); fn();}void fn(){ static n=10; cout<<n<<endl; n++;}
通常，在函數體內定義了一個變數，每當程序運行到該語句時都會給該局部變數分配棧內存。但隨著程序退出函數體，系統就會收回棧內存，局部變數也相應失效。
但有時候我們需要在兩次調用之間對變數的值進行保存。通常的想法是定義一個全局變數來實現。但這樣一來，變數已經不再屬於函數本身了，不再僅受函數的控制，給程序的維護帶來不便。
靜態局部變數正好可以解決這個問題。靜態局部變數保存在全局數據區，而不是保存在棧中，每次的值保持到下一次調用，直到下次賦新值。
靜態局部變數有以下特點：
該變數在全局數據區分配內存；
靜態局部變數在程序執行到該對象的聲明處時被首次初始化，即以後的函數調用不再進行初始化；
靜態局部變數一般在聲明處初始化，如果沒有顯式初始化，會被程序自動初始化為0；
它始終駐留在全局數據區，直到程序運行結束。但其作用域為局部作用域，當定義它的函數或語句塊結束時，其作用域隨之結束；
3、靜態函數
在函數的返回類型前加上static關鍵字,函數即被定義為靜態函數。靜態函數與普通函數不同，它只能在聲明它的文件當中可見，不能被其它文件使用。
靜態函數的例子：
//Example 4#include <iostream.h>static void fn();//聲明靜態函數void main(){ fn();}void fn()//定義靜態函數{ int n=10; cout<<n<<endl;}
定義靜態函數的好處：
靜態函數不能被其它文件所用；
其它文件中可以定義相同名字的函數，不會發生沖突；
二、面向對象的static關鍵字（類中的static關鍵字）
1、靜態數據成員
在類內數據成員的聲明前加上關鍵字static，該數據成員就是類內的靜態數據成員。先舉一個靜態數據成員的例子。
//Example 5#include <iostream.h>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="<<Sum<<endl;}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 <iostream.h>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<<a<<endl; //錯誤代碼，a是非靜態數據成員 cout<<"Sum="<<Sum<<endl;}void main(){ Myclass M(1,2,3); M.GetSum(); Myclass N(4,5,6); N.GetSum(); Myclass::GetSum();}
關於靜態成員函數，可以總結為以下幾點：
出現在類體外的函數定義不能指定關鍵字static；
靜態成員之間可以相互訪問，包括靜態成員函數訪問靜態數據成員和訪問靜態成員函數；
非靜態成員函數可以任意地訪問靜態成員函數和靜態數據成員；
靜態成員函數不能訪問非靜態成員函數和非靜態數據成員；
由於沒有this指針的額外開銷，因此靜態成員函數與類的全局函數相比速度上會有少許的增長；
調用靜態成員函數，可以用成員訪問操作符(.)和(->)為一個類的對象或指向類對象的指針調用靜態成員函數，也可以直接使用如下格式：
＜類名＞::＜靜態成員函數名＞（＜參數表＞）
調用類的靜態成員函數。
===============================================================================================
static靜態變數聲明符。 在聲明它的程序塊，子程序塊或函數內部有效，值保持，在整個程序期間分配存儲器空間，編譯器默認值0。
是C++中很常用的修飾符，它被用來控制變數的存儲方式和可見性。
2、為什麼要引入static?
函數內部定義的變數，在程序執行到它的定義處時，編譯器為它在棧上分配空間，大家知道，函數在棧上分配的空間在此函數執行結束時會釋放掉，這樣就產生了一個問題: 如果想將函數中此變數的值保存至下一次調用時，如何實現？最容易想到的方法是定義一個全局的變數，但定義為一個全局變數有許多缺點，最明顯的缺點是破壞了此變數的訪問范圍（使得在此函數中定義的變數，不僅僅受此函數控制）。
3、什麼時候用static?
需要一個數據對象為整個類而非某個對象服務,同時又力求不破壞類的封裝性,即要求此成員隱藏在類的內部，對外不可見。
4、static的內部機制：
靜態數據成員要在程序一開始運行時就必須存在。因為函數在程序運行中被調用，所以靜態數據成員不能在任何函數內分配空間和初始化。
這樣，它的空間分配有三個可能的地方，一是作為類的外部介面的頭文件，那裡有類聲明；二是類定義的內部實現，那裡有類的成員函數定義；三是應用程序的main（）函數前的全局數據聲明和定義處。
靜態數據成員要實際地分配空間，故不能在類的聲明中定義（只能聲明數據成員）。類聲明只聲明一個類的「尺寸和規格」，並不進行實際的內存分配，所以在類聲明中寫成定義是錯誤的。它也不能在頭文件中類聲明的外部定義，因為那會造成在多個使用該類的源文件中，對其重復定義。
static被引入以告知編譯器，將變數存儲在程序的靜態存儲區而非棧上空間，靜態
數據成員按定義出現的先後順序依次初始化，注意靜態成員嵌套時，要保證所嵌套的成員已經初始化了。消除時的順序是初始化的反順序。
5、static的優勢：
可以節省內存，因為它是所有對象所公有的，因此，對多個對象來說，靜態數據成員只存儲一處，供所有對象共用。靜態數據成員的值對每個對象都是一樣，但它的值是可以更新的。只要對靜態數據成員的值更新一次，保證所有對象存取更新後的相同的值，這樣可以提高時間效率。
6、引用靜態數據成員時，採用如下格式：
<類名>::<靜態成員名>
如果靜態數據成員的訪問許可權允許的話(即public的成員)，可在程序中，按上述格式
來引用靜態數據成員。
7、注意事項：
(1)類的靜態成員函數是屬於整個類而非類的對象，所以它沒有this指針，這就導致
了它僅能訪問類的靜態數據和靜態成員函數。
(2)不能將靜態成員函數定義為虛函數。
(3)由於靜態成員聲明於類中，操作於其外，所以對其取地址操作，就多少有些特殊
，變數地址是指向其數據類型的指針 ，函數地址類型是一個「nonmember函數指針」。
(4)由於靜態成員函數沒有this指針，所以就差不多等同於nonmember函數，結果就
產生了一個意想不到的好處：成為一個callback函數，使得我們得以將C++和C-based X W
indow系統結合，同時也成功的應用於線程函數身上。
(5)static並沒有增加程序的時空開銷，相反她還縮短了子類對父類靜態成員的訪問
時間，節省了子類的內存空間。
(6)靜態數據成員在<定義或說明>時前面加關鍵字static。
(7)靜態數據成員是靜態存儲的，所以必須對它進行初始化。
(8)靜態成員初始化與一般數據成員初始化不同:
初始化在類體外進行，而前面不加static，以免與一般靜態變數或對象相混淆；
初始化時不加該成員的訪問許可權控制符private，public等；
初始化時使用作用域運算符來標明它所屬類；
所以我們得出靜態數據成員初始化的格式：
<數據類型><類名>::<靜態數據成員名>=<值>
(9)為了防止父類的影響，可以在子類定義一個與父類相同的靜態變數，以屏蔽父類的影響。這里有一點需要注意：我們說靜態成員為父類和子類共享，但我們有重復定義了靜態成員，這會不會引起錯誤呢？不會，我們的編譯器採用了一種絕妙的手法：name-mangling 用以生成唯一的標志。
編輯本段static 函數
內部函數和外部函數
當一個源程序由多個源文件組成時，C語言根據函數能否被其它源文件中的函數調用，將函數分為內部函數和外部函數。
1 內部函數（又稱靜態函數）
如果在一個源文件中定義的函數，只能被本文件中的函數調用，而不能被同一程序其它文件中的函數調用，這種函數稱為內部函數。
定義一個內部函數，只需在函數類型前再加一個「static」關鍵字即可，如下所示：
static 函數類型 函數名(函數參數表)
{……}
關鍵字「static」，譯成中文就是「靜態的」，所以內部函數又稱靜態函數。但此處「static」的含義不是指存儲方式，而是指對函數的作用域僅局限於本文件。
使用內部函數的好處是：不同的人編寫不同的函數時，不用擔心自己定義的函數，是否會與其它文件中的函數同名，因為同名也沒有關系。
2 外部函數
外部函數的定義：在定義函數時，如果沒有加關鍵字「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(……) /*定義外部函數*/
{……}

⑧ java靜態方法(方法前冠以static)和實例方法(未冠以static)的區別

靜態方法（方法前冠以static）和實例方法（前面未冠以static）的區別

調用靜態方法或說類方法時，可以使用類名做前綴，也可以使用某一個具體的對象名；通常使用類名。
非static的方法是屬於某個對象的方法，而static的方法是屬於整個類的，不被任何一個對象單獨擁有；
由於static方法是屬於整個類的，所以它不能操縱和處理屬於某個對象的成員變數，而只能處理屬於整個類的成員變數，也即，static方法只能處理static域或靜態方法。實例方法可以訪問實例域， 靜態域或靜態方法， 記住都行。
聲明為static的方法有以下幾條限制： 1.它們僅能調用其他的static方法。
2.它們只能訪問static數據。
3.它們不能以任何方式引用this或super（關鍵 字super與繼承有關，在下一章中描述）。
static method Have No this Reference
All instance methods have a hidden parameter—this
So,

Static method can』t access instance methods and fields; it can only
invoke other static class
members.It can access class members only.
instance can use static method.
Instance methods:
If a method is declared without the static modifier keyword,
that method is known as an instance method. Instance methods
are associated with objects – not classes.
It can access either instance or class members.

本章源碼

class StaticExa {
static int a = 4;
static int b = 9;
static void call() {
System.out.println("a = " + a);//靜態方法可以訪問靜態屬性
}
}
public class Test {
static int c = 43;
public static void main(String args[]) {
/*剛運行到這一步時，debug觀察，StaticExa.a的值就等於42，Test.c的值就等於43，
說明系統在我們的程序一開始時，就會給所有的類變數賦值。如果是對象參考， 就是null，
見photoshop的例子*/

。。。。。。。。。。。。。。。。詳情網上找「馬克-to-win」，參考他的網站或他的網路空間：java第2章的內容

⑨ JAVA中的static

Java是個面向對象編程的語言，一般而言，方法需要通過實例對象來調用。但是有一些方法不需要實例對象（或者說沒有這樣的對象）來調用，那麼就可以在方式前面加上static修飾符，表示這個方法是靜態方法，不需要實例對象就可以調用。
例如String類的valueOf(int arg0)方法，作用是得到整數參數arg0的字元串表示，不需要創建出一個String類的實例對象來調用這個方法，所以它是static的。
如果你學過C/C++，你就會知道C/C++程序有一個入口，就是main()函數。電腦執行C/C++程序的時候就以main()函數作為入口，首先執行main()函數。Java也是類似，JVM首先調用main()方法。這個時候還沒有什麼實例對象呢，所以必須把main()方法聲明為static，以便JVM調用。

如果是在類中變數前加static修飾的話，就是另外一個意思了。例如「人」這個類，有一個成員變數叫做「姓名」。現在new一個「人」的實例對象叫做「張三」，再new一個「人」的實例對象叫做「李四」。張三、李四自然有各自的「姓名」，它們的「姓名」成員變數在內存當中各自佔一塊存儲單元，互不幹擾。但是，如果在「人」這個類的「姓名」成員變數前加上static修飾的話，那麼就變成了類變數。還是new出來「張三」「李四」，這次張三、李四的「姓名」在內存中就不是各自獨立的存儲區域了，而是共用一個存儲區域。所有「人」的實例對象的「姓名」其實都是指的那一個存儲單元。無論創建10個「人」對象還是100個「人」對象，它們的「姓名」指向的都是內存中的那一個存儲單元。如果被更改了，實際上所有的對象的「姓名」都會改了，因為它們引用的都是內存中的那一個存儲單元。就好像這個變數是屬於類而不是屬於實例對象的。

靜態方法因為不需要實例對象就可以調用，所以當然其中也不可以使用實例對象變數。原因很簡單啊，調用靜態方法的時候怎麼知道實例對象有沒有創建、實例對象變數有沒有初始化過呢。還是拿String類的valueOf()方法舉例。假設valueOf()方法裡面調用了String的一個實例對象str的某個成員變數。
那麼以下這行代碼
String.valueOf(10);
執行的時候，如何確定此時str對象就一定被創建出來並且成員變數都初始化過有值了呢？

⑩ JAVA! static什麼作用

static是靜態修飾符，static可以用來區分成員變數、方法是屬於類本身還是屬於類實例化後的對象。有static修飾的成員屬於類本身，沒有static修飾的成員屬於類的實例。

static靜態變數是屬於類的，只有一份存儲空間，是類之間共享的，牽一發而動全身，一處變，處處變。實例變數屬於實例對象，創建幾次對象，就有幾份的成員變數（拷貝）。

(10)cjavastatic擴展閱讀

static的使用

示例：

classa{

publicstatic$aa=1;

publicstaticfunctionaa(){

self::$aa+=1;

echoself::$aa;

}

}

classb{

publicfunctionbb(){

a::aa();

}

}

classc{

publicfunctioncc(){

a::aa();

}

}

$bbb=newb();

$ccc=newc();

$bbb->bb();

echo'*******************';

$ccc->cc();