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