2012年6月14日
#
摘要: 轉載：http://www.tkk7.com/qcyycom/archive/2013/07/11/401467.htmlSpring MVC 3 深入總結
一、前言：
大家好，Spring3 MVC是非常優秀的MVC框架，由其是在3.0版本發布后，現在有越來越多的團隊選擇了Spring3 MVC了。Spring3 MVC結構簡單，應了那句話簡單就是美，而且他強大不失靈活，性能...
閱讀全文
1.delete from 表名 where ID in (select id from 表名 group by id having count(id) >1)
and rowid not in (select min(rowid) from 表名 group by id having count(id )>1)
使用POI對excel表數據進行操作時出現了該問題，從數據庫導出數據到excel表中，datetime類型的數據以String類型存儲，當對表內的該列數據做修改后，excel將自動修改單元格的格式，從而導致在重新讀取時出現了以上錯誤。
解決辦法：
判斷讀取的單元格是否為HSSFCell.CELL_TYPE_NUMERIC類型，然后利用cell.getNumericCellValue()，讀取該單元格的數據。
getNumericCellValue()讀出的數據類型是double型，
因此，需要重新進行數據轉換：HSSFDateUtil.getJavaDate(d).toLocaleString()。其中d為讀出的double類型數據。
至此，則成功的將excel表內的數據讀取出來。
單元格的格式總共有以下幾種：
HSSFCell.CELL_TYPE_BLANK;
HSSFCell.CELL_TYPE_BOOLEAN;
HSSFCell.CELL_TYPE_ERROR;
HSSFCell.CELL_TYPE_FORMULA;
HSSFCell.CELL_TYPE_NUMERIC;
HSSFCell.CELL_TYPE_STRING;
轉載：
http://www.tkk7.com/zhanghu198901/archive/2012/08/12/385337.html
PS：在所有例子中正則表達式匹配結果包含在源文本中的【和】之間，有的例子會使用java來實現，如果是java本身正則表達式的用法，會在相應的地方說明。所有java例子都在JDK1.6.0_13下測試通過。
一、有多少個匹配
前面幾篇講的都是匹配一個字符，但是一個字符或字符集合要匹配多次，應該怎么做呢？比如要匹配一個電子郵件地址，用之前說到的方法，可能有人會寫出像\w@\w\.\w這樣的正則表達式，但這個只能匹配到像a@b.c這樣的地址，明顯是不正確的，接下來就來看看如何匹配電子郵件地址。
首先要知道電子郵件地址的組成：以字母數字或下劃線開頭的一組字符，后面跟@符號，再后面是域名，即用戶名@域名地址。不過這也跟具體的郵箱服務提供商有關，有的在用戶名中也允許.字符。
1、匹配一個或多個字符
要想匹配同一個字符（或字符集合）的多次重復，只要簡單地給這個字符（或字符集合）加上一個+字符作為后綴就可以了。+匹配一個或多個字符（至少一個）。如：a匹配a本身，a+將匹配一個或多個連續出現的a；[0-9]+匹配多個連續的數字。
注意：在給一個字符集合加上+后綴的時候，必須把+放在字符集合的外面，否則就不是重復匹配了。如[0-9+]這樣就表示數字或+號了，雖然語法上正確，但不是我們想要的了。
文本：Hello, mhmyqn@qq.com or mhmyqn@126.com is my email.
正則表達式：\w+@(\w+\.)+\w+
結果：Hello, 【mhmyqn@qq.com】 or 【mhmyqn@126.com】 is my email.
分析：\w+可以匹配一個或多個字符，而子表達式(\w+\.)+可匹配像xxxx.edu.這樣的字符串，而最后不會是.字符結尾，所以后面還會有一個\w+。像mhmyqn@xxxx.edu.cn這樣的郵件地址也會匹配到。
2、匹配零個或多個字符
匹配零個或多個字符使用元符*，它的用法和+完全一樣，只要把它放在一下字符或字符集合的后面，就可以匹配該字符（或字符集合）連續出現零次或多次。如正則表達式ab*c可以匹配ac、abc、abbbbbc等。
3、匹配零個或一個字符
匹配零個或一個字符使用元字符?。像上一篇說到的匹配一個空白行使用正則表達式\r\n\r\n，但在Unix和Linux中不需要\r，就可以使用元字符?，\r?\n\r?\n這樣既可匹配windows中的空白行，也可匹配Unix和Linux中的空白行。下面來看一個匹配http或https協議的URL的例子：
文本：The URL is http://www.mikan.com, to connect securely use https://www.mikan.cominstead.
正則表達式：https?://(\w+\.)+\w+
結果：The URL is 【http://www.mikan.com】, to connect securely use 【https://www.mikan.com】 instead.
分析：這個模式以https?開頭，表示?之前的一個字符可以有，也可以沒有，所以它能匹配http或https，后面部分和前一個例子一樣。
二、匹配的重復次數
正則表達式里的+、*和?解決了很多問題，但是：
1）+和*匹配的字符個數沒有上限。我們無法為它們將匹配的字符個數設定一個最大值。
2）+、*和?至少匹配一個或零個字符。我們無法為它們將匹配的字符個數另行設定一個最小值。
3）如果只使用*和+，我們無法把它們將匹配的字符個數設定為一個精確的數字。
正則表達式里提供了一個用來設定重復次數的語法，重復次數要用{和}字符來給出，把數值寫在它們中間。
1、為重復匹配次數設定一個精確值
如果想為重復匹配次數設定一個精確的值，把那個數字寫在{和}之間即可。如{4}表示它前面的那個字符（或字符集合）必須在原始文本中連續重復出現4次才算是一個匹配，如果只出現了3次，也不算是一個匹配。
如前面幾篇中說到的匹配頁面中顏色的例子，就可以用重復次數來匹配：#[[:xdigit:]]{6}或#[0-9a-fA-F]{6}，POSIX字符在java中是#\\p{XDigit}{6}。
2、為重復匹配次數設定一個區間
{}語法還可以用來為重復匹配次數設定一個區間，也就是為重復匹配次數設定一個最小值和最大值。這種區間必須以{n, m}這樣的形式給出，其中n>=m>=0。如檢查日期格式是否正確（不檢查日期的有效性）的正則表達式（如日期2012-08-12或2012-8-12）：\d{4}-\d{1,2}-\d{1,2}。
3、匹配至少重復多少次
{}語法的最后一種用法是給出一個最小的重復次數（但不必給出最大重復次數），如{3,}表示至少重復3次。注意：{3,}中一定要有逗號，而且逗號后不能有空格。否則會出錯。
來看一個例子，使用正則表達式把所有金額大于$100的金額找出來：
文本：
$25.36
$125.36
$205.0
$2500.44
$44.30
正則表達式：$\d{3,}\.\d{2}
結果：
$25.36
【$125.36】
【$205.0】
【$2500.44】
$44.30
+、*、?可以表示成重復次數：
+等價于{1,}
*等價于{0,}
?等價于{0,1}
三、防止過度匹配
?只能匹配零個或一個字符，{n}和{n,m}也有匹配重復次數的上限，但是像*、+、{n,}都沒有上限值，這樣有時會導致過度匹配的現象。
來看匹配一個html標簽的例子
文本：
Yesterday is <b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>.
正則表達式：<[Bb]>.*</[Bb]>
結果：
Yesterday is 【<b>history</b>,tomorrow is a <B>mystery</B>, but today is a <b>gift</b>】.
分析：<[Bb]>匹配<b>標簽（不區分大小寫），</[Bb]>匹配</b>標簽（不區分大小寫）。但結果卻不是預期的那樣有三個，第一個</b>標簽之后，一直到最后一個</b>之間的東西全部匹配出來了。
為什么會這樣呢？因為*和+都是貪婪型的元字符，它們在匹配時的行為模式是多多益善，它們會盡可能從一段文本的開頭一直匹配到這段文本的末尾，而不是從這段文本的開頭匹配到碰到第一個匹配時為止。
當不需要這種貪婪行為時，可以使用這些元字符的懶惰型版本。懶惰意思是匹配盡可能少的字符，與貪婪型相反。懶惰型元字符只需要給貪婪型元字符加上一個?后綴即可。下面是貪婪型元字符的對應懶惰型版本：
* *?
+ +?
{n,} {n,}?
所以上面的例子中，正則表達式只需要改成<[Bb]>.*?</[Bb]>即可，結果如下：
<b>history</b>
<B>mystery</B>
<b>gift</b>
四、總結
正則表達式的真下威力體現在重復次數匹配方面。這里介紹了+、*、?幾種元字符的用法，如果要精確的確定匹配次數，使用{}。元字符分貪婪型和懶惰型兩種，在需要防止過度匹配的場合下，請使用懶惰型元字符來構造正則表達式
轉載：http://www.tkk7.com/zhanghu198901/archive/2012/08/12/385337.html
PS：在所有例子中正則表達式匹配結果包含在源文本中的【和】之間，有的例子會使用java來實現，如果是java本身正則表達式的用法，會在相應的地方說明。所有java例子都在JDK1.6.0_13下測試通過。
一、對特殊字符進行轉義
元字符是一些在正則表達式里有著特殊含義的字符。因為元字符在正則表達式里有著特殊的含義，所以這些字符就無法用來代表它們本身。在元字符前面加上一個反斜杠就可以對它進行轉義，這樣得到的轉義序列將匹配那個字符本身而不是它特殊的元字符含義。如，如果想要匹配[和]，就必須對它進行轉義：\[和\]。
對元字符轉義需要用到斜杠\字符，這就意味著\字符本向也是一個元字符，要匹配\字符本身，必須轉義成\\。如匹配windows文件路徑。
二、匹配空白字符
元字符大致可以分為兩種：一種是用來匹配文本的（如.），另一種是正則表達式的語法所要求的（如[和]）。
在進行正則表達式搜索的時候，我們經常會遇到需要對原始文本中里的非打印空白字符進行匹配的情況。比如說，我們可能需要把所有的制表符找出來，或者我們需要把換行符找出來，這類字符很難被直接輸入到一個正則表達式里，這時我們可以使用如下列出的特殊元字符來輸入它們：
\b 回退（并刪除）一個字符（Backspace鍵）
\f 換頁符
\n 換行符
\r 回車符
\t 制表符（Tab鍵）
\v 垂直制表符
來看一個例子，把文件中的空白行去掉：
文本：
8 5 4 1 6 3 2 7 9
7 6 2 9 5 8 3 4 1
9 3 1 4 2 7 8 5 6
6 9 3 8 7 5 1 2 4
5 1 8 3 4 2 6 9 7
2 4 7 6 1 9 5 3 8
3 26 7 8 4 9 1 5
4 8 9 5 3 1 7 6 2
1 7 5 2 9 6 4 8 3
正則表達式：\r\n\r\n
分析：\r\n匹配一個回車+換行組合，windows操作系統中把它作為文本行的結束標簽。使用正則表達式\r\n\r\n進行的搜索將匹配兩個連續的行尾標簽，而這正好是空白行。
注意：Unix和Linux操作系統中只使用一個換行符來結束一個文本行，換句話說，在Unix或Linux系統中匹配空白行只使用\n\n即可，不需要加上\r。同時適用于windows和Unix/Linux的正則表達式應該包括一個可先的\r和一個必須匹配的\n，即\r?\n\r?\n，這將會在后面的文章中講到。
Java代碼如下：
public static void matchBlankLine() throws Exception{
BufferedReader br = new BufferedReader(new FileReader(new File("E:/九宮格.txt")));
StringBuilder sb = new StringBuilder();
char[] cbuf = new char[1024];
int len = 0;
while(br.ready() && (len = br.read(cbuf)) > 0){
br.read(cbuf);
sb.append(cbuf, 0, len);
}
String reg = "\r\n\r\n";
System.out.println("原內容：\n" + sb.toString());
System.out.println("處理后：-----------------------------");
System.out.println(sb.toString().replaceAll(reg, "\r\n"));
}
運行結果如下：
原內容：
8 5 4 1 6 3 2 7 9
7 6 2 9 5 8 3 4 1
9 3 1 4 2 7 8 5 6
6 9 3 8 7 5 1 2 4
5 1 8 3 4 2 6 9 7
2 4 7 6 1 9 5 3 8
3 2 6 7 8 4 9 1 5
4 8 9 5 3 1 7 6 2
1 7 5 2 9 6 4 8 3
處理后：-----------------------------
8 5 4 1 6 3 2 7 9
7 6 2 9 5 8 3 4 1
9 3 1 4 2 7 8 5 6
6 9 3 8 7 5 1 2 4
5 1 8 3 4 2 6 9 7
2 4 7 6 1 9 5 3 8
3 2 6 7 8 4 9 1 5
4 8 9 5 3 1 7 6 2
1 7 5 2 9 6 4 8 3
三、匹配特定的字符類別
字符集合（匹配多個字符中的某一個）是最常見的匹配形式，而一些常用的字符集合可以用特殊元字符來代替。這些元字符匹配的是某一類別的字符（類元字符），類元字符并不是必不可少的，因為可以通過逐一列舉有關字符或通過定義一個字符區間來匹配某一類字符，但是使用它們構造出來的正則表達式簡明易懂，在實際應用中很常用。
1、匹配數字與非數字
\d 任何一個數字，等價于[0-9]或[0123456789]
\D 任何一個非數字，等價于[^0-9]或[^0123456789]
2、匹配字母和數字與非字母和數字
字母（A-Z不區分大小寫）、數字、下劃線是一種常用的字符集合，可用如下類元字符：
\w 任何一個字母（不區分大小寫）、數字、下劃線，等價于[0-9a-zA-Z_]
\W 任何一個非字母數字和下劃線，等價于[^0-9a-zA-Z_]
3、匹配空白字符與非空白字符
\s 任何一下空白字符，等價于[\f\n\r\t\v]
\S 任何一下空白字符，等價于[^\f\n\r\t\v]
注意：退格元字符\b沒有不在\s的范圍之內。
4、匹配十六進制或八進制數值
十六進制：用前綴\x來給出，如：\x0A對應于ASCII字符10（換行符），其效果等價于\n。
八進制：用前綴\0來給出，數值本身可以是兩位或三位數字，如：\011對應于ASCII字符9（制表符），其效果等價于\t。
四、使用POSIX字符類
POSIX字符類是很多正則表達式實現都支持的一種簡寫形式。Java也支持它，但JavaScript不支持。POSIX字符如下所示：
[:alnum:] 任何一個字母或數字，等價于[a-zA-Z0-9]
[:alpha:] 任何一個字母，等價于[a-zA-Z]
[:blank:] 空格或制表符，等價于[\t]
[:cntrl:] ASCII控制字符（ASCII 0到31，再加上ASCII 127）
[:digit:] 任何一個數字，等價于[0-9]
[:graph:] 任何一個可打印字符，但不包括空格
[:lower:] 任何一個小寫字母，等價于[a-z]
[:print:] 任何一個可打印字符
[:punct:] 既不屬于[:alnum:]和[:cntrl:]的任何一個字符
[:space:] 任何一個空白字符，包括空格，等價于[^\f\n\r\t\v]
[:upper:] 任何一個大寫字母，等價于[A-Z]
[:xdigit:] 任何一個十六進制數字，等價于[a-fA-F0-9]
POSIX字符和之前見過的元字符不太一樣，我們來看一個前面利用正則表達式來匹配網頁中的顏色的例子：
文本：<span style="background-color:#3636FF;height:30px;width:60px;">測試</span>
正則表達式：#[[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]] [[:xdigit:]]
結果：<span style="background-color:【#3636FF】;height:30px;width:60px;">測試</span>
注意：這里使用的模式以[[開頭、以]]結束，這是使用POSIX字符類所必須的，POSIX字符必須括在[:和:]之間，外層[和]字符用來定義一個集合，內層的[和]字符是POSIX字符類本身的組成部分。
在java中的POSIX字符表示有所不同，不是包括在[:和:]之間，而是以\p開頭，包括在{和}之間，且大小寫有區別，同時增加了\p{ASCII}，如下所示：
\p{Alnum} 字母數字字符：[\p{Alpha}\p{Digit}]
\p{Alpha} 字母字符：[\p{Lower}\p{Upper}]
\p{ASCII} 所有 ASCII：[\x00-\x7F]
\p{Blank} 空格或制表符：[ \t]
\p{Cntrl} 控制字符：[\x00-\x1F\x7F]
\p{Digit} 十進制數字：[0-9]
\p{Graph} 可見字符：[\p{Alnum}\p{Punct}]
\p{Lower} 小寫字母字符：[a-z]
\p{Print} 可打印字符：[\p{Graph}\x20]
\p{Punct} 標點符號：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
\p{Space} 空白字符：[ \t\n\x0B\f\r]
\p{Upper} 大寫字母字符：[A-Z]
\p{XDigit} 十六進制數字：[0-9a-fA-F]
一、final
根據程序上下文環境，Java關鍵字final有“這是無法改變的”或者“終態的”含義，它可以修飾非抽象類、非抽象類成員方法和變量。你可能出于兩種理解而需要阻止改變：設計或效率。
final類不能被繼承，沒有子類，final類中的方法默認是final的。
final方法不能被子類的方法覆蓋，但可以被繼承。
final成員變量表示常量，只能被賦值一次，賦值后值不再改變。
final不能用于修飾構造方法。
注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。
1、final類
final類不能被繼承，因此final類的成員方法沒有機會被覆蓋，默認都是final的。在設計類時候，如果這個類不需要有子類，類的實現細節不允許改變，并且確信這個類不會載被擴展，那么就設計為final類。
2、final方法
如果一個類不允許其子類覆蓋某個方法，則可以把這個方法聲明為final方法。
使用final方法的原因有二：
第一、把方法鎖定，防止任何繼承類修改它的意義和實現。
第二、高效。編譯器在遇到調用final方法時候會轉入內嵌機制，大大提高執行效率。
例如：
public class Test1 {
public static void main(String[] args) {
// TODO 自動生成方法存根
}
public void f1() {
System.out.println("f1");
}
//無法被子類覆蓋的方法
public final void f2() {
System.out.println("f2");
}
public void f3() {
System.out.println("f3");
}
private void f4() {
System.out.println("f4");
}
}
public class Test2 extends Test1 {
public void f1(){
System.out.println("Test1父類方法f1被覆蓋!");
}
public static void main(String[] args) {
Test2 t=new Test2();
t.f1();
t.f2(); //調用從父類繼承過來的final方法
t.f3(); //調用從父類繼承過來的方法
//t.f4(); //調用失敗，無法從父類繼承獲得
}
} |
3、final變量（常量）
用final修飾的成員變量表示常量，值一旦給定就無法改變！
final修飾的變量有三種：靜態變量、實例變量和局部變量，分別表示三種類型的常量。
從下面的例子中可以看出，一旦給final變量初值后，值就不能再改變了。
另外，final變量定義的時候，可以先聲明，而不給初值，這中變量也稱為final空白，無論什么情況，編譯器都確保空白final在使用之前必須被初始化。但是，final空白在final關鍵字final的使用上提供了更大的靈活性，為此，一個類中的final數據成員就可以實現依對象而有所不同，卻有保持其恒定不變的特征。
package org.leizhimin;
public class Test3 {
private final String S="final實例變量S";
private final int A=100;
public final int B=90;
public static final int C=80;
private static final int D=70;
public final int E; //final空白,必須在初始化對象的時候賦初值
public Test3(int x){
E=x;
}
/**
* @param args
*/
public static void main(String[] args) {
Test3 t=new Test3(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);
Test3 t1=new Test3(3);
System.out.println(t1.E); //final空白變量E依據對象的不同而不同
}
private void test(){
System.out.println(new Test3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
public void test2(){
final int a; //final空白,在需要的時候才賦值
final int b=4; //局部常量--final用于局部變量的情形
final int c; //final空白,一直沒有給賦值.
a=3;
//a=4; 出錯,已經給賦過值了.
//b=2; 出錯,已經給賦過值了.
}
} |
4、final參數
當函數參數為final類型時，你可以讀取使用該參數，但是無法改變該參數的值。
public class Test4 {
public static void main(String[] args) {
new Test4().f1(2);
}
public void f1(final int i){
//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將按照它們在類中出現的先后順序依次執行它們，每個代碼塊只會被執行一次。例如：
public class Test5 {
private static int a;
private int b;
static{
Test5.a=3;
System.out.println(a);
Test5 t=new Test5();
t.f();
t.b=1000;
System.out.println(t.b);
}
static{
Test5.a=4;
System.out.println(a);
}
public static void main(String[] args) {
// TODO 自動生成方法存根
}
static{
Test5.a=5;
System.out.println(a);
}
public void f(){
System.out.println("hhahhahah");
}
} |
運行結果：
3
hhahhahah
1000
4
5
利用靜態代碼塊可以對一些static變量進行賦值，最后再看一眼這些例子，都一個static的main方法，這樣JVM在運行main方法的時候可以直接調用而不用創建實例。
4、static和final一塊用表示什么 static final用來修飾成員變量和成員方法，可簡單理解為“全局常量”！
對于變量，表示一旦給值就不可修改，并且通過類名可以訪問。
對于方法，表示不可覆蓋，并且可以通過類名直接訪問。