Java一些基础知识的整合
文章目錄
- 1. 數(shù)據(jù)類型、變量與常量
- 1.1基本數(shù)據(jù)類型（primitive types）
- 1.1.1 boolean
- 1.1.2字符型
- 1.1.2.1 轉(zhuǎn) 義 字 符 含 義
- 1.1.3整數(shù)類型
- 1.1.4 浮點(diǎn)類型
- 1.2引用類型( reference types )
- 1.3 基本數(shù)據(jù)類型和引用類型區(qū)別
- 1.4 標(biāo)識(shí)符（ Identifier）
- 2. 運(yùn)算符與表達(dá)式
- 2.1運(yùn)算符
- 2.1.1具體說(shuō)明
- 3. 流程控制語(yǔ)句
- 4. 數(shù)組
- 1 .類、字段、方法
- 1.1定義
- 1.2 構(gòu)造方法
- 1.3 使用對(duì)象
- 1.4方法重載（ overload)
- 1.5 this的使用
- 2 .類的繼承
- 2.1字段
- 2.2方法
- 2.3 super 的使用
- 2.4 父類對(duì)象與子類對(duì)象的轉(zhuǎn)換
- 2.5例子
- 3 .包
- 3.1 包的定義
- 3.2 package 語(yǔ)句
- 3.3 import 語(yǔ)句
- 3.4 編譯和運(yùn)行包中的類
- 3.5 CLASSPATH
- 4 .訪問(wèn)控制符
- 4.1 修飾符
- 4.2 成員的訪問(wèn)控制符（權(quán)限修飾符）
- 4.3 類的訪問(wèn)控制符
- 4.4 setter 與getter
- 5 .非訪問(wèn)控制符
- 5.1 static
- 5.1.1 static 字段
- 5.1.2 static 方法
- 5.1.3 import static
- 5.2 final
- 5.3 abstract
- 6 .接口
- 6.1 定義
- 6.2 接口的作用
- 6.3 接口的實(shí)現(xiàn)
- 6.4 接口類型
- 6.5 接口中的常量
- 7 .枚舉
- 8. Java8 中的接口
- 1 . 變量及其傳遞
- 1.1 基本類型變量與引用型變量
- 1.2 字段變量與局部變量
- 1.2 變量的傳遞
- 1.3變量的返回
- 不定長(zhǎng)參數(shù)
- 2 . 多態(tài)和虛方法調(diào)用
- 2.1多態(tài)
- 2.2上溯造型
- 2.3虛方法調(diào)用
- 3 . 對(duì)象構(gòu)造與初始化
- 3.1 構(gòu)造方法（constructor)
- 3.2 創(chuàng)建對(duì)象時(shí)初始化
- 3.3 實(shí)例初始化與靜態(tài)初始化
- 3.4 構(gòu)造方法的執(zhí)行過(guò)程
- 4 . 對(duì)象清除與垃圾回收
- 4.1 對(duì)象的自動(dòng)清除
- System.gc ()方法
- finalize() 方法
- try -with-resources
- 5 . 內(nèi)部類與匿名類
- 定義
- 內(nèi)部類（Inner class)
- 局部類
- 匿名類
- 6 . Lambda表達(dá)式
- 7 . 裝箱、枚舉、注解
- 基本類型的包裝類
- 裝箱與拆箱
- 枚舉
- 注解
- 8 . 沒有指針的Java語(yǔ)言
- java中相等還是不等
1. 數(shù)據(jù)類型、變量與常量
數(shù)據(jù)類型決定數(shù)據(jù)的存儲(chǔ)方式和運(yùn)算方式
Java中的數(shù)據(jù)類型分為兩大類
1.1基本數(shù)據(jù)類型（primitive types）
Java中定義了四類/八種基本數(shù)據(jù)類型
整數(shù)型---- byte, short, int, long
浮點(diǎn)數(shù)型---- float, double
邏輯型---- boolean
字符型---- char
1.1.1 boolean
boolean類型適于邏輯運(yùn)算，一般用于程序流程控制
boolean類型數(shù)據(jù)只允許取值true或false，不可以0或非0的整數(shù)替代true和false
if(a=5)在java中是不允許的
1.1.2字符型
char型數(shù)據(jù)用來(lái)表示通常意義上“字符”
字符常量是用單引號(hào)括起來(lái)的單個(gè)字符
char c = ‘A’;
Java字符采用Unicode編碼，每個(gè)字符占兩個(gè)字節(jié)，可用十六進(jìn)制編碼形式表示 char c1 = ‘\u0061’;
Java語(yǔ)言中還允許使用轉(zhuǎn)義字符’'來(lái)將其后的字符轉(zhuǎn)變?yōu)槠渌暮x
char c2 = ‘\n’; //代表?yè)Q行符
1.1.2.1 轉(zhuǎn) 義 字 符 含 義
\ddd 1到3位八進(jìn)制數(shù)所表示的字符(ddd)
\uxxxx 1到4位十六進(jìn)制數(shù)所表示的字符(xxxx)
\' 單引號(hào)字符
\" 雙引號(hào)字符
\ 反斜杠字符
\r 回車
\n 換行
\f 走紙換頁(yè)
\t 橫向跳格
\b 退格
1.1.3整數(shù)類型
Java各整數(shù)類型有固定的表數(shù)范圍和字段長(zhǎng)度，而不受具體操作系統(tǒng)的 影響，以保證Java程序的可移植性
byte 1字節(jié) -128 ~ 127
short 2字節(jié) -2^15 ~ 2 ^15-1
int 4字節(jié) -2 ^ 31 ~ 2^31-1
long 8字節(jié) -2^63 ~ 2 ^63-1
Java語(yǔ)言整型常量的三種表示形式：
十進(jìn)制整數(shù)，如12, -314, 0。
八進(jìn)制整數(shù)，要求以0開頭，如012
十六進(jìn)制數(shù)，要求0x或0X開頭，如0x12
二進(jìn)制數(shù)，以0b或0B開頭，如0b00010010 （Java7以上）
Java語(yǔ)言的整型常量默認(rèn)為int型，
如： int i =3;
聲明long型常量可以后加‘ l ’或‘ L ’ ，
如：long l = 3L;
Java中沒有“無(wú)符號(hào)數(shù)” 可以用long來(lái)處理無(wú)符號(hào)整數(shù)（uint）
1.1.4 浮點(diǎn)類型
Java浮點(diǎn)類型有固定的表數(shù)范圍和字段長(zhǎng)度
float 4字節(jié) -3.403E38~3.403E38
double 8字節(jié) -1.798E308~1.798E308
Java浮點(diǎn)類型常量有兩種表示形式
十進(jìn)制數(shù)形式，必須含有小數(shù)點(diǎn)，
例如: 3.14 314.0 .314
Java7以上： 123_456.789_000 (千分位分割符用下劃線表示）
科學(xué)記數(shù)法形式，如 3.14e2 3.14E2 314E2
Java浮點(diǎn)型常量默認(rèn)為double型, 如要聲明一個(gè)常量為float型，則需在數(shù)字后面加f或F，
如： double d = 3.14; float f = 3.14f;
1.2引用類型( reference types )
類(class)
接口(interface)
數(shù)組
1.3 基本數(shù)據(jù)類型和引用類型區(qū)別
基本類型： 變量在棧，在“這里”
引用類型： 變量引用到堆，在“那里”
double d = 3; Person p = new Person();
賦值時(shí) double d2 = d; 復(fù)制的是值
Person p2 = p; 復(fù)制的是引用
1.4 標(biāo)識(shí)符（ Identifier）
名字就是標(biāo)識(shí)符：任何一個(gè)變量、常量、方法、對(duì)象和類都需要有名字。
標(biāo)識(shí)符要滿足如下的規(guī)定：
（1）標(biāo)識(shí)符可以由字母、數(shù)字和下劃線(_)、美元符號(hào)($)組合而成； （2）標(biāo)識(shí)符必須以字母、下劃線或美元符號(hào)開頭，不能以數(shù)字開頭。
標(biāo)識(shí)符最好與其意義相符，以增加程序的可讀性
應(yīng)注意Java是大小寫敏感的語(yǔ)言。
按Java慣例，
1.類名首字母用大寫（Pascal)
2.其余的（包名、方法名、變量名）首字母都小寫(camel)
3.少用下劃線
4.變量、常量隨使用隨定義
2. 運(yùn)算符與表達(dá)式
2.1運(yùn)算符
算術(shù)運(yùn)算符: +，―，，/，%，++，-
關(guān)系運(yùn)算符: >，<，>=，<=，==，!=
邏輯運(yùn)算符: !，& , | , ^ , &&，||
位運(yùn)算符: &，|，^，~ ， >>，<<，>>>
賦值運(yùn)算符: =
擴(kuò)展賦值運(yùn)算符:+=，―=，=，/=
字符串連接運(yùn)算符: +
2.1.1具體說(shuō)明
左移 "a<<b; "將二進(jìn)制形式的a逐位左移b位，最低位空出的b位補(bǔ)0；
帶符號(hào)右移 "a>>b; "將二進(jìn)制形式的a逐位右移b位，最高位空出的b位補(bǔ)原來(lái)的符號(hào)位；
無(wú)符號(hào)右移 "a>>>b;"將二進(jìn)制形式的a逐位右移b位，最高位空出的b位補(bǔ)0
移位運(yùn)算符性質(zhì)
適用數(shù)據(jù)類型:byte、short、char、int、long
對(duì)低于int型的操作數(shù)將先自動(dòng)轉(zhuǎn)換為int型再移位（整型提升，對(duì)所有的運(yùn)算 都是這樣）
對(duì)于int型整數(shù)移位a>>b，系統(tǒng)先將b對(duì)32取模，得到的結(jié)果才是真正移位的 位數(shù)
對(duì)于long型整數(shù)移位時(shí)a>>b ，則是先將移位位數(shù)b對(duì)64取模
賦值運(yùn)算符=
當(dāng)“=”兩側(cè)的數(shù)據(jù)類型不一致時(shí)，可以適用默認(rèn)類型轉(zhuǎn)換或強(qiáng)制類型轉(zhuǎn)換 (casting)原則進(jìn)行處理
long ll = 100; int i = (int)ll;
特例:可以將整型常量直接賦值給byte, short, char等類型變量，而不需要進(jìn) 行強(qiáng)制類型轉(zhuǎn)換，只要不超出其表數(shù)范圍
byte b = 12; //合法 byte b = 4096; //非法
"+" 除用于算術(shù)加法運(yùn)算外，還可用于對(duì)字符串進(jìn)行連接操作
int i = 300 +5;
String s = "hello, " + “world!”;
"+"運(yùn)算符兩側(cè)的操作數(shù)中只要有一個(gè)是字符串(String)類型，系統(tǒng)會(huì)自動(dòng)將另一 個(gè)操作數(shù)轉(zhuǎn)換為字符串然后再進(jìn)行連接
表達(dá)式
表達(dá)式是符合一定語(yǔ)法規(guī)則的運(yùn)算符和操作數(shù)的序列
a
5.0 + a
(a-b)*c-4
i<30 && i%10!=0
表達(dá)式的類型和值
對(duì)表達(dá)式中操作數(shù)進(jìn)行運(yùn)算得到的結(jié)果稱為表達(dá)式的值
表達(dá)式的值的數(shù)據(jù)類型即為表達(dá)式的類型
表達(dá)式的運(yùn)算順序
首先應(yīng)按照運(yùn)算符的優(yōu)先級(jí)從高到低的順序進(jìn)行
優(yōu)先級(jí)相同的運(yùn)算符按照事先約定的結(jié)合方向進(jìn)行
當(dāng)有不同種類的混合運(yùn)算時(shí):
int->long->float->double
整型提升
所有的byte, short, char 參與算術(shù)運(yùn)算等轉(zhuǎn)為int
3. 流程控制語(yǔ)句
沒有“表達(dá)式語(yǔ)句”這個(gè)概念 x+y;是不合法的
方法調(diào)用語(yǔ)句
賦值語(yǔ)句，注意分號(hào)（；）
分支語(yǔ)句
循環(huán)語(yǔ)句
類似c++
4. 數(shù)組
數(shù)組是多個(gè)相同類型數(shù)據(jù)的組合
一維數(shù)組的聲明方式：
int[] a;
double []b
Mydate []c;
注意方括號(hào)寫到變量名的前面，也可以寫到后面
數(shù)組定義 與 為數(shù)組元素分配空間 分開進(jìn)行
Java語(yǔ)言中聲明數(shù)組時(shí)不能指定其長(zhǎng)度(數(shù)組中元素的個(gè)數(shù))，
例如： int a[5]; //非法
數(shù)組是引用類型
int [ ] a = new int[5];
這里 a 只是一個(gè)引用
靜態(tài)初始化：
在定義數(shù)組的同時(shí)就為數(shù)組元素分配空間并賦值。
默認(rèn)初始化
數(shù)組一經(jīng)分配空間，其中的每個(gè)元素也被按照成員變量同樣的方式被 隱式初始化。例如： ( 數(shù)值類型是0， 引用類型是null )
int []a= new int[5]; //a[3]則是0
數(shù)組元素的引用
數(shù)組元素的引用方式
index為數(shù)組元素下標(biāo)，可以是整型常量或整型表達(dá)式。
如a[3] , b[i] , c[6*i];
數(shù)組元素下標(biāo)從0開始；長(zhǎng)度為n的數(shù)組合法下標(biāo)取值范圍： 0 ~ n-1；
每個(gè)數(shù)組都有一個(gè)屬性length指明它的長(zhǎng)度，
例如：a.length 指明數(shù)組a的 長(zhǎng)度(元素個(gè)數(shù))；
Enhanced for語(yǔ)句可以方便地處理數(shù)組、集合中各元素
int[] ages = new int[10]; for ( int age ： ages ) { System.out.println( age ); } //這種語(yǔ)句是只讀式的遍歷System.arraycopy方法提供了數(shù)組元素復(fù)制功能：
//源數(shù)組 int[] source = { 1, 2, 3, 4, 5, 6 }; // 目的數(shù)組 int []dest = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }; // 復(fù)制源數(shù)組中從下標(biāo)0開始的source.length個(gè)元素到目的數(shù)組，//從下標(biāo)0的位置開始存儲(chǔ)。 // System.arraycopy( source, 0, dest, 0, source.Length );public static void arraycopy(Object src,int srcPos,Object dest,int destPos, int length)
其中：src表示源數(shù)組，srcPos表示源數(shù)組要復(fù)制的起始位置，desc表示目標(biāo)數(shù)組，length表示要復(fù)制的長(zhǎng)度。
二維數(shù)組
int [][] t = new int [3][];
t[0] = new int[2];
t[1] = new int[4];
t[2] = new int[3];
多維數(shù)組的聲明和初始化應(yīng)按從高維到低維的順序進(jìn)行
int t1[][] = new int [][4]; // 非法 , 這與 C++ 不同
1 .類、字段、方法
1.1定義
類是組成Java程序的基本要素,
是一類對(duì)象的原型
它封裝了一類對(duì)象的狀態(tài)和方法
它將變量與函數(shù)封裝到一個(gè)類中
字段（field）是類的屬性，是用變量來(lái)表示的。
字段又稱為域、域變量、屬性、成員變量等
方法（method）是類的功能和操作, 是用函數(shù)來(lái)表示的
1.2 構(gòu)造方法
構(gòu)造方法（constructor )是一種特殊的方法
用來(lái)初始化（new)該類的一個(gè)新的對(duì)象
構(gòu)造方法和類名同名，而且不寫返回?cái)?shù)據(jù)類型。
一般情況下，類都有一個(gè)至多個(gè)構(gòu)造方法
如果沒有定義任何構(gòu)造方法，系統(tǒng)會(huì)自動(dòng)產(chǎn)生一個(gè)構(gòu)造方法，稱為默 認(rèn)構(gòu)造方法（default constructor）。
默認(rèn)構(gòu)造方法不帶參數(shù)，并且方法體為空。
1.3 使用對(duì)象
訪問(wèn)對(duì)象的字段或方法，需要用算符“．” ：
Person p = new Person(); System.out.println( p.name )； p.sayHello();這種使用方式的好處 封裝性 安全性
1.4方法重載（ overload)
方法重載（overloading)：多個(gè)方法有相同的名字，編譯時(shí)能識(shí)別出 來(lái)。
這些方法的簽名（signature)不同，或者是參數(shù)個(gè)數(shù)不同，或者是參 數(shù)類型不同。
通過(guò)方法重載可以實(shí)現(xiàn)多態(tài)（polymorphism）
1.5 this的使用
1．在方法及構(gòu)造方法中，使用this來(lái)訪問(wèn)字段及方法
例如，方法sayHello中使用name和使用this.name是相同的。即：
this指當(dāng)前對(duì)象實(shí)例本身
2．使用this解決局部變量與域同名的問(wèn)題
使用this還可以解決局部變量（方法中的變量）或參數(shù)變量與域變 量同名的問(wèn)題。如，在構(gòu)造方法中，經(jīng)常這樣用：
這里，this.age表示域變量，而age表示的是參數(shù)變量。
3．構(gòu)造方法中，用this調(diào)用另一構(gòu)造方法
構(gòu)造方法中，還可以用this來(lái)調(diào)用另一構(gòu)造方法。如：
Person( ) { this( 0, "" ); //一個(gè)構(gòu)造方法中調(diào)用另一個(gè)構(gòu)造方法…… }在構(gòu)造方法中調(diào)用另一構(gòu)造方法，則這條調(diào)用語(yǔ)句必須放在第一句。
2 .類的繼承
繼承(inheritance)是面向?qū)ο蟮某绦蛟O(shè)計(jì)中最為重要的特征之一
子類（subclass），父類或超類（superclass）
父類包括所有直接或間接被繼承的類
Java支持單繼承：一個(gè)類只能有一個(gè)直接父類。
子類繼承父類的狀態(tài)和行為
可以修改父類的狀態(tài)或重載父類的行為
可以添加新的狀態(tài)和行為。
好處
可以提高程序的抽象程度
實(shí)現(xiàn)代碼重用，提高開發(fā)效率和可維護(hù)性
Java中的繼承是通過(guò)extends關(guān)鍵字來(lái)實(shí)現(xiàn)的
class Student extends Person {
……
}
如果沒有extends子句，則該類默認(rèn)為java.lang.Object的子類。
所有的類都是通過(guò)直接或間接地繼承java.lang.Object得到的。
所有對(duì)象都可以用他的 toString方法轉(zhuǎn)換成字符串，都可以克隆
類Student從類Person繼承：
class Student extends Person { String school; int score; boolean isGood(){ return score>80; } //… }2.1字段
1．字段的繼承
子類可以繼承父類的所有字段
Student自動(dòng)具有Person的屬性（name，age）
2. 字段的隱藏
子類重新定義一個(gè)與從父類那里繼承來(lái)的域變量完全相同的變量，稱為域的隱藏。域的隱藏在實(shí)際編程中用得 較少。
3. 字段的添加
在定義子類時(shí)，加上新的域變量，就可以使子類比父類多一些屬性。如：在定義子類時(shí)，加上新的域變量，就可以使子類比父類多一些屬性。如：
2.2方法
1．方法的繼承
父類的非私有方法也可以被子類自動(dòng)繼承。如，Student自動(dòng)繼承Person的方 法sayHello和isOlderThan。
2．方法的覆蓋(Override)（修改）
子類也可以重新定義與父類同名的方法，實(shí)現(xiàn)對(duì)父類方法的覆蓋
通過(guò)方法的覆蓋，能夠修改對(duì)象的同名方法的具體實(shí)現(xiàn)方法。
3.方法的添加
子類可以新加一些方法，以針對(duì)子類實(shí)現(xiàn)相應(yīng)的功能。
如，在類Student中，加入一個(gè)方法，對(duì)分?jǐn)?shù)進(jìn)行判斷：
4 . 方法的重載
一個(gè)類中可以有幾個(gè)同名的方法，這稱為方法的重載（Overload）。
同時(shí)，還可以重載父類的同名方法。
與方法覆蓋不同的是，重載不要求參數(shù) 類型列表相同。
重載的方法實(shí)際是新加的方法。
如，在類Student中，重載一個(gè)名為sayHello的方法：
2.3 super 的使用
1．使用super訪問(wèn)父類的域和方法
注意：正是由于繼承，使用this可以訪問(wèn)父類的域和方法。但有時(shí)為了明確地指明父類的域和方法，就要用關(guān) 鍵字super。
例如：父類Student有一個(gè)域age，在子類Student中用age, this.age, super.age來(lái)訪問(wèn)age是完全一樣的：
當(dāng)然，使用super不能訪問(wèn)在子類中添加的域和方法。
有時(shí)需要使用super以區(qū)別同名的域與方法
使用super可以訪問(wèn)被子類所隱藏了的同名變量。
又如，當(dāng)覆蓋父類的同名方法的同時(shí)，又要調(diào)用父類的方法，就必須使用super。
如：
**在覆蓋父類的方法的同時(shí)，又利用已定義好的父類的方法。**批判性的繼承
2．使用父類的構(gòu)造方法
構(gòu)造方法是不能繼承的
比如，父類Person有一個(gè)構(gòu)造方法Person(String, int)，不能說(shuō)子類Student也自動(dòng)有一個(gè)構(gòu)造方法Student(String, int)。所以子類要從新定義構(gòu)造方法
但是，子類在構(gòu)造方法中，可以用super來(lái)調(diào)用父類的構(gòu)造方法。
使用時(shí)，super()必須放在第一句。
2.4 父類對(duì)象與子類對(duì)象的轉(zhuǎn)換
類似于基本數(shù)據(jù)類型數(shù)據(jù)之間的強(qiáng)制類型轉(zhuǎn)換，存在繼承關(guān)系的父類對(duì)象和 子類對(duì)象之間也可以在一定條件下相互轉(zhuǎn)換。
(1) 子類對(duì)象可以被視為其父類的一個(gè)對(duì)象
如一個(gè)Student對(duì)象也是一個(gè)Person對(duì)象。
(2) 父類對(duì)象不能被當(dāng)做其某一個(gè)子類的對(duì)象。找一個(gè)學(xué)生不能隨便拉來(lái)一個(gè)人
(3) 如果一個(gè)方法的形式參數(shù)定義的是父類對(duì)象，那么調(diào)用這個(gè)方法時(shí)，可以使用子類對(duì)象作為實(shí)際參數(shù)。
需要一個(gè)人，實(shí)際傳過(guò)來(lái)一個(gè)學(xué)生，也是可以的
(4) 如果父類對(duì)象引用指向的實(shí)際是一個(gè)子類對(duì)象，那么這個(gè)父類對(duì)象的引 用可以用強(qiáng)制類型轉(zhuǎn)換（casting)成子類對(duì)象的引用。
2.5例子
class Person { String name; int age;Person( String n, int a ){name = n;age = a; }Person( String n ){name = n;age = 0; }Person( int age, String name ) {this.age = age;this.name = name; }Person( ){this( 0, "" ); }boolean isOlderThan( int anAge ){return this.age > anAge; }void sayHello(){System.out.println("Hello! My name is " + name ); }void sayHello( Person another ){System.out.println("Hello," + another.name + "! My name is " + name ); }public static void main(String[] args) {Person p = new Person("Li Min", 18);Person p2 = new Person("Wang Qiang", 20 );p.sayHello();p.sayHello(p2); } } class Student extends Person {String school;int score;void sayHello( Student another ){System.out.println("Hi!");if( school == another.school ) System.out.println(" Shoolmates ");}boolean isGoodStudent(){return score>=90;}void sayHello(){super.sayHello();System.out.println( "My school is " + school );}Student(String name, int age, String school ){super( name, age );this.school = school;}Student(){}void testThisAndSuper(){int a;a = age;a = this.age;a = super.age;}public static void main( String [] arggs ){Person p = new Person( "Liming", 50 );Student s = new Student( "Wangqiang", 20, "PKU" );Person p2 = new Student( "Zhangyi", 18, "THU" );Student s2 = (Student) p2;//強(qiáng)制轉(zhuǎn)換//Student s3 = (Student) p; //runtime exception p.sayHello( s );Person [] manypeople = new Person[ 100 ];manypeople[0] = new Person("Li", 18 );manypeople[1] = new Student("Wang", 18, "PKU");} }3 .包
3.1 包的定義
package pkg1[.pkg2[.pkg3…]];
包及子包的定義，實(shí)際上是為了解決名字空間、名字沖突
它與類的繼承沒有關(guān)系。
事實(shí)上，一個(gè)子類與其父類可以位于不同的包中。
包有兩方面的含義
一是名字空間、存儲(chǔ)路徑（文件夾）、
一是可訪問(wèn)性（同一包中的各個(gè)類，默認(rèn)情況下可互相訪問(wèn)）
3.2 package 語(yǔ)句
包層次的根目錄是由環(huán)境變量CLASSPATH來(lái)確定的。
在簡(jiǎn)單情況下，沒有package語(yǔ)句，這時(shí)稱為無(wú)名包（unnamed package）
在Eclipse中，也叫(default package)。
Java的JDK提供了很多包
java.applet，java.awt，java.awt.image，java.awt.peer，java.io， java.lang，java.net，java.util，javax.swing，等
3.3 import 語(yǔ)句
為了能使用Java中已提供的類，需要用import語(yǔ)句來(lái)導(dǎo)入所需要的類。
import語(yǔ)句的格式為： import package1[.package2…]. (classname |*); 例如： import java.util.Date; 這樣，程序中 java.util.Date可以簡(jiǎn)寫為Date import java.awt.*; import java.awt.event.*; 注意：使用星號(hào)(*)只能表示本層次的所有類，不包括子層次下的類。Java編譯器自動(dòng)導(dǎo)入包java.lang.* 所以不用寫math類，
Eclipse等IDE可以方便地生成import語(yǔ)句
3.4 編譯和運(yùn)行包中的類
使用javac可以將.class文件放入到相應(yīng)的目錄，只需要使用一個(gè)命令選項(xiàng)-d來(lái)指明包的根目錄即可。
javac -d d:\tang\ch04 d:\tang\ch04\pk\TestPkg.java
javac -d . pk*.java
其中，“.”表示當(dāng)前目錄
運(yùn)行該程序，需要指明含有main的類名：
java pk.TestPkg
3.5 CLASSPATH
在編譯和運(yùn)行程序中，經(jīng)常要用到多個(gè)包，怎樣指明這些包的根目錄呢？
簡(jiǎn)單地說(shuō)，包層次的根目錄是由環(huán)境變量CLASSPATH來(lái)確定的。
具體操作 有兩種方法。
一是在java及javac命令行中，用-classpath（或-cp)選項(xiàng)來(lái)指明，如：
java –classpath d:\tang\ch04;c:\java\classes;. pk.TestPkg
二是設(shè)定classpath環(huán)境變量，用命令行設(shè)定環(huán)境變量，如：
set classpath= d:\tang\ch04;c:\java\classes;.
4 .訪問(wèn)控制符
4.1 修飾符
加到類的名字或字段的名字之前修飾一下
修飾符（modifiers）分為兩類
訪問(wèn)修飾符（access modifiers）
如public/private等
其他修飾符
如abstract等
可以修飾類、也可以修飾類的成員（字段、方法）
4.2 成員的訪問(wèn)控制符（權(quán)限修飾符）
可見性，默認(rèn)類似于c++里的友元，十分方便
| private | YES | |||
| 默認(rèn) （包可訪問(wèn)) | YES | YES | ||
| protected | YES | YES | YES | |
| public | YES | YES | YES | YES |
4.3 類的訪問(wèn)控制符
在定義類時(shí)，也可以用訪問(wèn)控制符。
類的訪問(wèn)控制符或者為public，或者默認(rèn)。 沒有private
若使用public，其格式為:
public class 類名{
……
}
如果類用public修飾，則該類可以被其他類所訪問(wèn)；
若類默認(rèn)訪問(wèn)控制符，則該類只能被同包中的類訪問(wèn)。
4.4 setter 與getter
將字段用private修飾，從而更好地將信息進(jìn)行封裝和隱藏。
用setXXXX和getXXXX方法對(duì)類的屬性進(jìn)行存取，分別稱為setter與getter。 字段是private，方法可以是public
這種方法有以下優(yōu)點(diǎn)
（1）屬性用private更好地封裝和隱藏，外部類不能隨意存取和修改。
（2）提供方法來(lái)存取對(duì)象的屬性，在方法中可以對(duì)給定的參數(shù)的合法性進(jìn)行檢驗(yàn)。
（3）方法可以用來(lái)給出計(jì)算后的值。
（4）方法可以完成其他必要的工作（如清理資源、設(shè)定狀態(tài)，等等）。
（5）只提供getXXXX方法，而不提供setXXXX方法，可以保證屬性是只讀的。無(wú)法修改
Setter/getter 示例
class Person2 { private int age; public void setAge( int age ){ if (age>0 && age<200) this.age = age; } public int getAge(){ return age; } }盡量不要把字段直接暴露出來(lái)，這樣就很好
5 .非訪問(wèn)控制符
| static | 靜態(tài)的、非實(shí)例的、類的 | 可以修飾內(nèi)部類 | Yes | |
| final | 最終的、不可改變的 | Yes | Yes | Yes |
| abstract | 抽象的、不可實(shí)例化的 | Yes | Yes |
5.1 static
5.1.1 static 字段
靜態(tài)字段最本質(zhì)的特點(diǎn)是：
它們是類的字段，不屬于任何一個(gè)對(duì)象實(shí)例。
它不保存在某個(gè)對(duì)象實(shí)例的內(nèi)存區(qū)間中，而是保存在類的內(nèi)存區(qū)域的公共存儲(chǔ)單元。
類變量可以通過(guò)類名直接訪問(wèn)，也可以通過(guò)實(shí)例對(duì)象來(lái)訪問(wèn)，兩種方法的結(jié)果是相同的。 實(shí)例對(duì)象也是屬于某一個(gè)類的
如System類的in和out對(duì)象，就是屬于類的域，直接用類名來(lái)訪問(wèn)， 即System.in和System.out。
例子
在類Person中可以定義一個(gè)類域?yàn)閠otalNum：
totalNum代表人類的總?cè)藬?shù)，它與具體對(duì)象實(shí)例無(wú)關(guān)。可以有兩種方法來(lái) 訪問(wèn)：Person.totalNum和p.totalNum (假定p是Person對(duì)象，實(shí)例)。
在一定意義上，可以用來(lái)表示全局變量
5.1.2 static 方法
用static修飾符修飾的方法僅屬于類的靜態(tài)方法，又稱為類方法。
與此相對(duì)，不用static修飾的方法，則為實(shí)例方法。
類方法的本質(zhì)是該方法是屬于整個(gè)類的，不是屬于某個(gè)實(shí)例的。
聲明一個(gè)方法為static有以下幾重含義。
(1) 非static的方法是屬于某個(gè)對(duì)象的方法，在這個(gè)對(duì)象創(chuàng)建時(shí)，對(duì)象 的方法在內(nèi)存中擁有自己專用的代碼段。而static的方法是屬于整個(gè)類 的，它在內(nèi)存中的代碼段將隨著類的定義而進(jìn)行分配和裝載，不被任 何一個(gè)對(duì)象專有。
(2) 由于static方法是屬于整個(gè)類的，所以它不能操縱和處理屬于某個(gè)對(duì)象 的成員變量，而只能處理屬于整個(gè)類的成員變量，即static方法只能處理本類中的static域或調(diào)用static方法。
(3) **static方法中，不能訪問(wèn)實(shí)例變量，不能使用this 或super。**因?yàn)閠his和super是具體的當(dāng)前的某一個(gè)實(shí)例的，而static是屬于整個(gè)類的
(4) 調(diào)用這個(gè)方法時(shí)，應(yīng)該使用類名直接調(diào)用，也可以用某一個(gè)具體的對(duì)象 名。
例如：Math.random()，Integer.parseInt()等就是類方法，直接用類名進(jìn)行訪問(wèn)，他不是實(shí)例方法
5.1.3 import static
import static java.lang.System.*;
有一個(gè)類成員都是static
out.println();表示System.out.println();
5.2 final
1．final類
如果一個(gè)類被final修飾符所修飾和限定，說(shuō)明這個(gè)類不能被繼承，即不可能有 子類。 可以進(jìn)行優(yōu)化
2．final方法
final修飾符所修飾的方法，是不能被子類所覆蓋的方法。
3. final字段、final局部變量(方法中的變量)
它們的值一旦給定，就不能更改。
是只讀量，它們能且只能被賦值一次，而不能被賦值多次。
一個(gè)字段被static final兩個(gè)修飾符所限定時(shí)，它可以表示常量，
如Integer. MAX_VALUE(表示最大整數(shù))、Math.PI(表示圓周率)就是這種常量。
關(guān)于賦值
1.在定義static final域時(shí)，若不給定初始值，則按默認(rèn)值進(jìn)行初始化（數(shù)值為0，boolean型為false，引用型為 null）。
2.在定義final字段時(shí)，若不是static的域，則必須且只能賦值一次，不能缺省。
這種域的賦值的方式有兩種：一是在定義變量時(shí)賦初始值，二是在每一個(gè)構(gòu)造函數(shù)中進(jìn)行賦值。
3.在定義final局部變量時(shí)，也必須且只能賦值一次。它的值可能不是常量，但它的取值在變量存在期間不會(huì)改變。（只讀的）
5.3 abstract
1 . abstract類
凡是用abstract修飾符修飾的類被稱為抽象類。
抽象類不能被實(shí)例化 ，不能new一個(gè)實(shí)例對(duì)象
2．abstract方法
被abstract所修飾的方法叫抽象方法，抽象方法的作用在為所有子類定義一個(gè)統(tǒng)一的 接口。對(duì)抽象方法只需聲明，而不需實(shí)現(xiàn)，即用分號(hào)（；）而不是用{}，格式如下：
abstract returnType abstractMethod( [paramlist] );
抽象類中可以包含抽象方法，也可以不包含abstract方法。但是，一旦某個(gè)類中包含 了abstract方法，則這個(gè)類必須聲明為abstract類。
抽象方法在子類中必須被實(shí)現(xiàn)，否則子類仍然是abstract的。
6 .接口
6.1 定義
接口，某種特征的約定 ，約定特征，引用類型
定義接口 interface
所有方法都自動(dòng)是public abstract的 ，公開不考慮實(shí)現(xiàn)
這個(gè)特征可以被不同的類所實(shí)現(xiàn)，使用接口時(shí)候可以用某個(gè)具體對(duì)象代替他
實(shí)現(xiàn)接口 implements
可以實(shí)現(xiàn)多繼承
與類的繼承關(guān)系無(wú)關(guān)
面向接口編程，而不是面向?qū)崿F(xiàn)
Flyable f = new Bird();
Java中有大量的接口
6.2 接口的作用
1 . 通過(guò)接口可以實(shí)現(xiàn)不相關(guān)類的相同行為，（超人，鳥，飛機(jī)相同行為是可飛行）而不需要考慮這些類之間 的層次關(guān)系。從而在一定意義上實(shí)現(xiàn)了多重繼承。 （可以讓一個(gè)類實(shí)現(xiàn)多個(gè)特征，可飛翔，可復(fù)制。。。）
2. 通過(guò)接口可以指明多個(gè)類需要實(shí)現(xiàn)的方法。
3. 通過(guò)接口可以了解對(duì)象的交互界面，而不需了解對(duì)象所對(duì)應(yīng)的類。
示例
下面我們給出一個(gè)接口的定義： 實(shí)現(xiàn)方法都是public
通常接口以able或ible結(jié)尾，表明接口能完成一定的行為。
接口聲明中還可以包括對(duì)接口的訪問(wèn)權(quán)限以及它的父接口列表。完整的接口聲明如下：
[public] interface interfaceName [extends listOfSuperInterface]{
……
}
其中public指明任意類均可以使用這個(gè)接口，缺省情況下，只有與該接口定義在同一個(gè)包中的類才可以訪問(wèn)這個(gè)接口。
extends 子句與類聲明中的extends子句基本相同，不同的是一個(gè)接口可以有多個(gè)父接口， 用逗號(hào)隔開，而一個(gè)類只能有一個(gè)父類。子接口繼承父接口中所有的常量和方法。
方法定義的格式為：
returnType methodName ( [paramlist] )；
接口中只進(jìn)行方法的聲明，而不提供方法的實(shí)現(xiàn)，所以，方法定義沒有方法體，且用分號(hào)(;)結(jié)尾。在接口中聲明的方法具有public 和 abstract屬性。
所以定義的時(shí)候這兩個(gè)關(guān)鍵詞是可以省略的
另外，如果在子接口中定義了和父接口同名的常量或相同的方法，則 父接口中的常量被隱藏，方法被重載。
6.3 接口的實(shí)現(xiàn)
在類的聲明中用implements子句來(lái)表示一個(gè)類使用某個(gè)接口，在類體中可以使用接口中定義的常量，而且必須實(shí)現(xiàn)接口中定義的所有方法。一個(gè)類可以實(shí)現(xiàn)多個(gè)接口。
下面我們?cè)陬怓IFOQueue中實(shí)現(xiàn)上面所定義的接口collection：
class FIFOQueue implements collection{ public void add ( Object obj ){……}public void delete( Object obj ){……}public Object find( Object obj ){……}public int currentCount{……}在類中實(shí)現(xiàn)接口所定義的方法時(shí)，方法的聲明必須與接口中所定義的完全一致。
6.4 接口類型
接口可以作為一種引用類型來(lái)使用。任何實(shí)現(xiàn)該接口的類的實(shí)例都可以存儲(chǔ)在該接口類型的變量中，通過(guò)這些變量可以訪問(wèn)類所實(shí)現(xiàn)的接口中的方法。Java運(yùn)行時(shí)系統(tǒng)動(dòng)態(tài)地確定該使用哪個(gè)類中的方法。
把接口作為一種數(shù)據(jù)類型可以不需要了解對(duì)象所對(duì)應(yīng)的具體的類，以 前面所定義的接口Collection和實(shí)現(xiàn)該接口的類FIFOQueue為例，下例中，我們以Collection作為引用類型來(lái)使用。
6.5 接口中的常量
接口體中可以包含常量定義
常量定義的格式為：
type NAME = value;
其中type可以是任意類型，NAME是常量名，通常用大寫，value是 常量值。
在接口中定義的常量可以被實(shí)現(xiàn)該接口的多個(gè)類共享，它與 C中用 #define以及C++中用const定義的常量是相同的。
在接口中定義的常量具有public, static, final的屬性。（可以省略）
7 .枚舉
從JDK1.5起，可以使用枚舉
enum Light {
Red, Yellow, Green
}
使用
Ligth light = Light.Red;
switch( light ) {
case Red:
…… Break;
}
注意：case后面不寫為 Light.Red
Java中的枚舉是用class來(lái)實(shí)現(xiàn)的，可以復(fù)雜地使用
8. Java8 中的接口
Java8以上，接口成員還可以是：
static方法
具有實(shí)現(xiàn)體的方法 （default方法）
默認(rèn)方法的好處是：提供了一個(gè)默認(rèn)實(shí)現(xiàn)，子類在implements可以不用再重新寫了
1 . 變量及其傳遞
1.1 基本類型變量與引用型變量
基本類型(primitive type)：其值直接存于變量中。“在這里”
引用型(reference type) 的變量（class，interface，數(shù)組）除占據(jù)一定的內(nèi)存空間外，它所引用 的對(duì)象實(shí)體（由new 創(chuàng)建）也要占據(jù)一定空間?！霸谀抢铩?br /> 引用變量在這里只是存一個(gè)對(duì)象實(shí)體的地址，通過(guò)這個(gè)引用能夠操作這個(gè)對(duì)象
.
public class MyDate {private int day;private int month;private int year;public MyDate(int y, int m, int d) {year = y;month = m;day = d;} void addYear(){year ++;}public void display() {System.out.println(year + "-" + month + "-" +day); }public static void main(String[] args) {MyDate m = new MyDate(2003, 9, 22);MyDate n = m;//復(fù)制只是復(fù)制了一個(gè)引用n.addYear();m.display();//操作的是同一個(gè)對(duì)象n.display();} }1.2 字段變量與局部變量
字段變量（field)與局部變量(Local variable)
前者是在類中，后者是方法中定義的變量或方法的參變量
從內(nèi)存角度看
存儲(chǔ)位置，字段變量為對(duì)象的一部分、存在于堆中的，局部變量是存在于棧中。
生命周期不同 字段變量隨著對(duì)象的存在而存在，局部變量隨著方法的存在而存在，隨著方法的結(jié)束而結(jié)束
初始值：字段變量可以自動(dòng)賦初值，局部變量則須顯式賦值
從語(yǔ)法角度看
字段變量屬于類，可以用public,private,static,final 修飾。
局部變量不能夠被訪問(wèn)控制符及static修飾
都可以被final修飾
1.2 變量的傳遞
調(diào)用對(duì)象方法時(shí)，要傳遞參數(shù)。在傳遞參數(shù)時(shí)，
Java 是值傳遞，即，是將表達(dá)式的值復(fù)制給形式參數(shù)。
對(duì)于引用型變量，傳遞的值是引用值，而不是復(fù)制對(duì)象實(shí)體
可以改變對(duì)象的屬性
1.3變量的返回
方法的返回：
返回基本類型。
返回引用類型。它就可以存取對(duì)象實(shí)體。
調(diào)用時(shí)：Object p= GetNewObject();
不定長(zhǎng)參數(shù)
不定長(zhǎng)參數(shù)（Variable length arguments），從JDK1.5開始
用省略號(hào)表示, 并且是最后一個(gè)參數(shù)
實(shí)際上Java當(dāng)成一個(gè)數(shù)組
調(diào)用：sum(1,2,3,4);
又例如： public static void main( String…argv)
2 . 多態(tài)和虛方法調(diào)用
2.1多態(tài)
多態(tài)(Polymorphism)是指一個(gè)程序中相同的名字表示不同的含義的情況。
多態(tài)有兩種情形
編譯時(shí)多態(tài)：
重載(overload) （多個(gè)同名的不同方法）。
如 p.sayHello(); p.sayHello(“Wang”);
運(yùn)行時(shí)多態(tài)：
覆蓋(override) （子類對(duì)父類方法進(jìn)行覆蓋）
動(dòng)態(tài)綁定（dynamic binding） ----虛方法調(diào)用(virtual method invoking)
在調(diào)用方法時(shí)，程序會(huì)正確地調(diào)用子類對(duì)象的方法。
多態(tài)的特點(diǎn)大大提高了程序的抽象程度和簡(jiǎn)潔性
2.2上溯造型
上溯造型（upcasting）
是把派生類型當(dāng)作基本類型處理
例子見下面博客
https://blog.csdn.net/weijie_home/article/details/49105871
2.3虛方法調(diào)用
什么是虛方法？
https://blog.csdn.net/vop444/article/details/69525124#commentBox
虛方法例子：
https://blog.csdn.net/qq_32863631/article/details/79227859
用虛方法調(diào)用，可以實(shí)現(xiàn)運(yùn)行時(shí)的多態(tài)！
子類重載了父類方法時(shí)，運(yùn)行時(shí)
運(yùn)行時(shí)系統(tǒng)根據(jù)調(diào)用該方法的實(shí)例的類型（傳進(jìn)去的時(shí)student，那么就調(diào)用student）來(lái)決定選擇哪個(gè)方法調(diào)用
所有的非final方法都會(huì)自動(dòng)地進(jìn)行動(dòng)態(tài)綁定！
什么是動(dòng)態(tài)綁定？
https://blog.csdn.net/javamoo/article/details/78776150
虛方法調(diào)用示例
動(dòng)態(tài)類型確定
變量 instanceof 類型
結(jié)果是boolean 值（實(shí)際就是這個(gè)類型或者是他的子類型，則返回true）
對(duì)實(shí)際類型進(jìn)行判斷
例子：
什么情況不是虛方法調(diào)用
Java中，普通的方法是虛方法
（在調(diào)用過(guò)程中會(huì)根據(jù)實(shí)際的對(duì)象來(lái)決定方法的調(diào)用）
但static,private方法不是虛方法調(diào)用 （static是屬于類的，private是屬于這個(gè)類自己的）
static,private與虛方法編譯后用的指令是不同的
反匯編代碼：
Compiled from "JavaP3methods.java" public class text1.JavaP3methods {public text1.JavaP3methods();Code:0: aload_01: invokespecial #8 // Method java/lang/Object."<init>":()V4: returnvoid f();Code:0: returnstatic void s();Code:0: returnpublic static void main(java.lang.String...);Code:0: new #1 // class text1/JavaP3methods3: dup4: invokespecial #19 // Method "<init>":()V7: astore_18: aload_19: invokevirtual #20 // Method f:()V12: aload_113: invokespecial #22 // Method p:()V16: invokestatic #24 // Method s:()V19: return }三種非虛的方法
static的方法，以聲明的類型為準(zhǔn)，與實(shí)例類型無(wú)關(guān)
private方法子類看不見，也不會(huì)被虛化
final方法子類不能覆蓋，不存在虛化問(wèn)題
3 . 對(duì)象構(gòu)造與初始化
3.1 構(gòu)造方法（constructor)
對(duì)象都有構(gòu)造方法
如果沒有，編譯器加一個(gè)default構(gòu)造方法 （默認(rèn)構(gòu)造方法什么都不干）
抽象類也有構(gòu)造方法，任何一個(gè)對(duì)象都需要構(gòu)造
調(diào)用本類或父類的構(gòu)造方法
this調(diào)用本類的其他構(gòu)造方法。
super調(diào)用直接父類的構(gòu)造方法
this或super要放在第一條語(yǔ)句,且只能夠有一條
如果沒有this及super，則編譯器自動(dòng)加上super()，即調(diào)用直接父類 不帶參數(shù)的構(gòu)造方法
因?yàn)楸仨毩钏懈割惖臉?gòu)造方法都得到調(diào)用，否則整個(gè)對(duì)象的構(gòu)建就 可能不正確。
例子：
class example2 {public static void main(String[] args){ Person p = new Graduate();} }class Person {String name; int age;Person(){}Person( String name, int age ){this.name=name; this.age=age; System.out.println("In Person(String,int)");} }class Student extends Person {String school;Student(){this( null, 0, null );System.out.println("In Student()");}Student( String name, int age, String school ){super( name, age );this.school = school;System.out.println("In Student(String,int,String)");} }class Graduate extends Student {String teacher="";Graduate(){//super();System.out.println("In Graduate()");} }//輸出結(jié)果： //In Person(String,int) //In Student(String,int,String) //In Student() //In Graduate()上面代碼可見雖然只寫了一個(gè)new，但是它是一直調(diào)用父類的構(gòu)造方法，直到object
class A { A(int a){} } class B extends A { B(String s){} //編譯不能夠通過(guò).}編譯器會(huì)自動(dòng)調(diào)用B(String s){ super();} 他會(huì)調(diào)用不帶參數(shù)的構(gòu)造方法，但是父類沒有不帶參數(shù)的，所以出錯(cuò).
解決方法:
在B的構(gòu)造方法中,加入super(3);
在A中加入一個(gè)不帶參數(shù)的構(gòu)造方法,A(){}
去掉A中全部的構(gòu)造方法,則編譯器會(huì)自動(dòng)加入一個(gè)不帶參數(shù)的構(gòu)造方法,稱為默認(rèn)的構(gòu)造方法
3.2 創(chuàng)建對(duì)象時(shí)初始化
p = new Person(){{ age=18; name=“李明”; }};
這樣就 不 用 寫 p. name，p.age，方便一點(diǎn)
這樣可以針對(duì)沒有相應(yīng)構(gòu)造函數(shù)，但又要賦值
注意雙括號(hào)
3.3 實(shí)例初始化與靜態(tài)初始化
實(shí)例初始化（Instance Initializers）
在類中直接寫
{ 語(yǔ)句…. }
實(shí)例初始化，先于構(gòu)造方法{}中的語(yǔ)句執(zhí)行（先于this或super之外的那些語(yǔ)句）
盡量少用這種{}，有點(diǎn)怪怪的感覺。。
靜態(tài)初始化（Static Initializers）
static { 語(yǔ)句…. } 只是與類有關(guān)的而不是跟實(shí)例有關(guān)的
靜態(tài)初始化，在第一次使用這個(gè)類時(shí)要執(zhí)行，
但其執(zhí)行的具體時(shí)機(jī)是不確定的
但是可以肯定的是：總是先于實(shí)例的初始化
例子：
class InitialTest {public static void main(String[] args) {new InitialTest2(6);}int n=10; //step2{n++;System.out.println("InitialTest..."+n);}static int x;static {x++;System.out.println("static..." +x);}}class examp extends InitialTest{examp(int a){ this.a=a; System.out.println("this.a=" + a );}int a;//實(shí)例初始化的語(yǔ)句{System.out.println("InitialTest2..."+this.a);}static//這個(gè)初始化要先于實(shí)例的初始化{x++;System.out.println("static2..." +x);} } //輸出： //static...1 //static...1 //static2...2 //InitialTest...11 //InitialTest2...0 //this.a=63.4 構(gòu)造方法的執(zhí)行過(guò)程
構(gòu)造方法的執(zhí)行過(guò)程遵照以下步驟：
調(diào)用本類或父類的構(gòu)造方法，直至最高一層（Object）
按照聲明順序執(zhí)行字段的初始化賦值
執(zhí)行構(gòu)造函數(shù)中的其它各語(yǔ)句（不包括this或super）
簡(jiǎn)單地說(shuō)：
先父類構(gòu)造，再本類成員賦值，最后執(zhí)行構(gòu)造方法中的語(yǔ)句。
例子：
class JavaPConstructor {int a=2000;JavaPConstructor(){this.a=3000;} }下面我們看一下反匯編后的結(jié)果
Compiled from "JavaPConstructor.java" class text3.JavaPConstructor {int a;text3.JavaPConstructor();Code:0: aload_01: invokespecial #10 // Method java/lang/Object."<init>":()V4: aload_05: sipush 20008: putfield #12 // Field a:I11: aload_012: sipush 300015: putfield #12 // Field a:I18: return }可見，它先調(diào)用了object方法，雖然沒有寫super，但實(shí)際上他會(huì)調(diào)用super。第二步把兩千賦值到字段里面。（執(zhí)行實(shí)例初始化及對(duì)字段的賦值）第三步才執(zhí)行構(gòu)造方法里面的語(yǔ)句
例子：（這次有super有this）
class ConstructS {public static void main(String[] args){ Person p = new Student("李明", 18, "北大");} }class Person {String name="未命名"; //step 2int age=-1;Person( String name, int age ){super(); //step 1//step 3System.out.println( "開始構(gòu)造Person(),此時(shí)this.name="+this.name+",this.age="+this.age );this.name=name; this.age=age; System.out.println( "Person()構(gòu)造完成,此時(shí)this.name="+this.name+",this.age="+this.age );} }class Student extends Person {String school="未定學(xué)校"; //step2 Student( String name, int age, String school ){super( name, age ); //step 1看似一步其實(shí)包含父類三步//step 3System.out.println( "開始構(gòu)造Student(),此時(shí)this.name="+this.name+",this.age="+this.age+",this.school="+this.school );this.school = school;System.out.println( "Student()構(gòu)造完成,此時(shí)this.name="+this.name+",this.age="+this.age+",this.school="+this.school );} } //輸出結(jié)果： //開始構(gòu)造Person(),此時(shí)this.name=未命名,this.age=-1 //Person()構(gòu)造完成,此時(shí)this.name=李明,this.age=18 //開始構(gòu)造Student(),此時(shí)this.name=李明,this.age=18,this.school=未定學(xué)校 //Student()構(gòu)造完成,此時(shí)this.name=李明,this.age=18,this.school=北大構(gòu)造方法內(nèi)部調(diào)用別的的方法
如果這個(gè)方法是虛方法，結(jié)果如何？
從語(yǔ)法上來(lái)說(shuō)這是合法的，但有時(shí)會(huì)造成事實(shí)上的不合
在本例中，在構(gòu)造方法中調(diào)用了一個(gè)動(dòng)態(tài)綁定的方法sayHello(),這時(shí)， 會(huì)使用那個(gè)方法被覆蓋的定義，而這時(shí)對(duì)象嘗未完全構(gòu)建好，所以 School還沒有賦值。
在構(gòu)造方法中盡量避免調(diào)用任何方法，盡可能簡(jiǎn)單地使對(duì)象進(jìn)入就緒 狀態(tài)
惟一能夠安全調(diào)用的是final的方法。這就不會(huì)有虛方法的問(wèn)題
4 . 對(duì)象清除與垃圾回收
我們知道：new創(chuàng)建對(duì)象 那么如何銷毀對(duì)象？
Java中是自動(dòng)清除 不需要使用delete
4.1 對(duì)象的自動(dòng)清除
垃圾回收(garbage collection ）
對(duì)象回收是由 Java虛擬機(jī)的垃圾回收線程來(lái)完成的。
為什么系統(tǒng)知道對(duì)象是否為垃圾
任何對(duì)象都有一個(gè)引用計(jì)數(shù)器，當(dāng)其值為0時(shí)，說(shuō)明該對(duì)象可以回收
（任何對(duì)象我們要用它，它都是一個(gè)引用）（如果對(duì)象實(shí)體空間沒有被任何引用所引用，那么其值為零）
引用計(jì)數(shù)示意（可見他是自動(dòng)的）
System.gc ()方法
System.gc()方法
它是System類的static方法
它可以要求系統(tǒng)進(jìn)行垃圾回收
但它僅僅只是”建議(suggest)”
你沒法強(qiáng)制，只是希望虛擬機(jī)有空有條件時(shí)候進(jìn)行垃圾回收
finalize() 方法
Java中沒有“析構(gòu)方法(destructor)”
但Object的finalize() 有類似功能
系統(tǒng)在回收時(shí)會(huì)自動(dòng)調(diào)用對(duì)象的finalize() 方法。
protected void finalize() throws Throwable{}
子類的finalize()方法
可以在子類的finalize()方法釋放系統(tǒng)資源
**一般來(lái)說(shuō)，子類的finalize()方法中應(yīng)該調(diào)用父類的finalize()方法，**以保證父 類的清理工作能夠正常進(jìn)行。
try -with-resources
由于finalize()方法的調(diào)用時(shí)機(jī)并不確定，所以一般不用finalize()
關(guān)閉打開的文件、清除一些非內(nèi)存資源等工作需要進(jìn)行處理
可以使用try-with-resources語(yǔ)句（JDK1.7以上）
對(duì)于實(shí)現(xiàn)了java.lang.AutoCloseable的對(duì)象
會(huì)自動(dòng)調(diào)用其close()方法,相當(dāng)于，不管你try里面正常異常都會(huì)做下面的事情
finally{ Scanner.close(); }5 . 內(nèi)部類與匿名類
定義
內(nèi)部類( inner class )是在其他類中的類 （其他的類中再定義類）
匿名類( anonymous class)是一種特殊的內(nèi)部類，它沒有類名。
內(nèi)部類（Inner class)
內(nèi)部類的定義
將類的定義class xxxx{…}置入一個(gè)類的內(nèi)部即可
編譯器生成xxxx$xxxx這樣的class文件
內(nèi)部類不能夠與外部類同名
內(nèi)部類的使用
在封裝它的類的內(nèi)部使用內(nèi)部類，與普通類的使用方式相同
在其他地方使用
類名前要冠以外部類的名字。
在用new創(chuàng)建內(nèi)部類實(shí)例時(shí)，也要在 new前面冠以對(duì)象變量。
外部對(duì)象名.new 內(nèi)部類名(參數(shù))
例子：
在內(nèi)部類中使用外部類的成員
內(nèi)部類中可以直接訪問(wèn)外部類的字段及方法
即使private也可以
如果內(nèi)部類中有與外部類同名的字段或方法，則可以用
外部類名.this.字段及方法
（平時(shí)用this都是指當(dāng)前的，但是你這個(gè)指的是外部的字段及方法）
例子：
內(nèi)部類的修飾符
內(nèi)部類與類中的字段、方法一樣是外部類的成員，它的前面也可以有 訪問(wèn)控制符和其他修飾符。
訪問(wèn)控制符：public,protected,默認(rèn)（沒有修飾符）及private。
注：外部類只能夠使用public修飾或者默認(rèn) （package）
final,abstract（表示他是不可繼承的）
static 修飾符
用static修飾內(nèi)部類 表明該內(nèi)部類實(shí)際是一種外部類 （對(duì)象.new就不用了）
因?yàn)樗c外部類的實(shí)例無(wú)關(guān)
有人認(rèn)為static的類是嵌套類（nested class），不是內(nèi)部類inner class
static類在使用時(shí)：
1、實(shí)例化static類時(shí)，在 new前面不需要用對(duì)象實(shí)例變量； （因?yàn)樗蛯?shí)例無(wú)關(guān)）
2、static類中不能訪問(wèn)其外部類的非static的字段及方法，既只能夠訪問(wèn)static成員。
3、static方法中不能訪問(wèn)非static的域及方法，也不能夠不帶前綴地new 一個(gè)非 static的內(nèi)部類。
例子：
局部類
在一個(gè)方法中也可以定義類，這種類稱為”方法中的內(nèi)部類”
或者叫局部類（local class）
例子：
使用局部類
1、同局部變量一樣，方法中的內(nèi)部類
不能夠用 public,private,protected,static修飾，（不能修飾局部變量同類也不能修飾局部類） 但可以被final（不可繼承）或者abstract（抽象）修飾。
2、可以訪問(wèn)其外部類的成員
3、不能夠訪問(wèn)該方法的局部變量，（它是隨時(shí)產(chǎn)生隨時(shí)消失的，進(jìn)到方法里就有，退出就消失了，是不可捉摸的不可訪問(wèn)的）除非是final局部變量
匿名類
匿名類( anonymous class)是一種特殊的內(nèi)部類
它沒有類名，在定義類的同時(shí)就生成該對(duì)象的一個(gè)實(shí)例
“一次性使用”的類（所以沒必要給他個(gè)名字）
（一般他是擴(kuò)展一個(gè)或者說(shuō)要繼承一個(gè)類，實(shí)現(xiàn)一個(gè)接口）
例子：
匿名 類的使用
1、不取名字，直接用其父類或接口的名字。
也就是說(shuō)，該類是父類的子類，或者實(shí)現(xiàn)了一個(gè)接口
編譯器生成 xxxxx$1之類的名字
2、類的定義的同時(shí)就創(chuàng)建實(shí)例，即類的定義前面有一個(gè)new
new 類名或接口名（）{……}
不使用關(guān)鍵詞class，也不使用extends及implements。直接寫父類的名字就完事
3、在構(gòu)造對(duì)象時(shí)使用父類構(gòu)造方法
不能夠定義構(gòu)造方法，因?yàn)樗鼪]有名字
如果new對(duì)象時(shí)，要帶參數(shù)，則使用父類的構(gòu)造方法
匿名 類的應(yīng)用
用到界面的事件處理 （繼承一個(gè)類）
注冊(cè)一個(gè)事件偵聽器
作為方法的參數(shù)
排序，給一個(gè)比較大小的接口
6 . Lambda表達(dá)式
Lambda表達(dá)式是從Java8增加的新語(yǔ)法
Lambda表達(dá)式（λ expression)的基本寫法
(參數(shù)）->結(jié)果
如 (String s) -> s.length()
如 x->x*x
如 () -> { System.out.println(“aaa”); }
大體上相當(dāng)于其他語(yǔ)言的“匿名函數(shù)”或“函數(shù)指針”
在Java中它實(shí)際上是“ 匿名類的一個(gè)實(shí)例
例子：
可以看出
Lambda表達(dá)式是接口或者說(shuō)是接口函數(shù)的簡(jiǎn)寫
其基本寫法是參數(shù)->結(jié)果
這里，參數(shù)是()或1個(gè)參數(shù)或 (多個(gè)參數(shù))
結(jié)果是指 表達(dá)式 或 語(yǔ)句 或 {語(yǔ)句}
例子：
@FunctionalInterface interface Fun { double fun( double x );}public class LambdaIntegral {public static void main(String[] args){double d = Integral( new Fun(){public double fun(double x){ return Math.sin(x); }}, 0, Math.PI, 1e-5 );//簡(jiǎn)寫d = Integral( x->Math.sin(x),0, Math.PI, 1e-5 );System.out.println( d );d = Integral( x->x*x, 0, 1, 1e-5 );System.out.println( d );}static double Integral(Fun f, double a, double b, double eps)// 積分計(jì)算{int n,k;double fa,fb,h,t1,p,s,x,t=0;fa=f.fun(a); fb=f.fun(b);n=1; h=b-a;t1=h*(fa+fb)/2.0;p=Double.MAX_VALUE;while (p>=eps){ s=0.0;for (k=0;k<=n-1;k++){ x=a+(k+0.5)*h;s=s+f.fun(x);}t=(t1+h*s)/2.0;p=Math.abs(t1-t);t1=t; n=n+n; h=h/2.0;}return t;}}Lambda大大地簡(jiǎn)化了書寫
在線程的例子中
new Thread( ()->{ … } ).start();
在積分的例子中
d = Integral( x->Math.sin(x), 0, 1, EPS );
d = Integral( x->x*x, 0, 1, EPS );
d = Integral( x->1, 0, 1, EPS );
在按鈕事件處理中
btn.addActionListener( e->{ … } ) );
能寫成 Lambda的接口的條件
由于Lambda只能表示一個(gè)函數(shù)，所以
能寫成Lambda的接口要求包含且最多只能有一個(gè)抽象函數(shù)
這樣的接口可以（但不強(qiáng)求）用注記
@FunctionalInterface 來(lái)表示。稱為函數(shù)式接口
如
@FunctionalInterface
interface Fun { double fun( double x );}
再舉一例：排序
Comparator<Person> compareAge = (p1, p2) -> p1.age-p2.age; Arrays.sort(people, compareAge); Arrays.sort(people, (p1, p2) -> p1.age-p2.age); Arrays.sort(people, (p1, p2) -> (int)(p1.score-p2.score)); Arrays.sort(people, (p1, p2) -> p1.name.compareTo(p2.name)); Arrays.sort(people, (p1, p2) -> -p1.name.compareTo(p2.name));Lambda表達(dá)式，不僅僅是簡(jiǎn)寫了代碼，
更重要的是：
它將代碼也當(dāng)成數(shù)據(jù)來(lái)處理
函數(shù)式編程
7 . 裝箱、枚舉、注解
基本類型的包裝類
基本類型的包裝類
它將基本類型（primitive type) 包裝成Object(引用類型）（因?yàn)榛绢愋蜎]法當(dāng)對(duì)象用）
如int->Interger
共8類：
Boolean, Byte, Short, Character, Integer, Long, Float, Double
Integer I = new Integer(10);
裝箱與拆箱
裝箱（Boxing） Integer I = 10;
拆箱（Unboxing） int i = I;
實(shí)際譯為
Integer I= Integer.valueOf(10);
int i = I.intValue();
主要方便用于集合中，如： Object [] ary = { 1, “aaa”};
枚舉
枚舉(enum)是一種特殊的class類型
在簡(jiǎn)單的情況下，用法與其他語(yǔ)言的enum相似
enum Light { Red, Yellow, Green };
Light light = Light.Red;
但實(shí)際上，它生成了 class Light extends java.lang.Enum
自定義枚舉
可以在enum定義體中，添加字段、方法、構(gòu)造方法
注解
注解（annotation）
又稱為注記、標(biāo)記、標(biāo)注、注釋（不同于comments)
是在各種語(yǔ)法要素上加上附加信息，以供編譯器或其他程序使用
所有的注解都是 java.lang.annotation. Annotation 的子類
常用的注解，如
@Override 表示覆蓋父類的方法
@Deprecated 表示過(guò)時(shí)的方法
@SuppressWarnings 表示讓編譯器不產(chǎn)生警告
自定義注解，比較復(fù)雜
public @interface Author {
String name();
}
8 . 沒有指針的Java語(yǔ)言
引用（reference）實(shí)質(zhì)就是指針（pointer)
但是它是受控的、安全的
比如
會(huì)檢查空指引
沒有指針運(yùn)算 *(p+5)
不能訪問(wèn)沒有引用到的內(nèi)存
自動(dòng)回收垃圾
C 語(yǔ)言指針在Java中的體現(xiàn)
(1)傳地址 ->對(duì)象
引用類型，引用本身就相當(dāng)于指針
可以用來(lái)修改對(duì)象的屬性、調(diào)用對(duì)象的方法
基本類型：沒用對(duì)應(yīng)的
如交換兩個(gè)整數(shù)
void swap(int x, int y){ int t=x; x=y; y=t; }
int a=8, b=9; swap(a.b);
一種變通的辦法，傳出一個(gè)有兩個(gè)分量x,y的對(duì)象
(2)指針運(yùn)算 -> 數(shù)組
*(p+5) 則可以用 args[5]
(3)函數(shù)指針 -> 接口、Lambda表達(dá)式
例：求積分，線程 、回調(diào)函數(shù)、事件處理
(4)指向結(jié)點(diǎn)的指針-> 對(duì)象的引用
class Node {
Object data;
Node next;
}
(5)使用JNI
Java Native Interface(JNI)
它允許Java代碼和其他語(yǔ)言寫的代碼進(jìn)行交互
java中相等還是不等
基本 類型的相等
數(shù)值類型：轉(zhuǎn)換后比較
浮點(diǎn)數(shù)，最好不直接用==
Double.NAN==Double.NAN 結(jié)果為false
請(qǐng)參見JDK的API文檔
boolean型無(wú)法與int相比較
裝箱 對(duì)象是否相等
Integer i = new Integer(10); Integer j = new Integer(10); System.out.println(i==j); //false，因?yàn)閷?duì)象是兩個(gè)Integer m = 10; Integer n = 10; System.out.println(m==n); //true，因?yàn)閷?duì)象有緩存Integer p = 200; Integer q = 200; System.out.println(p==q); //false，因?yàn)閷?duì)象是兩個(gè)，不能超過(guò)-128到+127注意緩存
If the value p being boxed is true, false, a byte, or a char in the range \u0000 to \u007f, or an int or short number between -128 and 127 (inclusive), then let r1 and r2 be the results of any two boxing conversions of p. It is always the case that r1 == r2.
枚舉、引用對(duì)象是否相等
枚舉類型
內(nèi)部進(jìn)行了惟一實(shí)例化，所以可以直接判斷
引用對(duì)象
是直接看兩個(gè)引用是否一樣
如果要判斷內(nèi)容是否一樣，則要重寫equals方法
如果重寫equals方法，則最好重寫 hashCode()方法
String 對(duì)象的特殊性
String對(duì)象
判斷相等，一定不要用==，要用equals
但是字符串常量（ String literal)及字符串常量會(huì)進(jìn)行內(nèi)部化（interned）， 相同的字符串常量是 = =的
例子：
String hello = "Hello", lo = "lo"; System.out.println( hello == "Hello"); //true System.out.println( Other.hello == hello ); //true System.out.println( hello == ("Hel"+"lo") ); //true System.out.println( hello == ("Hel"+lo) ); //false System.out.println( hello == new String("Hello")); //false System.out.println( hello == ("Hel"+lo).intern()); //true總結(jié)
以上是生活随笔為你收集整理的Java一些基础知识的整合的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。
- 上一篇： matlab guide实现多级界面
- 下一篇： 在计算机桌面上添加小工具日历,实用桌面小