constantjava

❶ java中constant是幹嘛用的

你進入constant這個類看看就知道了，裡面都是一些項目中常用的常量，比如：用戶名、密碼、許可權什麼的。

❷ java的Util.formatDateTime和Constant為什麼有錯誤，很多包我不知道該引入哪一個

因為不同包中的類雖然同名但類結構不同，如果你導錯包了，你的Java代碼要麼報錯，要麼達不到預期目的。最好導包之前先查一下API，了解清楚同名類的區別再用。

❸ 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成員函數，編譯器將指出錯誤，這無疑會提高程序的健壯性。

❹ java中什麼是靜態變數，什麼是常量

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

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

❺ 網上書店查詢書籍功能，定義這個 Constant.java 是什麼用處的，

- -!!
類別：靜態類
BY_AUTHOR BY_ISBN BY_KEYWORD分別是裡面的成員
功能：實體類
用於保存從資料庫取出的數值 也就是後面注釋寫的 作者 書 和關鍵字
有了這個類以後 相當於多了一道工序 以前是直接從資料庫查 現在查了一次
之後 保存在實體類中 以後直接調用實體類的數據

也就是實現了 我們所說的三層架構模式

❻ java 為什麼使用constant類

constant 用來修飾變數,使變數的值一旦確定不能修改。 再細點說,就是基本類型的變數賦值後不能改變其值,對象變數賦值後不能更改對象引用值

❼ Java里constant是干什麼的

constant 用來修飾變數，使變數的值一旦確定不能修改。

再細點說，就是基本類型的變數賦值後不能改變其值，對象變數賦值後不能更改對象引用值

❽ java中常見的異常類

從異常類的繼承架構圖中可以看出：Exception 類擴展出數個子類，其中 IOException、RunntimeException 是較常用的兩種。

習慣上將 Error 與 Exception 類統稱為異常類，但這兩者本質上還是有不同的。Error 類專門用來處理嚴重影響程序運行的錯誤，可是通常程序設計者不會設計程序代碼去捕捉這種錯誤，其原因在於即使捕捉到它，也無法給予適當的處理，如 JAVA 虛擬機出錯就屬於一種 Error。

不同於 Error 類，Exception 類包含了一般性的異常，這些異常通常在捕捉到之後便可做妥善的處理，以確保程序繼續運行，如 TestException7_2 里所捕捉到的 就是屬於這種異常。

RunntimeException 即使不編寫異常處理的程序代碼，依然可以編譯成功，而這種異常必須是在程序運行時才有可能發生，例如：數組的索引值超出了范圍。

與RunntimeException 不同的是，IOException 一定要編寫異常處理的程序代碼才行，它通常用來處理與輸入/輸出相關的操作，如文件的訪問、網路的連接等。

當異常發生時，發生異常的語句代碼會拋出一個異常類的實例化對象，之後此對象與 catch 語句中的類的類型進行匹配，然後在相應的 catch 中進行處理。

(8)constantjava擴展閱讀：

Java異常的分類：

Java標准褲內建了一些通用的異常，這些類以Throwable為頂層父類。

Throwable又派生出Error類和Exception類。

錯誤：Error類以及他的子類的實例，代表了JVM本身的錯誤。錯誤不能被程序員通過代碼處理，Error很少出現。因此，程序員應該關注Exception為父類的分支下的各種異常類。

異常：Exception以及他的子類，代表程序運行時發送的各種不期望發生的事件。可以被Java異常處理機制使用，是異常處理的核心。

參考資料：網路-異常

❾ Java中調用常量

以上該類常量是該類對象的屬性是不對的，屬性只有在定義封裝後set和get方法才出現的。只能說是該對象的成員欄位。

❿ 在Java中,可以用關鍵字constant來聲明一個常量嗎

java中，聲明常量用 static