constjava

A. java語言中，不能被修改的變數是用關鍵字（）來修飾的

final表示不能修滲基改的變數，如果再加上static就能修飾拆含常量叢御謹

B. Java的const怎麼用

const是constant的縮寫，「恆定不變」的意思。被const修飾的東西都受到強制保護，可以預防意外的變動，能提高程序的健壯性和高效性。

1 用const修飾函數的參數
如果參數作輸出用，不論它是什麼數據類型，也不論它採用「指針傳遞」還是「引用傳遞」，都不能加const修飾，否則該參數將失去輸出功能。
const只能修飾輸入參數：
u 如果輸入參數採用「指針傳遞」，那麼加const修飾可以防止意外地改動該指針，起到保護作用。
例如StringCopy函數：
void StringCopy(char *strDestination, const char *strSource);
其中strSource是輸入參數，strDestination是輸出參數。給strSource加上const修飾後，如果函數體內的語句試圖改動strSource的內容，編譯器將指出錯誤。

u 如果輸入參數採用「值傳遞」，由於函數將自動產生臨時變數用於復制該參數，該輸入參數本來就無需保護，所以不要加const修飾。
例如不要將函數void Func1(int x)寫成void Func1(const int x)。同理不要將函數void Func2(A a) 寫成void Func2(const A a)。其中A為用戶自定義的數據類型。

u 對於非內部數據類型的參數而言，象void Func(A a) 這樣聲明的函數註定效率比較底。因為函數體內將產生A類型的臨時對象用於復制參數a，而臨時對象的構造、復制、析構過程都將消耗時間。
為了提高效率，可以將函數聲明改為void Func(A& a)，因為「引用傳遞」僅借用一下參數的別名而已，不需要產生臨時對象。但是函數void Func(A& a) 存在一個缺點：「引用傳遞」有可能改變參數a，這是我們不期望的。解決這個問題很容易，加const修飾即可，因此函數最終成為void Func(const A& a)。
以此類推，是否應將void Func(int x) 改寫為void Func(const int& x)，以便提高效率？完全沒有必要，因為內部數據類型的參數不存在構造、析構的過程，而復制也非常快，「值傳遞」和「引用傳遞」的效率幾乎相當。
對於非內部數據類型的輸入參數，應該將「值傳遞」的方式改為「const引用傳遞」，目的是提高效率。例如將void Func(A a) 改為void Func(const A& a)。
對於內部數據類型的輸入參數，不要將「值傳遞」的方式改為「const引用傳遞」。否則既達不到提高效率的目的，又降低了函數的可理解性。例如void Func(int x) 不應該改為void Func(const int& x)。

2 用const修飾函數的返回值
u 如果給以「指針傳遞」方式的函數返回值加const修飾，那麼函數返回值（即指針）的內容不能被修改，該返回值只能被賦給加const修飾的同類型指針。
例如函數
const char* GetString(void);
如下語句將出現編譯錯誤：
char *str = GetString();
正確的用法是
const char *str = GetString();
u 如果函數返回值採用「值傳遞方式」，由於函數會把返回值復制到外部臨時的存儲單元中，加const修飾沒有任何價值。
例如不要把函數int GetInt(void) 寫成const int GetInt(void)。
同理不要把函數A GetA(void) 寫成const A GetA(void)，其中A為用戶自定義的數據類型。
如果返回值不是內部數據類型，將函數A GetA(void) 改寫為const A& GetA(void)的確能提高效率。但此時千萬千萬要小心，一定要搞清楚函數究竟是想返回一個對象的「拷貝」還是僅返回「別名」就可以了，否則程序會出錯。例如：

[cpp] view plainprint?
class String
{
//…
// 賦值函數
String & operate=(const String &other);
// 相加函數，如果沒有friend修飾則只許有一個右側參數
friend String operate+(const String &s1, const String &s2);
private:
char *m_data;
}
class String
{
//…
// 賦值函數
String & operate=(const String &other);
// 相加函數，如果沒有friend修飾則只許有一個右側參數
friend String operate+(const String &s1, const String &s2);
private:
char *m_data;
}

String的賦值函數operate = 的實現如下：

[cpp] view plainprint?
String& String::operate=(const String &other)
{
if (this == &other)
return *this;
delete m_data;
m_data = new char[strlen(other.data)+1];
strcpy(m_data, other.data);
return *this; // 返回的是*this的引用，無需拷貝過程
}
String& String::operate=(const String &other)
{
if (this == &other)
return *this;
delete m_data;
m_data = new char[strlen(other.data)+1];
strcpy(m_data, other.data);
return *this; // 返回的是*this的引用，無需拷貝過程
}

對於賦值函數，應當用「引用傳遞」的方式返回String對象。如果用「值傳遞」的方式，雖然功能仍然正確，但由於return語句要把 *this拷貝到保存返回值的外部存儲單元之中，增加了不必要的開銷，降低了賦值函數的效率。例如：
String a,b,c;
…
a = b; // 如果用「值傳遞」，將產生一次 *this 拷貝
a = b = c; // 如果用「值傳遞」，將產生兩次 *this 拷貝

String的相加函數operate + 的實現如下：

[cpp] view plainprint?
String String::operate+(const String &s1, const String &s2)
{
String temp;
delete temp.data; // temp.data是僅含『\0』的字元串
temp.data = new char[strlen(s1.data) + strlen(s2.data) + 1];
strcpy(temp.data, s1.data);
strcat(temp.data, s2.data);
return temp;
}
String String::operate+(const String &s1, const String &s2)
{
String temp;
delete temp.data; // temp.data是僅含『\0』的字元串
temp.data = new char[strlen(s1.data) + strlen(s2.data) + 1];
strcpy(temp.data, s1.data);
strcat(temp.data, s2.data);
return temp;
}

對於相加函數，應當用「值傳遞」的方式返回String對象。如果改用「引用傳遞」，那麼函數返回值是一個指向局部對象temp的「引用」。由於temp在函數結束時被自動銷毀，將導致返回的「引用」無效。例如：
c = a + b;
此時 a + b 並不返回期望值，c什麼也得不到，留下了隱患。

u 函數返回值採用「引用傳遞」的場合並不多，這種方式一般只出現在類的賦值函數中，目的是為了實現鏈式表達。
例如

[cpp] view plainprint?
class A
{//…
A& operate = (const A &other); // 賦值函數
};
class A
{//…
A& operate = (const A &other); // 賦值函數
};

A a, b, c; // a, b, c 為A的對象
…
a = b = c; // 正常的鏈式賦值
(a = b) = c; // 不正常的鏈式賦值，但合法
如果將賦值函數的返回值加const修飾，那麼該返回值的內容不允許被改動。上例中，語句 a = b = c仍然正確，但是語句 (a = b) = c 則是非法的。

3 用const修飾成員函數
const成員函數是指在類的成員函數後面加 const的函數，如int GetNum() const; const修飾成員函數的作用是：只能讀取數據成員，不能改變數據成員。const成員函數只能調用const函數，不能調用其它非const成員函數；const對象只能調用const成員函數，不能調用非const成員函數。
任何不會修改數據成員的函數都應該聲明為const類型。如果在編寫const成員函數時，不慎修改了數據成員，或者調用了其它非const成員函數，編譯器將指出錯誤，這無疑會提高程序的健壯性。

C. java裡面的const-string什麼意思

java裡面沒法用const。
1、可以用final關鍵字。
2、例如 final int m = 9。
被聲明為final的變數不能被再次賦值。
final也可以用於聲明方法或類，被聲明為final的方法或類不能被繼承。
3、注意const是java的保留字以備擴充。

const-String表示定義好的字元串常量在任何位置都不能被更改。

D. java，謝謝

1.在java語言中，標識符可以由字母、數字、下劃線或者美元符號組成，但不能以數字開頭，還有就是不能取java的保留字作為標識符，選A的原因是const恰恰是一個保留字。
2.loop是這額循環體的名字，continue Loop即為跳出這個循環。

E. java中關鍵字const是什麼意思

在Java中,const是作為保留字以備擴充,同樣的保留字以備擴充還有goto.

你可以用final關鍵字.final也可以用於聲明方法或類,被聲明為final的方法或類不能被繼承

一般C里是const java用final

F. java判斷題1​．在Java的方法中定義一個常量要用const關鍵字。

1. 錯誤。在java中定義常量用final。
2. 錯誤。抽象類中必須要有抽象方法，但是同時也可以有非抽象方法。
3. 正確。
4. 正確。
5. 正確。
6. 錯誤。是單繼承。一個類最多隻能夠有一個基類，用extends實現。
7. 錯誤。Final是最終類，不能再派生。
8. 正確。
9. 錯誤。
10. 正確。
11. 錯誤。
12. 正確。
13. 正確。
14. 錯誤。可以有方法體。
15. 錯誤。不是子類和父類之間吧。
16. 正確。
17. 錯誤。不可以，是單繼承。
18. 正確。
19. 正確。
20. 錯誤。
21. 正確。
22. 正確。
23. 錯誤。只是為了說明他不可派生。
24. 錯誤。
25. 錯誤。Java程序也可以是applet程序，如果是applet，不用main方法。。。由init初始化，start啟用。
26. 正確。
27. 錯誤。
28. 錯誤。可以被繼承，但是不能被訪問。
29. 正確。
30. 正確。
31. 錯誤。
32. 正確。
33. 正確。
34. 錯誤。方法體中的變數只在方法中有效，而且和位置有關。
35. 錯誤。
36. 正確。
37. 正確。
38. 正確。
39. 錯誤。和20題一樣
40. 正確。

G. JAVA語言中有C++中的 const 語句么

Java沒有const，常量用final表示

Java里的方法(method)，跟C++里的函數(function)是對應的，二沖耐者都有對象

final修飾變數和參數，都將對其無法修改

修飾方法，指其無法被子類方法覆蓋

修飾類渣氏，如判散則此類無法被繼承

H. JAVA中的final等於C++中的const

並不完全等於，但是用於聲明一個常數的時候 java 中用 final，C++ 中用 const。
final 除了用於聲明常數，還可作為方法前綴，表示某個方法不能被其子類繼承。

I. java const

java const是什麼， 讓我們一起來了解一下：

const是java中的預留關鍵字（java中預留關鍵字還有goto），const修飾的旅稿數據類型是指常類型，常類型的變數或對象的值是不能被更新的。也可以定義const常量，具有不可變性。

const的幾種常見用法？

1、用於定義常量變數，這樣這個變數在後面就不可以再被修改。
const int Val = 10;  //Val = 20; //錯誤,不可被修改

2、保護傳遞參數時參數不被修改，如果使用引用傳遞參數或按地址傳遞參數給一個函數，在這個函數里這個參數的值若被修改，則函數外部傳進來的變數的值也發生改變，若想保護傳進來的變數不被修改，可以使用const保護。
 void  fun1(const int &val)   {      //val = 10; //出錯 } void fun2(int &val) {    val = 10; //沒有出錯 } void main() {    int a = 2;    int b = 2;    fun1(a); //因為出錯,這個函數結束時a的值還是2    fun2(b);//因為沒有出錯,函數結束時b的值為10 }
3、類中使用const修飾函數防止修改非static類成員氏鎮旅變數。
class {  public:   void fun() const //加const修飾    {      a = 10; //出錯,不可修改非static變數      b = 10; //對,可以修改 }  private:   int  a ;   static int b; }
 拓展殲凳一下：

const是java中的預留關鍵字（java中預留關鍵字還有goto），現在沒有作為關鍵字，以後的版本中可能擴展用，但現在常用於C，C++中。C中的const類似於final。

J. const是java關鍵字嗎

const是java關鍵字嗎？

是保留關鍵字，沒有具體含義。const關鍵字最早是在javascript中作為ECMAScript 6標準的一部分於2015年引入的。它可能是在javascript中聲明變數的最流行的方法，但是javascript在它們之前又是如何呢？

const是在2015年作為ES6標準的一部分引入的，const值像let一樣是塊范圍的，但用於定義常量值（obv）。它是恆定的事實並不意味著它是不變的。 這是一個常見的誤解，但是any const object can change its properties ，例如any const array can change its data 。 

讓我向您展示一些示例：
//const object example //declare a const object with id and msg const a={ id:5， msg:"Hello!" //change property of constant object a.msg ="Hi!";//c changes it's value//reasign constant object a = { msg : "new object!" }; //TypeError: Assignment to constant variable.

//const array example//declare const array const arr =["Hello","Constant"凱蘆猛 ];//push new element to array arr.push("works"); //push new element-ok  //change first element in array arr[0]="Hi!"; //change first element-ok  //reasign to new array arr =["New」，"Array" ]; //change reference- TypeError: Assignment to constant variable.

//primitive const value//declare consatnt string const message="Constant string"; message ="嘩敬New constant string"; //change value- TypeError: Assignment to constant variable.
綜上所述： const創建盯橋一個指向值的不可變指針，但其自身的值仍然可變。 如果要創建一個完全不變的值，則應使用Object.freeze（）。