鄭志遠的 java學習筆記

2019-11-18 15:25:23

字體：大中小

來源：轉載

供稿：網友

　　鄭志遠的java學習筆記

1 Java起源
2 Java語言概述

1．面向對象編程的3個原則：封裝(encapsulation)、繼續(inheritance)、多態性(polymorephism)
封裝：將代碼及其處理的數據捆綁在一起的一種機制；
繼續：一個對象獲得另一個對象的屬性的過程；
多態性：一個接口，多種方法。

2．System.out.PRintln(“dfjdfjdf”);
System.out.print(“dfdfdfdf”);
這兩種寫法輸出基本一樣，只是print不換行

3．基本詞匯：空白分隔符（whitespace）標識符（identifiers）常量（literal）注釋（comments）分隔符（separators）java要害字 java類庫
3 數據類型、變量、數組
1．Java語言是強類型語言，java定義了8個簡單數據類型：byte short int long char float double Boolean

2．假如一個數據類型占8位那么他的范圍為-（2的7次方）到2的7次方-1，一共2的8次方個數字（別忘記0），其中最高為作為符號位，是1就為負值。
其中：（2的8次方-1）等于2的0次方+2的1次方+……+2的7次方
所以ip地址中若地址為00000000則代表可以有256個地址，0次方+2的1次方+……+2的7次方=255，但是別忘記0 ！！！

3．標準的ASCII字符集的范圍為0~127（共2的7次方個，因為最高位沒用），擴展的ASCII字符集范圍為0~255（共2的8次方個）
UNICODE字符集占16位，范圍為：0~65535（共2的16次方個）

4． System.out.println(“The value is”+ (10>9)); 結果為true,10>9加括號，因為+的優先級大于”>”
System.out.println(“10>9”); 結果為10>9

5．Octal------8進制，前面加0表示
Hexadecimal------16進制，前面加0x 或0X表示
6．Java中的浮點字面量默認是雙精度的，占64位
1234．333f(orF)---------float
1234．343434d(or D)-------double
所以：float m=20.3將編譯出錯，應該寫為float m=(float)20.3

7．自動類型轉換：
滿足以下兩個條件：這2種類型是兼容的；目的類型的范圍比源類型的范圍大

強制類型轉換：
2種不兼容類型之間的轉換，格式為：(target-type) value,例如：將整形轉為字節型，若整形的值超出byte的取值范圍，則轉化后的值為對256取摸。Byte b; int i=300; b=(byte)i; 則b的值為44。
例如：將323.234強制轉為byte的步驟：去掉小數點后的數為323，在執行323%256得到67。

8．自動類型提升，用在表達式中，byte和short自動提升為int型
例如：
byte b=50;
b=b*2;//編譯將出錯！因為b*2為整形
應該寫為
b=(byte)(b*2)//括號的優先級大于*，所以b*2要加括號
又例如：
short mm=(short)0x8000;//此處的(short)也必須寫，否則編譯出錯！！！

9．數組，聲明格式：
int array[]=new int[3];
或者
int array[];
array=new int[3];

//初始化
array[0]=1;
array[1]=2;
array[2]=3;
或者
int array[]={1,2,3};//此時自動分配內存，而不用new操作符
注重：[]之內不可寫進長度，否則編譯出錯！！！
另外Java進行數組越界檢查，而C/C++沒有

多維數組：
int Dshuzu[][]=new int[2][3];
初始化
Dshuzu[0][0]=1;……………
或者 int Dshuzu[][]={
{12,13,14},
{20,21,22}
};//[]之內不可寫進長度，否則編譯出錯！！！
可以先個第一維分配內存，第二維手工分配內存。例如：
int Dshuzu[][]=new int[3][];
Dshuzu[0]=new int[1];
Dshuzu[1]=new int[2];
Dshuzu[2]=new int[3];
第二維的大小不相等，圖例：
Dshuzu[0][0]
Dshuzu[1][0] Dshuzu[1][1]
Dshuzu[2][0] Dshuzu[2][1] Dshuzu[2][2]

另外的數組聲明方法：
int[] mm = new int[12];
int[][] nn = new int[3][4];
在java中數組是作為對象來使用的。數組有一個實例變量length，存儲的是數組能夠包含的元素的個數。
例如：
char arr[]=new char [10];//不論字符數組，還是整形數組，元素個數最多為10個，下標從0-9
arr.length;//他的值為10
int arr1[20]={1,3,4,5};
arr1.length//他的值為20
char str[][]=new char[2][3]//此二維數組的length為2。即第一維的長度
10．Java中方法內部聲明的變量必須賦初值，雖然它有自己的默認值。例如：
int i;
system.out.println(i);//編譯將出錯，提示i沒有初始化,解決：int i=0;
但是實例變量不存在這種情況。
4 運算符
四大運算符：算術運算符、位運算、關系運算、邏輯運算
另外還有比較運算符(instanceof)

4． 1算術運算符號

算術運算符不能用在boolean上，但是可以用在char上，因為在Java中char 類型是int 類型的一個子集。

對整數進行“/”運算，余數將被舍去。例如：int i=6/4;結果為1。

%運算符也可以用在浮點數（C/C++中不答應）例如：
42．25%10的結果為2.25

注重遞增遞減運算 ++m和m++的區別
++m 的值和m保持同步，而m++的值比m小1。例如int m=0;
++m;//則m的值為1，++m表達式的值也為1
m++;//則m的值為1，m++表達式的值為0
有一個例子：
int i=100;int j=200;
while(++i< --j);//空循環體，i大于或等于j則循環結束
system.out.println(“:i is “ + i);//求出i和j的中間值150

算術賦值運算例如：a+=4;等價于a=a+4;

4．2位運算符（bitwise Operators）

直接對整數類型的位進行操作，包括：byte short int long char 。

理解反碼、補碼。負數的2進制表示是：將原碼做反碼后加1。

整型都是有符號的，（除了char）,所以用他們的最高位來表示符號位。

注重：對byte和short 移位運算時（不論左移還是右移），byte和short 都先被自動提升到int型。再執行移位運算。假如byte和short為負數的時候，也就是說符號位也要擴展，高位全部用1填充，隨后再做移位！
例如：
byte b=01000000;
int i;
i=b<<2;
//結果為256，2進制為00000000 00000000 00000001 00000000
b=(byte)(b<<2);//結果為0,byte只有8位，高位被截斷

例如： byte b=11111111;//十進制為-1
b=(byte)(b<<2);
//變為11111111 11111111 11111111 11111100,10進制為-4
b=(byte)(b>>2);
//變為11111111 11111111 11111111 11111111，10進制為-1
b=(byte)(b>>>2);
//變為00111111 11111111 11111111 11111111，b還是-1，因為b先被擴展為int型

注重：左移（<<）時，假如將1移進高位（31或63）那么值就變為負的。
高位移出，低位補0

右移運算(>>)：低位移出，高位填充原來高位的值。
無符號右移（>>>）：低位移出，高位用0填充。

注重：因為short 和byte 總被擴展到32位，所以符號位擴展和移動總是發生在32和64位。

把握位賦值運算符，例如：a=a>>4;等價于 a>>=4;
a^=b; 等價于a=a^b;

4．3關系運算符
== > < <= >= !=
關系運算的結果為boolean,只有true和false，不像C/C++中，非0為true，0為false。
boolean flag= a<c;//這種寫法是正確的

4．4布爾邏輯運算符

布爾邏輯運算的運算數只能是布爾型，結果也為boolean型
注重：
標準的邏輯與(&)和邏輯或()不論第一個表達式為true or false，都計算第二個表達式。例如：
if (c==0 e++ < 100) d=12;//不論c是否等于0，e都被自增量。

短路AND(&&)和短路OR()：
A&&B,當A為false時，不去計算B的值而直接返回false;當A為true時，計算B的值。

AB，當A為true時，不去計算B的值而直接返回true; 當A為false時，計算B的值。

4．5賦值運算符（=）

int x,y,z;
x=y=z=100;//答應對一連串的變量賦值

4．6 ？運算符

三元運算符（ternary），經常用于取代if- else語句。格式：
eXPression1?expression2:expression3
//expression1是一個布爾表達式, expression2和expression3是除了void類型以外的任何類型的表達式，并且它們的類型必須相同。
例如：
rado=denom==0?0:num/denom;
//假如denom等于0則？表達式的值為0，否則為num/denom。最后將？表達式的值賦給rado

4．7運算符的優先級

把握運算符的優先級。適當的運用（）可以提高程序的可讀性，澄清含義，而不至于降低程序的運行速度。
5 程序控制語句
Java程序控制語句分為：選擇(selection)、重復(iteration)、跳轉(jump)

5．1 Java的選擇語句
Java支持2種選擇語句：If語句和Switch語句。

5．1．1 if 條件分支語句
If (condition)//condition只能是布爾型
Statement;
Else if (condition)
Statement;
Else if (condition)
Statement;
……………
Else
Statement;
5．1．2switch多路分支語句

switch(expression) {
case value1:
statement;
break;
case value2:
statement;
break;
…………….
default:
statement;
}
//其中expression必須為byte,short,int 或者char 類型，每個case之后的value必須是與表達式類型兼容的一個常量
break用于跳出整個switch語句。假如省略break，則每個語句都被遍歷，符合條件就被執行，直到switch末尾或者碰到break為止。
例如：
switch(expression) {
case value1:
case value2:
case value3:
statement;
break;
case value4:
case value5:
statement;
break;
…………….
default:
statement;
}
注重：switch 語句只能測試相等的情況，而if可計算任何類型的布爾表達式。
同一個switch語句中沒有兩個相同的case常量，嵌套switch的外部case常量和內部case常量除外。
Switch 語句通常比if語句更有效。

5．2循環語句

包括：while do while for
5．2．1 while循環
格式： while(condition) {
//body of loop
} //condition為布爾表達式
空循環在Java中是合法的。
空語句是只有一個分號（；）的語句。例如；
int i=100;int j=200;
while(++i < --j) //++i的值和i同步
; //;可以和while語句連一塊為while(++i< --j);
system.out.println(“i=” + i);
當然上面的例子可以寫為：
int i=100;int j=200;
while (i<j){
i++;j--;
}
System.out.println("i=" + i);

5．2．2 do-while循環
格式： do {
//body of loop
} while (condition);//不要漏掉；

循環至少被執行一次。
例子：
int n=10;
do {
system.out.println(“n=” + n);
n--;
} while (n>0);
可以寫為以下，更為高效。
int n=10;
do {
system.out.println(“n=” + n);
} while (--n>0);//--n的值與n的值同步

5．2．3 for 循環
格式： for (initialization ;condition ; iteration) {
//body of loop
}
//假如只有一條語句需要重復則{ }沒有必要。初始化表達式只被執行一次。例如for(i=0;i<10;i++) 中i=0只執行1次！！！

在for循環中聲明循環控制變量。例如：
for (int i=0;i<10;i++) {
………….
}//i的作用域在for循環執行后就結束了

在for循環中使用“，”。例如：
for (a=1 , b=4;a<b ; a++ , b--)
注重：在Java中，逗號僅僅是一個分隔符，只適用于for循環！！！

for( ; ; ){
……..
}//這將是一個無限循環

把握循環嵌套

5．3跳轉語句
java支持3種跳轉語句：break continue return
5．3．1 break語句

作用：1、在switch中，終止一個語句序列
2、退出一個循環
3、作為一種先進的“goto”語句使用
注重：switch語句中的break僅僅影響該switch，而不影響任何循環；
內部循環的break僅僅終止該循環，外部循環不受影響。

把break當作goto的一種形式來用(不局限于循環)，最大用處是跳出多層循環。格式：break label; 例子：
public static void main(Strings[] args)
{
label1:{
label2:{
for(i=0;i<10;i++)
{
if (i==5) break label1;//執行跳出label1，在label1的結尾開始執行
}
}
system.out.println(“not arrival here”);//不被執行
}
system.out.println(“Hello!arrivel here”);//被執行
}
程序最后輸出：Hello!arrivel here
又例如：
outer:for (int m=0;m<3;m++)//循環的范圍已經固定，所以用于循環的label可以不帶{ }。當然也可以用{}包括更多的語句，要害是注重label的范圍。
{
system.out.println(“pass”+ m);
for(int i=0;i<50;i++){
if(i==10) break outer;//若只寫break;則跳出該循環，從該循環結束的位置開始執行
system.out.println(“i=”+i);
}
system.out.println(“not execute me”);
}
sytem.out.println(“I am executed”);

注重：假如label1不包括break，則break label1非法，不被編譯。例如：
label1{
……………
}
for(i=0;i<10;i++){
if(i==5) break label1;//錯誤！！！因為label1不包括break
}
5．3．2 把握continue的用法。
5．3．3 return語句。將在以后章節具體研究。
下面的例子將編譯出錯，提示：unreachable statement因為編譯器知道println語句將永遠不能被執行。C語言中也存在這種情況，但是編譯時只提出warning.
class test{
public static void main(String[] args){
int m=100;
return;
system.out.println(“m is “+ m);
}
}
解決方法是：在return前面加一個true值以蒙騙編譯器如：
boolean flag=true;
if (flag) return;
6 介紹類
類是Java的核心和本質。
6．1類基礎
類是一個邏輯構造，創建一個類就相當于創建了一種新的數據類型。
對象有物理的真實性，也就是說對象占有內存空間
對象是類的一個實例(instance)，所以經常instance和object互換使用。

類包括成員變量和成員方法。成員變量包括實例變量和類（static）變量。

6．2聲明對象
參見《Java2參考大全》
動態分配內存就是在運行時分配內存，通過new運算符來實現。
類的聲明只是創建一個模板（或類型描述），并不創建一個實際的對象。

6．3給對象引用變量賦值
Object b1=new Object();
Object b2=b1;//b2和b1的地址值相等，指向了同一對象。
此時b1和b2引用了同一對象，并不是對象的拷貝。通過變量b2對對象的改變將影響b1所對應的對象。
b1=null;//這里b1被設置為空，但b2仍指向原來的對象。
相當于C中的指針。

6．4方法
訪問類的成員有兩種：
1．類內部代碼的訪問
2．類外部代碼的訪問
當一個實例變量不是被該實例變量所在類的部分代碼訪問時，它必須通過該對象加點運算符來訪問。但是當一個實例變量被定義該變量的類的部分代碼訪問時，該變量可以被直接引用。同樣的規則適用于方法。

寫方法時必須要有返回值，不返回寫void。（構造函數例外。）
否則編譯時提示: invalid method declaration; return type required
例如：
class Box{
double width;
double height;
double depth;

double volume(){
return width*height*depth//沒有用對象加點號
}
void setdim(double w ,double h, double d){
width=w;
height=h;
depth=d;
}
}
//一個好的Java程序，它的實例變量應該僅僅由類內部的方法來存取，不應該直接對其存取。象object obj=new object();obj.var1=10;這樣就不好。如:vb。
Class demo{
Public static void main(String[] args){
Box mybox=new box();
double vol;
mybox.setdim(12,13,14);
vol=mybox.volume();
system.out.println(“volume is” + vol);
}
}
注重：下面區分一下自變量(parameter)和參數(argument)
自變量是方法定義的一個變量，當方法調用時，他接收一個值。例如上面setdim(double w ,double h, double d)方法中w,h,d就是自變量
參數是當一個方法被調用時，傳遞給該方法的值。例如setdim(12,13,14)把12，13，14作為參數傳遞，自變量w,h,d接收它們。

6．5構造函數
構造函數與類同名，在對象創建后，new運算符完成前，構造函數立即自動調用。構造函數無任何返回值，即使void型也不返回。他的任務就是初始化一個對象的內部狀態，使實例變量能夠完全初始化，可以被對象馬上調用。
假如不顯式的為類定義一個構造函數，java將為該類創建一個默認的構造函數，它將實例變量初始化為零。
6．4中的例子中將void setdim改為Box(double w ,double h, double d)即可。注重：Box必須和類同名，區分大小寫！！！

6．6this要害字
在方法內代表引用該方法的對象。使用this是冗余的，但是完全正確。他在6.6.1中比較有用。
例如：
Box(double w ,double h, double d){
this.width=w;
this.height=h;
this.depth=d;
}

6．6．1隱藏的實例變量
在同一個方法內，定義二個重名的局部變量在java中是不合法的。但是，
方法內的變量和方法的自變量可以和類的實例變量的名字相同，此時，實例變量名字就被隱藏，就只好用this要害字來存取同名的實例變量。
例如：

Box(double width ,double height, double depth){
this.width=width;
this.height=height;
this.depth=depth;
}//width height depth為實例變量
6．7垃圾回收（garbage collection）
Java自動處理重新分配內存。，垃圾回收只在程序中偶然發生，對于大多數程序，不必考慮垃圾回收問題。

6．8finalize()方法
有時撤銷一個對象時，需要顯式的完成一些操作，例如一個對象處理的是非java資源，如文件句柄或windows字符字體，這時，在對象被撤銷以前要保證這些資源被釋放。
finalize()方法正好在垃圾回收之前被調用。但是，當一個對象超出了他的作用域，finalize()并不被調用。我們不知道何時，甚至是否finalize()被調用，所以，最好用別的方法釋放有對象使用的系統資源，不要依靠finalize方法。

6．9一個堆棧類

7 進一步研究方法和類
7．1方法重載（method overloaded）
方法重載是實現多態性的一種方式，由參數的類型或數量來決定重載方法的版本，雖然每個重載方法可以有不同的返回類型，但是，返回類型不足以區分所使用的是哪個方法。

7．1．1構造函數重載
可以重載多個構造方法。像上面的Box，就可以另外構造一個
Box(){
Width=1;
Height=1;
Depth=1;
}//這樣比較方便，可以在只想創建一個對象而不關心它的實例變量時，不用老是輸入參數

7．2把對象作為參數
參見《java參考大全114頁》
對象參數最普遍的使用涉及到構造函數，構造一個新對象，使它的初始狀態與一個已存在的對象一樣。
例如：
Box(Box obj){
width=obj.width;
height=obj.height;
depth=obj.depth;
}
//要害：以類的名字作為數據類型，就像java的內置類型一樣。傳給obj 的參數自然在先前是創建好了的。和c的指針參數差不多，例如
函數：kill_blank_all(char *str)，你不用在函數體內給str分配內存，因為在調用這個函數之前，作為參數的字符串內存已經分配了。
舉例說明：
Box box1=new box(12,13,14);//box1被聲明且分配內存并初始化了。
Box clone_box=new box(box1);//box1是一個對象

7．3參數是如何傳遞的
1．按值傳遞(call-by-value)//將參數值拷貝一份
2．引用調用(call-by-reference)//指向同一對象
注重：當一個簡單類型傳遞給一個方法時，使用按值傳遞。對象傳遞則按引用傳遞。
實際上一個對象引用被傳遞個方法時，引用本身使用按值傳遞，但是因為被傳遞的值指向一個對象，該值的拷貝仍然指向同一個對象。

7．4返回對象
方法能返回任何類型的數據，包括你創建的類的類型。例如；
Box test_meth(){
Box box1 = new Box(12,13,14);
return box1;
}//其中藍色的Box是返回類型,和C的返回指針一樣，是個引用。

同C/C++字符指針的類比：
Box box1=new box();
char *str0=”compare to C”;

Box box3;//先聲明一個Box型的引用，但是引用哪塊內存未分配，同char *str;
Box3=box1.test_meth();//將引用指向一個已經存在的對象。同str=str0;

舉個數據庫操作的例子：
Resultset res=conn.execute(“select * from table”);//數據庫對象的方法execute的返回類型就是對象：Resultset。所以，有些地方不必顯式的非要用new 來創建引用的對象。

7．5遞歸（recursion）
遞歸就是答應方法調用自身，它的典型的例子就是數字的階乘，1---N之間的所有數的乘積。參考大全 118頁。
遞歸，迭代各有各的優點。

7．6介紹訪問控制（access control）
假如程序的其他部分可以繞開一個類的方法（接口）而直接去存取該類的變量，說明封裝的不好。可以通過訪問指示符(access specifier)來控制。極端的做法是將成員變量全部設為private，只能通過類的方法對他們存取。
VB這一點作的就不好，很多屬性都可以直接存取。

主要有public private protected 默認訪問級別（包內public）
類中的private成員為此類私有，不能為該類外的所有代碼訪問，包括子類。
main()方法老是被public指示符修飾，因為他要被java運行時系統調用。若沒有public，編譯提示：Main method not public

7．7；理解static
假如一個成員被聲明為static，他就能夠在他的類的對象被創建之前被訪問，不必引用任何對象。最常見的例子是main()方法，因為在程序開始時必須調用main()，所以他被聲明為static。若沒有static，編譯提示：
Exception in thread "main" java.lang.NoSUChMethodError: main
參見大全125頁
類變量：所有的實例共用一個變量。
類方法：
1．僅能直接調用其他的static方法
2．只能直接調用static變量（數據），調用任何實例變量都是錯誤的。但是，可以通過聲明所在類的對象來訪問實例變量。
3．不能以任何方式引用this和super。因為他們代表對象。
4．類方法可以有自己的自變量。
以上幾點適用于main函數，轉到8。1

調用方法：
class_name.variable
class_name.method()

static塊的聲明方法：
static {
system.out.println(“This is a static block”);
}
調用一個類方法的順序是：首先它所在的類的static變量被初始化一次
再者，static塊被只初始化一次，后者，類方法執行。
例如：
class userstatic{
static int i=3;
static int j;
static void meth(int x){
system.out.println(“x=”+x);
system.out.println(“i=”+i);
system.out.println(“j=”+j);
}
static{
system.out.println(“static block initialized”);
b=a*4;
}

public void main(String[] args){
meth(42);
}
}

輸出結果為：
static block initialized
x=42
i=3;
j=12

7．8介紹final

變量聲明為final即為常量，類似于C/C++中的const。例如：
final int FLAG=1;
final變量一般都大寫，在實例中不占內存，實質上是常數。雖然這樣，但是仍須將類實例化后才能訪問，不像static那樣。
final的其他兩個作用在繼續中：
1．final 方法可以防止被子類覆蓋，但是可以在其他類中被訪問。
2．final類可以防止被繼續。

7．9略

7．10介紹嵌套類和內部類
在另一個類中定義的類就是嵌套類（nested classes）。
嵌套類的兩種類型：
1．前面加static標識符的嵌套類。他不能直接引用包圍類的成員，只有通過對象來訪問包圍類的成員。所以，這種嵌套類很少使用。
2．內部類(inner class)：前面不加static標識符的嵌套類。

類B被定義在類A之內，那么B為A所知，然而不被A的外面知道。類A外面的任何代碼試圖實例化類B，都匯編譯錯誤，但是類A內部的代碼可以實例化B。
嵌套類可以直接引用嵌套它的類的成員變量或方法，包括private，但是，包圍類不能直接引用但是可以通過對象來訪問嵌套類的成員變量和方法。
注:在這里用 “可不可以訪問 “不太恰當

內部類有和外部類的成員同級的，也有定義在外部類的方法之內或方法的循環之內的。
若屬于后者，這內部類不但可以直接引用外部類的成員變量，還可以直接引用方法的局部變量。
例如：
class outer{
int i=10;
class inner{
void in_meth(){
system.out.println(“I is “ + i);//直接調用包圍類的變量
}
}
void out_meth(){
inner in1 = new inner();//包圍類實例化內部類
in1.in_meth();
}
}
體會：其實內部類、包圍類的成員引用只是一個范圍問題，一個以{}為界的范圍。出了這個作用域，成員的生命期就結束了。
也可以從訪問的兩種方式來理解。類內代碼訪問（直接引用）和類外代碼訪問（對象加點訪問）：內部類對包圍類來說是類內代碼，包圍類的代碼對于內部類來說是類外代碼。
下面看看一段C語言程序
main ()
{
int i=1000;
int j=2000;
{ //注重作用域
int i=23; //將暫時覆蓋1000
int m=50;
printf("%d ",i); //結果為23
printf("%d ",j); //結果為2000，說明可以直接引用作用域外` 面的變量
printf("%d ",m); //結果為50
} //作用域到此結束

printf("%d ",i); //結果為1000，23已經釋放了。
printf("%d ",m); //編譯期錯誤。m已經滅亡了。說明不可直接引用作用域里面的變量。
}

內部類一般不使用，但在處理applet時有幫助。還有匿名內部類（anonymous inner classes），一個沒有名字的內部類。詳見第20章。

7．11String類

我們創建的每一個字符串都是String類型的一個對象。
String類型的對象是不可改變的，假如要改變，可以先創建一個新的字符串，其中包含修改后的字符串即可。
StringBuffer類型的字符串可以改變。

連接字符串運算符：+，注重：它不能用于其它任何的類型

String類的方法：
boolean equals(String object)//檢驗兩個字符串引用指向的內容是否相等
int length()//獲得字符串的長度，java字符串無’

上一篇：正則表達式幾種常用功能

下一篇：支持運營商從GSM向3G過渡捷德推出新Java SIM卡