1、實例變量 (非靜態(tài)字段) 從技術(shù)上來說, 對象保存它們各自的狀態(tài)在 "非靜態(tài)字段", 也即, 沒有使用static 關(guān)鍵字定義的字段. 非靜態(tài)字段也稱為 實例變量 因為它們的值對每個 類 實例 (對每個對象, 換句話說); 一個自行車的currentSpeed 與另外一個自行車的currentSpeed 是獨立的.
天全網(wǎng)站建設(shè)公司成都創(chuàng)新互聯(lián)公司,天全網(wǎng)站設(shè)計制作，有大型網(wǎng)站制作公司豐富經(jīng)驗。已為天全上千家提供企業(yè)網(wǎng)站建設(shè)服務(wù)。企業(yè)網(wǎng)站搭建\外貿(mào)營銷網(wǎng)站建設(shè)要多少錢，請找那個售后服務(wù)好的天全做網(wǎng)站的公司定做！
2、類變量 (靜態(tài)字段)類變量是使用static 修飾符聲明的變量;這告訴編譯器僅有一份該變量存在, 無論該類被實例化多少個對象。為 某種類型的自行車定義gear數(shù)量的字段可以標(biāo)記為static 因為所有實例有相同數(shù). 代碼static int numGears = 6; 將創(chuàng)建一個這樣的靜態(tài)字段. 此外, 可以添加關(guān)鍵字final 來表明轉(zhuǎn)動裝置個數(shù)永遠(yuǎn)不發(fā)生改變 .
類型 變量名[=初值] [,變量名[=初值]......。
string s="",b=""; 中間，表示連續(xù)申明變量，都是最前面的類型。
一、定義字符串
直接定義字符串是指使用雙引號表示字符串中的內(nèi)容，例如"Hello Java"、"Java 編程"等。具體方
法是用字符串常量直接初始化一個 String 對象，示例如下：
String str="Hello Java";? ? ?String str;? ? ?str="Heilo Java";
二、用 String 類定義
1. String() 初始化一個新創(chuàng)建的 String 對象，表示一個空字符序列。
2. String(String original)
初始化一個新創(chuàng)建的 String 對象，使其表示一個與參數(shù)相同的字符序列。換句話說，新創(chuàng)建的字符串是該參數(shù)字符串的副本。
例如：
String str1=new String("Hello Java");
String str2=new String(str1);
3、String(char[ ]value)
分配一個新的字符串，將參數(shù)中的字符數(shù)組元素全部變?yōu)樽址?。該字符?shù)組的內(nèi)容已被復(fù)制，后
續(xù)對字符數(shù)組的修改不會影響新創(chuàng)建的字符串。
例如：
char a[]={'H','e','l','l','0'};
String sChar=new String(a);a[1]='s';
4、String(char[] value,int offset,int count)
分配一個新的 String，它包含來自該字符數(shù)組參數(shù)一個子數(shù)組的字符。offset 參數(shù)是子數(shù)組第一個字符的索引，count 參數(shù)指定子數(shù)組的長度。
該子數(shù)組的內(nèi)容已被賦值，后續(xù)對字符數(shù)組的修改不會影響新創(chuàng)建的字符串。
例如：
char a[]={'H','e','l','l','o'};
String sChar=new String(a,1,4);
a[1]='s';
擴(kuò)展資料：
編程工具：
Eclipse：一個開放源代碼的、基于Java的可擴(kuò)展開發(fā)平臺 。
NetBeans：開放源碼的Java集成開發(fā)環(huán)境，適用于各種客戶機(jī)和Web應(yīng)用。
IntelliJ IDEA：在代碼自動提示、代碼分析等方面的具有很好的功能。
MyEclipse：由Genuitec公司開發(fā)的一款商業(yè)化軟件，是應(yīng)用比較廣泛的Java應(yīng)用程序集成開發(fā)環(huán)境? ?。
EditPlus：如果正確配置Java的編譯器“Javac”以及解釋器“Java”后，可直接使用EditPlus編譯執(zhí)行Java程序? ?。
參考資料：百度百科-java
首先要說明的是，java里不能直接使用synchronized聲明一個變量，而是使用synchronized去修飾一個代碼塊或一個方法。\x0d\x0a\x0d\x0a詳細(xì)說明如下：\x0d\x0a\x0d\x0a synchronized用來修飾一個方法或者一個代碼塊，它用來保證在同一時刻最多只有一個線程執(zhí)行該段代碼。\x0d\x0a 一、當(dāng)兩個并發(fā)線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內(nèi)只能有一個線程得到執(zhí)行。另一個線程必須等待當(dāng)前線程執(zhí)行完這個代碼塊以后才能執(zhí)行該代碼塊。\x0d\x0a 二、然而，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，另一個線程仍然可以訪問該object中的非synchronized(this)同步代碼塊。\x0d\x0a 三、尤其關(guān)鍵的是，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，其他線程對object中所有其它synchronized(this)同步代碼塊的訪問將被阻塞。\x0d\x0a 四、第三個例子同樣適用其它同步代碼塊。也就是說，當(dāng)一個線程訪問object的一個synchronized(this)同步代碼塊時，它就獲得了這個object的對象鎖。結(jié)果，其它線程對該object對象所有同步代碼部分的訪問都被暫時阻塞。\x0d\x0a 五、以上規(guī)則對其它對象鎖同樣適用。\x0d\x0a\x0d\x0a示例代碼：\x0d\x0apublic class Thread1 implements Runnable { \x0d\x0a public void run() { \x0d\x0a synchronized(this) { \x0d\x0a for (int i = 0; i
回答于?2022-11-16
這個String只是個局部變量，本次循環(huán)結(jié)束后就會失去引用，占用的空間一段時間后會被自動回收
個人的總結(jié)
1 靜態(tài)變量只有一份被類的所有實例共享
2 靜態(tài)變量的聲明在編譯時已經(jīng)明確了內(nèi)存的位置
3 延遲初始化是改變靜態(tài)變量的值
引用
Java靜態(tài)變量的初始化（static塊的本質(zhì)）
在網(wǎng)上看到了下面的一段代碼：
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); } }
上述代碼會打印出什么結(jié)果來呢？10還是20？本文將以此代碼為引子，著重討論一下靜態(tài)變量的初始化問題。 樓主可以找組織先記下175再來記下161最后填寫984就會出現(xiàn)扣裙問題1：靜態(tài)變量如何初始化
Java類中可以定義一個static塊，用于靜態(tài)變量的初始化。如：
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; } }
當(dāng)然最常用的初始化靜態(tài)變量的操作是在聲明變量時直接進(jìn)行賦值操作。如：
1. public class Test {
2. public static int _i = 10;
3. }
public class Test { public static int _i = 10; }
那么上述兩例在本質(zhì)上有什么區(qū)別嗎？回答是沒有區(qū)別。兩例代碼編譯之后的字節(jié)碼完全一致，通過 “javap -c”查看到的字節(jié)碼如下：
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
}
通過字節(jié)碼還可以看出，當(dāng)類的定義中不含有static塊時，編譯器會為該類提供一個默認(rèn)的static塊。當(dāng)然這是在含有靜態(tài)變量初始化操作的前 提下。如果靜態(tài)變量沒有初始化操作，則編譯器不會為之提供默認(rèn)的static塊。如：
1. public class Test {
2. public static int _i;
3. }
public class Test { public static int _i; }
其字節(jié)碼的表現(xiàn)形式為：
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
}
由于靜態(tài)變量是通過賦值操作進(jìn)行初始化的，因此可以通過靜態(tài)函數(shù)返回值的方式為其初始化。如：
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; } }
其本質(zhì)與下面的代碼相同：
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; } }
此類編譯之后的字節(jié)碼為：
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：如何看待靜態(tài)變量的聲明
靜態(tài)變量存放在常量池之中。如何證明呢？如：
1. public class Test {
2. public static int _i = 10;
3. }
public class Test { public static int _i = 10; }
使用“javap -c -verbose”查看其字節(jié)碼的內(nèi)容如下：
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，也就是靜態(tài)變量。靜態(tài)變量被保存到常量池中的工作原理這里不深入討論。在此需要注意的是：
* 靜態(tài)變量的聲明與初始化是兩個不同的操作；
* 靜態(tài)變量的聲明在編譯時已經(jīng)明確了內(nèi)存的位置。
如：
1. public class Test {
2. public static int _i = 10;
3. }
public class Test { public static int _i = 10; }
上述代碼的本質(zhì)可以視為：
1. public class Test {
2. // 靜態(tài)變量的聲明
3. public static int _i;
4.
5. // 靜態(tài)變量的初始化
6. static {
7. _i = 10;
8. }
9. }
public class Test { // 靜態(tài)變量的聲明 public static int _i; // 靜態(tài)變量的初始化 static { _i = 10; } }
由于靜態(tài)變量的聲明在編譯時已經(jīng)明確，所以靜態(tài)變量的聲明與初始化在編碼順序上可以顛倒。也就是說可以先編寫初始化的代碼，再編寫聲明代碼。如：
1. public class Test {
2. // 靜態(tài)變量的初始化
3. static {
4. _i = 10;
5. }
6.
7. // 靜態(tài)變量的聲明
8. public static int _i;
9. }
public class Test { // 靜態(tài)變量的初始化 static { _i = 10; } // 靜態(tài)變量的聲明 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); } }
其本質(zhì)可以用下面的代碼表示：
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); } }
至此，代碼已經(jīng)明確告訴我們打印結(jié)果是什么了！
重慶分公司
重慶分公司
