java靜態變數定義

『壹』 java靜態變數的基本介紹

1·、static應用范圍：可用於內部類、方法和變數。
2、標記一個方法為static，意味著這個方法，被所在類的所有實例公用，在類裝載時被首先執行，執行一次即被所有該類的實例共享，同時意味著：
A、static方法內部不能引用非static變數。
B、static方法不能被子類重寫為非static方法。
C、父類的非static方法不能被子類重寫為static方法。
D、static代碼塊可以用static {}來完成，在類被第一次裝載時執行初始化，先於靜態方法和其他方法的執行。
3、標記一個變數為static，則該變數在內存中有不變的位置，相當於全局變數，所有類的實例都訪問同一個存儲變數區域。對其修改對於所有類的實例來說都是可見和一致的。

『貳』 java中什麼叫靜態成員變數麻煩告訴我

在java變數分為實例變數和靜態變數
方法實例方法和靜態方法如class Example{
int data;//定義實例變數，也叫成員變數
public void method(){
.....}static int count = 0;//定義靜變數
public static func(){ //靜態方法
......}public void static main(String arg[]){
Example e = new Example();//實例化一個對象
e.data = 0;//若要調用實例變數，則必須通過對象e來調用
count++;//要調用靜態變數，則在這里直接調用
//同樣，實例方法和靜態方法也是如此}}如果要在其它類中調用實例變數，則用 類.對象.實例變數，(如果實例變數是public)
若調用靜態方法，用 類.方法 調用。
實例變數和實例方法是 對象的屬性，
而靜態變數和靜態方法是 類的屬性。

『叄』 java 靜態初始化塊中是否可以定義靜態變數

靜態變數只能定義在類的內部，不可以定義在靜態塊或方法中
可以在類內部定義靜態變數，在靜態塊中進行初始化操作，因為類的內部是不允許有操作語句存在的，比如JDBC操作，所以可以在靜態塊static{} 中進行初始化操作，如：JDBC
定義靜態變數主要是為了供外部訪問，定義在一個局部中外部沒有許可權訪問，為什麼要定義呢，而且不能定義

『肆』 誰能詳細說明java中什麼樣的是靜態成員變數

Java類中的靜態變數在程序運行期間，其內存空間對所有該類的對象實例而言是共享的，有些時候可以認為是全局變數。因此在某些時候為了節省系統內存開銷、共享資源，可以將類中的一些變數聲明為靜態變數。
因為靜態變數生命周期較長，而且不易被系統回收，因此如果不能合理地使用靜態變數，就會適得其反，造成大量的內存浪費，所謂過猶不及。因此，建議在具備下列全部條件的情況下，盡量使用靜態變數：
（1）變數所包含的對象體積較大，佔用內存較多。
（2）變數所包含的對象生命周期較長。
（3）變數所包含的對象數據穩定。
（4）該類的對象實例有對該變數所包含的對象的共享需求。
如果變數不具備上述特點建議你不要輕易地使用靜態變數，以免弄巧成拙。

『伍』 java靜態變數怎麼聲明

個人的總結
1 靜態變數只有一份被類的所有實例共享
2 靜態變數的聲明在編譯時已經明確了內存的位置
3 延遲初始化是改變靜態變數的值
引用

Java靜態變數的初始化（static塊的本質）

在網上看到了下面的一段代碼：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

上述代碼會列印出什麼結果來呢？10還是20？本文將以此代碼為引子，著重討論一下靜態變數的初始化問題。 樓主可以找組織先記下175再來記下161最後填寫984就會出現扣裙問題1：靜態變數如何初始化

Java類中可以定義一個static塊，用於靜態變數的初始化。如：

1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6. }

public class Test { public static int _i; static { _i = 10; } }

當然最常用的初始化靜態變數的操作是在聲明變數時直接進行賦值操作。如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

那麼上述兩例在本質上有什麼區別嗎？回答是沒有區別。兩例代碼編譯之後的位元組碼完全一致，通過 「javap -c」查看到的位元組碼如下：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: return

}

通過位元組碼還可以看出，當類的定義中不含有static塊時，編譯器會為該類提供一個默認的static塊。當然這是在含有靜態變數初始化操作的前 提下。如果靜態變數沒有初始化操作，則編譯器不會為之提供默認的static塊。如：

1. public class Test {
2. public static int _i;
3. }

public class Test { public static int _i; }

其位元組碼的表現形式為：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

}

由於靜態變數是通過賦值操作進行初始化的，因此可以通過靜態函數返回值的方式為其初始化。如：

1. public class Test {
2. public static int _i = init();
3.
4. private static int init() {
5. return 10;
6. }
7. }

public class Test { public static int _i = init(); private static int init() { return 10; } }

其本質與下面的代碼相同：

1. public class Test {
2. public static int _i;
3. static {
4. _i = init();
5. }
6.
7. private static int init() {
8. return 10;
9. }
10. }

public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }

問題2：JDK如何處理static塊

類定義中可以存在多個static塊嗎？回答是可以。如：

1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6.
7. public static void main(String[] args) {
8. }
9.
10. static {
11. _i = 20;
12. }
13. }

public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }

此類編譯之後的位元組碼為：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

public static void main(java.lang.String[]);
Code:
0: return

static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: bipush 20
7: putstatic #2; //Field _i:I
10: return

}

觀察static{}部分可以看出，上例的代碼與下面的代碼效果一致：

1. public class Test {
2. public static int _i;
3.
4. public static void main(String[] args) {
5. }
6.
7. static {
8. _i = 10;
9. _i = 20;
10. }
11. }

public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }

此例可以證明，不僅類定義中可以有多個static塊，而且在編譯時編譯器會將多個static塊按照代碼的前後位置重新組合成一個static 塊。
問題3：如何看待靜態變數的聲明

靜態變數存放在常量池之中。如何證明呢？如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

使用「javap -c -verbose」查看其位元組碼的內容如下：

public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 49
Constant pool:
const #1 = Method #4.#14; // java/lang/Object."<init>":()V
const #2 = Field #3.#15; // Test._i:I
const #3 = class #16; // Test
const #4 = class #17; // java/lang/Object
const #5 = Asciz _i;
const #6 = Asciz I;
const #7 = Asciz <init>;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz <clinit>;
const #12 = Asciz SourceFile;
const #13 = Asciz Test.java;
const #14 = NameAndType #7:#8;// "<init>":()V
const #15 = NameAndType #5:#6;// _i:I
const #16 = Asciz Test;
const #17 = Asciz java/lang/Object;

{
public static int _i;

public Test();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 2: 0

static {};
Code:
Stack=1, Locals=0, Args_size=0
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
LineNumberTable:
line 3: 0

}

我們看到，常量池中const #2指向的就是Test._i，也就是靜態變數。靜態變數被保存到常量池中的工作原理這里不深入討論。在此需要注意的是：

* 靜態變數的聲明與初始化是兩個不同的操作；
* 靜態變數的聲明在編譯時已經明確了內存的位置。

如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

上述代碼的本質可以視為：

1. public class Test {
2. // 靜態變數的聲明
3. public static int _i;
4.
5. // 靜態變數的初始化
6. static {
7. _i = 10;
8. }
9. }

public class Test { // 靜態變數的聲明 public static int _i; // 靜態變數的初始化 static { _i = 10; } }

由於靜態變數的聲明在編譯時已經明確，所以靜態變數的聲明與初始化在編碼順序上可以顛倒。也就是說可以先編寫初始化的代碼，再編寫聲明代碼。如：

1. public class Test {
2. // 靜態變數的初始化
3. static {
4. _i = 10;
5. }
6.
7. // 靜態變數的聲明
8. public static int _i;
9. }

public class Test { // 靜態變數的初始化 static { _i = 10; } // 靜態變數的聲明 public static int _i; }

對初始問題的解答

解答了上述三個問題，讓我們再來看看開篇提到的問題。代碼如下：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

其本質可以用下面的代碼表示：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i;
6. static {
7. _i = 10;
8. }
9.
10. public static void main(String[] args) {
11. System.out.println(_i);
12. }
13. }

public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

再簡化一下，可以表示為：

1. public class Test {
2. public static int _i;
3.
4. static {
5. _i = 20;
6. _i = 10;
7. }
8.
9. public static void main(String[] args) {
10. System.out.println(_i);
11. }
12. }

public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

至此，代碼已經明確告訴我們列印結果是什麼了！

『陸』 java 靜態變數和靜態常量

• 靜態變數是屬於靜態存儲方式，但是屬於靜態存儲方式的量不一定就是靜態變數，例如外部變數雖屬於靜態存儲方式，但不一定是靜態變數，必須由static加以定義後才能成為靜態外部變數，或稱靜態全局變數。

• 對於自動變數，它屬於動態存儲方式。但是也可以用static定義它為靜態自動變數，或稱靜態局部變數，從而成為靜態存儲方式。由此看來，一個變數可由static進行再說明，並改變其原有的存儲方式。

• 而在以Pascal為代表的許多程序語言中，所有局部變數都由系統自動分配存儲空間，而所有全局變數的存儲空間則以靜態分配的方式獲取，因此由於實際上「局部變數」和「全局變數」這兩個術語已足以涵蓋所有的情況，在這些程序語言中通常不使用「靜態變數」這一術語，而直接以「全局變數」代之。

• 在這些程序語言中，靜態變數就是全局變數，而即使在有明確區分全局和靜態變數的程序語言中，在編譯後的代碼里二者也以相同的方式獲取存儲空間。而今術語「靜態變數」的概念則主要基於C族語言的「static」的定義。

• 靜態變數也可以用於存儲常數。具體來說，靜態變數可用const，constant或final等關鍵字標識，這時其值就會在編譯時設定，並且無法在運行時改變。編譯器通常將靜態常量與文本一起置於目標文件的文本區域，而非常量初始化數據則置於數據區

『柒』 java中什麼是靜態變數，什麼是常量

在C++中(以及其他一些語言，如 C#，Java 等面向對象的語言中)類的成員變數被聲明為static（稱為靜態成員變數），意味著它為該類的所有實例所共享，也就是說當某個類的實例修改了該靜態成員變數，其修改值為該類的其它所有實例所見。
比如在某個類A中聲明一個static int number;初始化為0。這個number就能被所有A的實例共用。在A的構造函數里加上number++，在A的析構函數里加上number--。那麼每生成一個A的實例，number就加一，每銷毀一個A的實例，number就減一，這樣，number就可以記錄程序中共生成了多少個A的實例。
這只是靜態成員的一種用法而已。

常量(constant）
也稱常數，是一種恆定的或不可變的數值或數據項。
它們可以是不隨時間變化的某些量和信息，也可以是表示某一數值的字元或字元串，常被用來標識、測量和比較。

『捌』 java 靜態函數中的變數定義

局部變數好像不能用靜態修飾吧……因為局部變數它定義的局部使用，不能長期存在，而靜態變數會一直保存在內存中，兩者本質上是沖突的
變數分成局部變數和成員變數，成員變數又分成類變數（用static修飾）和實例變數，靜態方法可以調用所有的成員變數，普通方法只能調用非靜態變數，也就是實例變數

『玖』 在Java中，到底什麼是靜態變數呢

答：在程序開發時，我們經常希望一個變數和方法不隨對象的改變而改變，甚至在沒有創建對象時也能訪問數據和方法，這時就可以在數據和方法上加上Static關鍵字，被Static修飾的數據就叫做靜態變數（數據）而方法就叫靜態方法。靜態變數在內存中的地址是相同的，所以對於同一類的不同對象，它們靜態變數的值肯定是相同的。