這麼說吧，在我眼裡，Java 就是最流行的編程語言，沒有之一（PHP 往一邊站）。不僅崗位多，容易找到工作，關鍵是薪資水平也到位，不學 Java 虧得慌，對吧？
那可能零基礎學編程的小夥伴就會頭疼了，網上關於 Java 的大部分技術文章都不夠幽默，不夠風趣，不夠系列，急需要一份能看得進去的學習手冊，那我覺得我肝的這份手冊正好符合要求，並且會一直持續更新下去。
第一版的內容暫時包含兩方面，Java 基礎和 Java 面向對象編程。來吧，先上目錄，一睹為快。
01、Java 基本語法簡介
02、Java 基本數據類型簡介
03、Java main() 方法簡介
04、Java 的流程控制語句
05、Java 包的簡介
06、Java 到底是值傳遞還是引用傳遞
07、Java 的類和對象
08、Java 構造方法
09、Java 抽象類
10、Java 接口
11、Java 繼承
12、this 關鍵字
13、super 關鍵字
14、重寫和重載
15、static 關鍵字
16、Java 枚舉
17、final 關鍵字
目錄欣賞完了，接下來就是拜讀精華內容的時間，搬個小板凳，認認真真好好學吧，學到就是賺到！
一、Java 基本語法簡介
01、數據類型
Java 有 2 種數據類型，一種是基本數據類型，一種是引用類型。
基本數據類型用於存儲簡單類型的數據，比如說，int、long、byte、short 用於存儲整數，float、double 用於存儲浮點數，char 用於存儲字符，boolean 用於存儲布爾值。
不同的基本數據類型，有不同的默認值和大小，來個表格感受下。
| 數據類型 | 默認值 | 大小 |
|---|---|---|
| boolean | false | 1比特 |
| char | ‘\u0000’ | 2字節 |
| byte | 0 | 1字節 |
| short | 0 | 2字節 |
| int | 0 | 4字節 |
| long | 0L | 8字節 |
| float | 0.0f | 4字節 |
| double | 0.0 | 8字節 |
引用類型用於存儲對象（null 表示沒有值的對象）的引用，String 是引用類型的最佳代表，比如說 String cmower = "沉默王二"。
02、聲明變量
要聲明一個變量，必須指定它的名字和類型，來看一個簡單的示例：
int age;
String name;
count 和 name 在聲明後會得到一個默認值，按照它們的數據類型——不能是局部變量（否則 Java 編譯器會在你使用變量的時候提醒要先賦值），必須是類成員變量。
public class SyntaxLocalVariable {
int age;
String name;
public static void main(String[] args) {
SyntaxLocalVariable syntax = new SyntaxLocalVariable();
System.out.println(syntax.age); // 輸出 0
System.out.println(syntax.name); // 輸出 null
}
}
也可以在聲明一個變量后使用“=”操作符進行賦值，就像下面這樣：
int age = 18;
String name = "沉默王二";
我們定義了 2 個變量，int 類型的 age 和 String 類型的 name，age 賦值 18，name 賦值為“沉默王二”。
每行代碼後面都跟了一個“;”，表示當前語句結束了。
在 Java 中，變量最好遵守命名約定，這樣能提高代碼的可閱讀性。
- 以字母、下劃線（_）或者美元符號（$）開頭
- 不能使用 Java 的保留字，比如說 int 不能作為變量名
03、數組
數組在 Java 中佔據着重要的位置，它是很多集合類的底層實現。數組屬於引用類型，它用來存儲一系列指定類型的數據。
聲明數組的一般語法如下所示：
type[] identiier = new type[length];
type 可以是任意的基本數據類型或者引用類型。來看下面這個例子：
public class ArraysDemo {
public static void main(String[] args) {
int [] nums = new int[10];
nums[0] = 18;
nums[1] = 19;
System.out.println(nums[0]);
}
}
數組的索引從 0 開始，第一個元素的索引為 0，第二個元素的索引為 1。為什麼要這樣設計？感興趣的話，你可以去探究一下。
通過變量名[索引]的方式可以訪問數組指定索引處的元素，賦值或者取值是一樣的。
04、關鍵字
關鍵字屬於保留字，在 Java 中具有特殊的含義，比如說 public、final、static、new 等等，它們不能用來作為變量名。為了便於你作為參照，我列舉了 48 個常用的關鍵字，你可以瞅一瞅。
-
abstract： abstract 關鍵字用於聲明抽象類——可以有抽象和非抽象方法。
-
boolean： boolean 關鍵字用於將變量聲明為布爾值類型，它只有 true 和 false 兩個值。
-
break： break 關鍵字用於中斷循環或 switch 語句。
-
byte： byte 關鍵字用於聲明一個可以容納 8 個比特的變量。
-
case： case 關鍵字用於在 switch 語句中標記條件的值。
-
catch： catch 關鍵字用於捕獲 try 語句中的異常。
-
char： char 關鍵字用於聲明一個可以容納無符號 16 位比特的 Unicode 字符的變量。
-
class： class 關鍵字用於聲明一個類。
-
continue： continue 關鍵字用於繼續下一個循環。它可以在指定條件下跳過其餘代碼。
-
default： default 關鍵字用於指定 switch 語句中除去 case 條件之外的默認代碼塊。
-
do： do 關鍵字通常和 while 關鍵字配合使用，do 后緊跟循環體。
-
double： double 關鍵字用於聲明一個可以容納 64 位浮點數的變量。
-
else： else 關鍵字用於指示 if 語句中的備用分支。
-
enum： enum（枚舉）關鍵字用於定義一組固定的常量。
-
extends： extends 關鍵字用於指示一個類是從另一個類或接口繼承的。
-
final： final 關鍵字用於指示該變量是不可更改的。
-
finally： finally 關鍵字和
try-catch配合使用，表示無論是否處理異常，總是執行 finally 塊中的代碼。 -
float： float 關鍵字用於聲明一個可以容納 32 位浮點數的變量。
-
for： for 關鍵字用於啟動一個 for 循環，如果循環次數是固定的，建議使用 for 循環。
-
if： if 關鍵字用於指定條件，如果條件為真，則執行對應代碼。
-
implements： implements 關鍵字用於實現接口。
-
import： import 關鍵字用於導入對應的類或者接口。
-
instanceof： instanceof 關鍵字用於判斷對象是否屬於某個類型（class）。
-
int： int 關鍵字用於聲明一個可以容納 32 位帶符號的整數變量。
-
interface： interface 關鍵字用於聲明接口——只能具有抽象方法。
-
long： long 關鍵字用於聲明一個可以容納 64 位整數的變量。
-
native： native 關鍵字用於指定一個方法是通過調用本機接口（非 Java）實現的。
-
new： new 關鍵字用於創建一個新的對象。
-
null： 如果一個變量是空的（什麼引用也沒有指向），就可以將它賦值為 null。
-
package： package 關鍵字用於聲明類所在的包。
-
private： private 關鍵字是一個訪問修飾符，表示方法或變量只對當前類可見。
-
protected： protected 關鍵字也是一個訪問修飾符，表示方法或變量對同一包內的類和所有子類可見。
-
public： public 關鍵字是另外一個訪問修飾符，除了可以聲明方法和變量（所有類可見），還可以聲明類。
main()方法必須聲明為 public。 -
return： return 關鍵字用於在代碼執行完成后返回（一個值）。
-
short： short 關鍵字用於聲明一個可以容納 16 位整數的變量。
-
static： static 關鍵字表示該變量或方法是靜態變量或靜態方法。
-
strictfp： strictfp 關鍵字並不常見，通常用於修飾一個方法，確保方法體內的浮點數運算在每個平台上執行的結果相同。
-
super： super 關鍵字可用於調用父類的方法或者變量。
-
switch： switch 關鍵字通常用於三個（以上）的條件判斷。
-
synchronized： synchronized 關鍵字用於指定多線程代碼中的同步方法、變量或者代碼塊。
-
this： this 關鍵字可用於在方法或構造函數中引用當前對象。
-
throw： throw 關鍵字主動拋出異常。
-
throws： throws 關鍵字用於聲明異常。
-
transient： transient 關鍵字在序列化的使用用到，它修飾的字段不會被序列化。
-
try： try 關鍵字用於包裹要捕獲異常的代碼塊。
-
void： void 關鍵字用於指定方法沒有返回值。
-
volatile： volatile 關鍵字保證了不同線程對它修飾的變量進行操作時的可見性，即一個線程修改了某個變量的值，這新值對其他線程來說是立即可見的。
-
while： 如果循環次數不固定，建議使用 while 循環。
05、操作符
除去“=”賦值操作符，Java 中還有很多其他作用的操作符，我們來大致看一下。
①、算術運算符
- +（加號）
- –（減號）
- *（乘號）
- /（除號）
- ％（取余）
來看一個例子：
public class ArithmeticOperator {
public static void main(String[] args) {
int a = 10;
int b = 5;
System.out.println(a + b);//15
System.out.println(a - b);//5
System.out.println(a * b);//50
System.out.println(a / b);//2
System.out.println(a % b);//0
}
}
“+”號比較特殊，還可以用於字符串拼接，來看一個例子：
String result = "沉默王二" + "一枚有趣的程序員";
②、邏輯運算符
邏輯運算符通常用於布爾表達式，常見的有：
- &&（AND）多個條件中只要有一個為 false 結果就為 false
- ||（OR）多個條件只要有一個為 true 結果就為 true
- !（NOT）條件如果為 true，加上“!”就為 false，否則，反之。
來看一個例子：
public class LogicalOperator {
public static void main(String[] args) {
int a=10;
int b=5;
int c=20;
System.out.println(a<b&&a<c);//false
System.out.println(a>b||a<c);//true
System.out.println(!(a<b)); // true
}
}
③、比較運算符
<(小於)<=(小於或者等於)>(大於)>=(大於或者等於)==(相等)!=(不等)
06、程序結構
Java 中最小的程序單元叫做類，一個類可以有一個或者多個字段（也叫作成員變量），還可以有一個或者多個方法，甚至還可以有一些內部類。
如果一個類想要執行，就必須有一個 main 方法——程序運行的入口，就好像人的嘴一樣，嗯，可以這麼牽強的理解一下。
public class StructureProgram {
public static void main(String[] args) {
System.out.println("沒有成員變量，只有一個 main 方法");
}
}
- 類名叫做 StructureProgram，在它裏面，只有一個 main 方法。
{}之間的代碼稱之為代碼塊。- 以上源代碼將會保存在一個後綴名為 java 的文件中。
07、編譯然後執行代碼
通常，一些教程在介紹這塊內容的時候，建議你通過命令行中先執行 javac 命令將源代碼編譯成字節碼文件，然後再執行 java 命令指定代碼。
但我不希望這個糟糕的局面再繼續下去了——新手安裝配置 JDK 真的蠻需要勇氣和耐心的，稍有不慎，沒入門就先放棄了。況且，在命令行中編譯源代碼會遇到很多莫名其妙的錯誤，這對新手是極其致命的——如果你再遇到這種老式的教程，可以吐口水了。
好的方法，就是去下載 IntelliJ IDEA，簡稱 IDEA，它被業界公認為最好的 Java 集成開發工具，尤其在智能代碼助手、代碼自動提示、代碼重構、代碼版本管理(Git、SVN、Maven)、單元測試、代碼分析等方面有着亮眼的發揮。IDEA 產於捷克（位於東歐），開發人員以嚴謹著稱。IDEA 分為社區版和付費版兩個版本，新手直接下載社區版就足夠用了。
安裝成功后，可以開始敲代碼了，然後直接右鍵運行（連保存都省了），結果會在 Run 面板中显示，如下圖所示。
想查看反編譯后的字節碼的話，可以在 src 的同級目錄 target/classes 的包路徑下找到一個 StructureProgram.class 的文件（如果找不到的話，在目錄上右鍵選擇「Reload from Disk」）。
可以雙擊打開它。
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.cmower.baeldung.basic;
public class StructureProgram {
public StructureProgram() {
}
public static void main(String[] args) {
System.out.println("沒有成員變量，只有一個 main 方法");
}
}
IDEA 默認會用 Fernflower 將 class 字節碼反編譯為我們可以看得懂的 Java 代碼。實際上，class 字節碼（請安裝 show bytecode 插件）長下面這個樣子：
// class version 57.65535 (-65479)
// access flags 0x21
public class com/cmower/baeldung/basic/StructureProgram {
// compiled from: StructureProgram.java
// access flags 0x1
public <init>()V
L0
LINENUMBER 3 L0
ALOAD 0
INVOKESPECIAL java/lang/Object.<init> ()V
RETURN
L1
LOCALVARIABLE this Lcom/cmower/baeldung/basic/StructureProgram; L0 L1 0
MAXSTACK = 1
MAXLOCALS = 1
// access flags 0x9
public static main([Ljava/lang/String;)V
L0
LINENUMBER 5 L0
GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
LDC "\u6ca1\u6709\u6210\u5458\u53d8\u91cf\uff0c\u53ea\u6709\u4e00\u4e2a main \u65b9\u6cd5"
INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
L1
LINENUMBER 6 L1
RETURN
L2
LOCALVARIABLE args [Ljava/lang/String; L0 L2 0
MAXSTACK = 2
MAXLOCALS = 1
}
新手看起來還是有些懵逼的，建議過過眼癮就行了。
二、Java 基本數據類型簡介
01、布爾
布爾（boolean）僅用於存儲兩個值：true 和 false，也就是真和假，通常用於條件的判斷。代碼示例：
boolean flag = true;
02、byte
byte 的取值範圍在 -128 和 127 之間，包含 127。最小值為 -128，最大值為 127，默認值為 0。
在網絡傳輸的過程中，為了節省空間，常用字節來作為數據的傳輸方式。代碼示例：
byte a = 10;
byte b = -10;
03、short
short 的取值範圍在 -32,768 和 32,767 之間，包含 32,767。最小值為 -32,768，最大值為 32,767，默認值為 0。代碼示例：
short s = 10000;
short r = -5000;
04、int
int 的取值範圍在 -2,147,483,648（-2 ^ 31）和 2,147,483,647（2 ^ 31 -1）（含）之間，默認值為 0。如果沒有特殊需求，整形數據就用 int。代碼示例：
int a = 100000;
int b = -200000;
05、long
long 的取值範圍在 -9,223,372,036,854,775,808(-2^63) 和 9,223,372,036,854,775,807(2^63 -1)（含）之間，默認值為 0。如果 int 存儲不下，就用 long，整形數據就用 int。代碼示例：
long a = 100000L;
long b = -200000L;
為了和 int 作區分，long 型變量在聲明的時候，末尾要帶上大寫的“L”。不用小寫的“l”，是因為小寫的“l”容易和数字“1”混淆。
06、float
float 是單精度的浮點數，遵循 IEEE 754（二進制浮點數算術標準），取值範圍是無限的，默認值為 0.0f。float 不適合用於精確的數值，比如說貨幣。代碼示例：
float f1 = 234.5f;
為了和 double 作區分，float 型變量在聲明的時候，末尾要帶上小寫的“f”。不需要使用大寫的“F”，是因為小寫的“f”很容易辨別。
07、double
double 是雙精度的浮點數，遵循 IEEE 754（二進制浮點數算術標準），取值範圍也是無限的，默認值為 0.0。double 同樣不適合用於精確的數值，比如說貨幣。代碼示例：
double d1 = 12.3
那精確的數值用什麼表示呢？最好使用 BigDecimal，它可以表示一個任意大小且精度完全準確的浮點數。針對貨幣類型的數值，也可以先乘以 100 轉成整形進行處理。
Tips：單精度是這樣的格式，1 位符號，8 位指數，23 位小數，有效位數為 7 位。
雙精度是這樣的格式，1 位符號，11 位指數，52 為小數，有效位數為 16 位。
取值範圍取決於指數位，計算精度取決於小數位（尾數）。小數位越多，則能表示的數越大，那麼計算精度則越高。
一個數由若干位数字組成，其中影響測量精度的数字稱作有效数字，也稱有效數位。有效数字指科學計算中用以表示一個浮點數精度的那些数字。一般地，指一個用小數形式表示的浮點數中，從第一個非零的数字算起的所有数字。如 1.24 和 0.00124 的有效数字都有 3 位。
08、char
char 可以表示一個 16 位的 Unicode 字符，其值範圍在 ‘\u0000’（0）和 ‘\uffff’（65,535）（包含）之間。代碼示例：
char letterA = 'A'; // 用英文的單引號包裹住。
三、Java main() 方法簡介
每個程序都需要一個入口，對於 Java 程序來說，入口就是 main 方法。
public static void main(String[] args) {}
public、static、void 這 3 個關鍵字在前面的內容已經介紹過了，如果覺得回去找比較麻煩的話，這裏再貼一下：
-
public 關鍵字是另外一個訪問修飾符，除了可以聲明方法和變量（所有類可見），還可以聲明類。
main()方法必須聲明為 public。 -
static 關鍵字表示該變量或方法是靜態變量或靜態方法，可以直接通過類訪問，不需要實例化對象來訪問。
-
void 關鍵字用於指定方法沒有返回值。
另外，main 關鍵字為方法的名字，Java 虛擬機在執行程序時會尋找這個標識符；args 為 main() 方法的參數名，它的類型為一個 String 數組，也就是說，在使用 java 命令執行程序的時候，可以給 main() 方法傳遞字符串數組作為參數。
java HelloWorld 沉默王二 沉默王三
javac 命令用來編譯程序，java 命令用來執行程序，HelloWorld 為這段程序的類名，沉默王二和沉默王三為字符串數組，中間通過空格隔開，然後就可以在 main() 方法中通過 args[0] 和 args[1] 獲取傳遞的參數值了。
public class HelloWorld {
public static void main(String[] args) {
if ("沉默王二".equals(args[0])) {
}
if ("沉默王三".equals(args[1])) {
}
}
}
main() 方法的寫法並不是唯一的，還有其他幾種變體，儘管它們可能並不常見，可以簡單來了解一下。
第二種，把方括號 [] 往 args 靠近而不是 String 靠近：
public static void main(String []args) { }
第三種，把方括號 [] 放在 args 的右側：
public static void main(String args[]) { }
第四種，還可以把數組形式換成可變參數的形式：
public static void main(String...args) { }
第五種，在 main() 方法上添加另外一個修飾符 strictfp，用於強調在處理浮點數時的兼容性：
public strictfp static void main(String[] args) { }
也可以在 main() 方法上添加 final 關鍵字或者 synchronized 關鍵字。
第六種，還可以為 args 參數添加 final 關鍵字：
public static void main(final String[] args) { }
第七種，最複雜的一種，所有可以添加的關鍵字統統添加上：
final static synchronized strictfp void main(final String[] args) { }
當然了，並不需要為了裝逼特意把 main() 方法寫成上面提到的這些形式，使用 IDE 提供的默認形式就可以了。
四、Java 的流程控制語句
在 Java 中，有三種類型的流程控制語句：
-
條件分支，用於在兩個或者多個條件之間做出選擇，常見的有
if/else/else if、三元運算符和 switch 語句。 -
循環或者遍歷，常見的有 for、while 和 do-while。
-
break 和 continue，用於跳出循環或者跳過進入下一輪循環。
if 語句
if 語句的格式如下：
if(布爾表達式){
// 如果條件為 true，則執行這塊代碼
}
畫個流程圖表示一下：
來寫個示例：
public class IfExample {
public static void main(String[] args) {
int age = 20;
if (age < 30) {
System.out.println("青春年華");
}
}
}
輸出：
青春年華
if-else 語句
if-else 語句的格式如下:
if(布爾表達式){
// 條件為 true 時執行的代碼塊
}else{
// 條件為 false 時執行的代碼塊
}
畫個流程圖表示一下：
來寫個示例：
public class IfElseExample {
public static void main(String[] args) {
int age = 31;
if (age < 30) {
System.out.println("青春年華");
} else {
System.out.println("而立之年");
}
}
}
輸出：
而立之年
除了這個例子之外，還有一個判斷閏年（被 4 整除但不能被 100 整除或者被 400 整除）的例子：
public class LeapYear {
public static void main(String[] args) {
int year = 2020;
if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
System.out.println("閏年");
} else {
System.out.println("普通年份");
}
}
}
輸出：
閏年
如果執行語句比較簡單的話，可以使用三元運算符來代替 if-else 語句，如果條件為 true，返回 ? 後面 : 前面的值；如果條件為 false，返回 : 後面的值。
public class IfElseTernaryExample {
public static void main(String[] args) {
int num = 13;
String result = (num % 2 == 0) ? "偶數" : "奇數";
System.out.println(result);
}
}
輸出：
奇數
if-else-if 語句
if-else-if 語句的格式如下：
if(條件1){
// 條件1 為 true 時執行的代碼
}else if(條件2){
// 條件2 為 true 時執行的代碼
}
else if(條件3){
// 條件3 為 true 時執行的代碼
}
...
else{
// 以上條件均為 false 時執行的代碼
}
畫個流程圖表示一下：
來寫個示例：
public class IfElseIfExample {
public static void main(String[] args) {
int age = 31;
if (age < 30) {
System.out.println("青春年華");
} else if (age >= 30 && age < 40 ) {
System.out.println("而立之年");
} else if (age >= 40 && age < 50 ) {
System.out.println("不惑之年");
} else {
System.out.println("知天命");
}
}
}
輸出：
而立之年
if 嵌套語句
if 嵌套語句的格式如下：
if(外側條件){
// 外側條件為 true 時執行的代碼
if(內側條件){
// 內側條件為 true 時執行的代碼
}
}
畫個流程圖表示一下：
來寫個示例：
public class NestedIfExample {
public static void main(String[] args) {
int age = 20;
boolean isGirl = true;
if (age >= 20) {
if (isGirl) {
System.out.println("女生法定結婚年齡");
}
}
}
}
輸出：
女生法定結婚年齡
switch 語句的格式：
switch(變量) {
case 可選值1:
// 可選值1匹配后執行的代碼;
break; // 該關鍵字是可選項
case 可選值2:
// 可選值2匹配后執行的代碼;
break; // 該關鍵字是可選項
......
default: // 該關鍵字是可選項
// 所有可選值都不匹配后執行的代碼
}
-
變量可以有 1 個或者 N 個值。
-
值類型必須和變量類型是一致的，並且值是確定的。
-
值必須是唯一的，不能重複，否則編譯會出錯。
-
break 關鍵字是可選的，如果沒有，則執行下一個 case，如果有，則跳出 switch 語句。
-
default 關鍵字也是可選的。
畫個流程圖：
來個示例：
public class Switch1 {
public static void main(String[] args) {
int age = 20;
switch (age) {
case 20 :
System.out.println("上學");
break;
case 24 :
System.out.println("蘇州工作");
break;
case 30 :
System.out.println("洛陽工作");
break;
default:
System.out.println("未知");
break; // 可省略
}
}
}
輸出：
上學
當兩個值要執行的代碼相同時，可以把要執行的代碼寫在下一個 case 語句中，而上一個 case 語句中什麼也沒有，來看一下示例：
public class Switch2 {
public static void main(String[] args) {
String name = "沉默王二";
switch (name) {
case "詹姆斯":
System.out.println("籃球運動員");
break;
case "穆里尼奧":
System.out.println("足球教練");
break;
case "沉默王二":
case "沉默王三":
System.out.println("乒乓球愛好者");
break;
default:
throw new IllegalArgumentException(
"名字沒有匹配項");
}
}
}
輸出：
乒乓球愛好者
枚舉作為 switch 語句的變量也很常見，來看例子：
public class SwitchEnumDemo {
public enum PlayerTypes {
TENNIS,
FOOTBALL,
BASKETBALL,
UNKNOWN
}
public static void main(String[] args) {
System.out.println(createPlayer(PlayerTypes.BASKETBALL));
}
private static String createPlayer(PlayerTypes playerType) {
switch (playerType) {
case TENNIS:
return "網球運動員費德勒";
case FOOTBALL:
return "足球運動員C羅";
case BASKETBALL:
return "籃球運動員詹姆斯";
case UNKNOWN:
throw new IllegalArgumentException("未知");
default:
throw new IllegalArgumentException(
"運動員類型: " + playerType);
}
}
}
輸出：
籃球運動員詹姆斯
循環語句比較
| 比較方式 | for | while | do-while |
|---|---|---|---|
| 簡介 | for 循環的次數是固定的 | while 循環的次數是不固定的，並且需要條件為 true | do-while 循環的次數也不固定，但會至少執行一次循環，無聊條件是否為 true |
| 何時使用 | 循環次數固定的 | 循環次數是不固定的 | 循環次數不固定，並且循環體至少要執行一次 |
| 語法 | for(init:condition;++/–) {// 要執行的代碼} | while(condition){// 要執行的代碼} | do{//要執行的代碼}while(condition); |
普通的 for 循環
普通的 for 循環可以分為 4 個部分：
1）初始變量：循環開始執行時的初始條件。
2）條件：循環每次執行時要判斷的條件，如果為 true，就執行循環體；如果為 false，就跳出循環。當然了，條件是可選的，如果沒有條件，則會一直循環。
3）循環體：循環每次要執行的代碼塊，直到條件變為 false。
4）自增/自減：初識變量變化的方式。
來看一下普通 for 循環的格式：
for(初識變量;條件;自增/自減){
// 循環體
}
畫個流程圖：
來個示例：
public class ForExample {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println("沉默王二好帥啊");
}
}
}
輸出：
沉默王二好帥啊
沉默王二好帥啊
沉默王二好帥啊
沉默王二好帥啊
沉默王二好帥啊
循環語句還可以嵌套呢，這樣就可以打印出更好玩的呢。
public class PyramidForExample {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
for (int j = 0;j<= i;j++) {
System.out.print("");
}
System.out.println();
}
}
}
打印出什麼玩意呢？
for-each
for-each 循環通常用於遍曆數組和集合，它的使用規則比普通的 for 循環還要簡單，不需要初始變量，不需要條件，不需要下標來自增或者自減。來看一下語法：
for(元素類型 元素 : 數組或集合){
// 要執行的代碼
}
來看一下示例：
public class ForEachExample {
public static void main(String[] args) {
String[] strs = {"沉默王二", "一枚有趣的程序員"};
for (String str : strs) {
System.out.println(str);
}
}
}
輸出：
沉默王二
一枚有趣的程序員
無限 for 循環
想不想體驗一下無限 for 循環的威力，也就是死循環？
public class InfinitiveForExample {
public static void main(String[] args) {
for(;;){
System.out.println("停不下來。。。。");
}
}
}
輸出：
停不下來。。。。
停不下來。。。。
停不下來。。。。
停不下來。。。。
一旦運行起來，就停不下來了，除非強制停止。
while 循環
while(條件){
//循環體
}
畫個流程圖：
來個示例：
public class WhileExample {
public static void main(String[] args) {
int i = 0;
while (true) {
System.out.println("沉默王二");
i++;
if (i == 5) {
break;
}
}
}
}
猜猜會輸出幾次？
沉默王二
沉默王二
沉默王二
沉默王二
沉默王二
do-while 循環
do{
// 循環體
}while(提交);
畫個流程圖：
來個示例：
public class DoWhileExample {
public static void main(String[] args) {
int i = 0;
do {
System.out.println("沉默王二");
i++;
if (i == 5) {
break;
}
} while (true);
}
}
程序輸出結果如下所示：
沉默王二
沉默王二
沉默王二
沉默王二
沉默王二
break
break 關鍵字通常用於中斷循環或 switch 語句，它在指定條件下中斷程序的當前流程。如果是內部循環，則僅中斷內部循環。
可以將 break 關鍵字用於所有類型循環語句中，比如說 for 循環，while 循環，以及 do-while 循環。
來畫個流程圖感受一下：
用在 for 循環中的示例：
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break;
}
System.out.println(i);
}
用在嵌套 for 循環中的示例：
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (i == 2 && j == 2) {
break;
}
System.out.println(i + " " + j);
}
}
用在 while 循環中的示例：
int i = 1;
while (i <= 10) {
if (i == 5) {
i++;
break;
}
System.out.println(i);
i++;
}
用在 do-while 循環中的示例：
int j = 1;
do {
if (j == 5) {
j++;
break;
}
System.out.println(j);
j++;
} while (j <= 10);
continue
當我們需要在 for 循環或者 （do）while 循環中立即跳轉到下一個循環時，就可以使用 continue 關鍵字，通常用於跳過指定條件下的循環體，如果循環是嵌套的，僅跳過當前循環。
來個示例：
public class ContinueDemo {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
if (i == 5) {
// 使用 continue 關鍵字
continue;// 5 將會被跳過
}
System.out.println(i);
}
}
}
輸出：
1
2
3
4
6
7
8
9
10
5 真的被跳過了。
再來個循環嵌套的例子。
public class ContinueInnerDemo {
public static void main(String[] args) {
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= 3; j++) {
if (i == 2 && j == 2) {
// 當i=2，j=2時跳過
continue;
}
System.out.println(i + " " + j);
}
}
}
}
打印出什麼玩意呢？
1 1
1 2
1 3
2 1
2 3
3 1
3 2
3 3
“2 2” 沒有輸出，被跳過了。
再來看一下 while 循環時 continue 的使用示例：
public class ContinueWhileDemo {
public static void main(String[] args) {
int i = 1;
while (i <= 10) {
if (i == 5) {
i++;
continue;
}
System.out.println(i);
i++;
}
}
}
輸出：
1
2
3
4
6
7
8
9
10
注意：如果把 if 條件中的“i++”省略掉的話，程序就會進入死循環，一直在 continue。
最後，再來看一下 do-while 循環時 continue 的使用示例：
public class ContinueDoWhileDemo {
public static void main(String[] args) {
int i=1;
do{
if(i==5){
i++;
continue;
}
System.out.println(i);
i++;
}while(i<=10);
}
}
輸出：
1
2
3
4
6
7
8
9
10
注意：同樣的，如果把 if 條件中的“i++”省略掉的話，程序就會進入死循環，一直在 continue。
五、Java 包的簡介
在 Java 中，我們使用 package（包）對相關的類、接口和子包進行分組。這樣做的好處有：
- 使相關類型更容易查找
- 避免命名衝突，比如說 com.itwanger.Hello 和 com.itwangsan.Hello 不同
- 通過包和訪問權限控制符來限定類的可見性
01、創建一個包
package com.itwanger;
可以使用 package 關鍵字來定義一個包名，需要注意的是，這行代碼必須處於一個類中的第一行。強烈建議在包中聲明類，不要缺省，否則就失去了包結構的帶來的好處。
包的命名應該遵守以下規則：
- 應該全部是小寫字母
- 可以包含多個單詞，單詞之間使用“.”連接，比如說
java.lang - 名稱由公司名或者組織名確定，採用倒序的方式，比如說，我個人博客的域名是
www.itwanger.com，所以我創建的包名是就是com.itwanger.xxxx。
每個包或者子包都在磁盤上有自己的目錄結構，如果 Java 文件時在 com.itwanger.xxxx 包下，那麼該文件所在的目錄結構就應該是 com->itwanger->xxxx。
02、使用包
讓我們在名為 test 的子包里新建一個 Cmower 類：
package com.itwanger.test;
public class Cmower {
private String name;
private int age;
}
如果需要在另外一個包中使用 Cmower 類，就需要通過 import 關鍵字將其引入。有兩種方式可供選擇，第一種，使用 * 導入包下所有的類：
import com.itwanger.test.*;
第二種，使用類名導入該類：
import com.itwanger.test.Cmower;
Java 和第三方類庫提供了很多包可供使用，可以通過上述的方式導入類庫使用。
package com.itwanger.test;
import java.util.ArrayList;
import java.util.List;
public class CmowerTest {
public static void main(String[] args) {
List<Cmower> list = new ArrayList<>();
list.add(new Cmower());
}
}
03、全名
有時，我們可能會使用來自不同包下的兩個具有相同名稱的類。例如，我們可能同時使用 java.sql.Date 和 java.util.Date。當我們遇到命名衝突時，我們需要對至少一個類使用全名（包名+類名）。
List<com.itwanger.test.Cmower> list1 = new ArrayList<>();
list.add(new com.itwanger.test.Cmower());
六、Java 到底是值傳遞還是引用傳遞
將參數傳遞給方法有兩種常見的方式，一種是“值傳遞”，一種是“引用傳遞”。C 語言本身只支持值傳遞，它的衍生品 C++ 既支持值傳遞，也支持引用傳遞，而 Java 只支持值傳遞。
01、值傳遞 VS 引用傳遞
首先，我們必須要搞清楚，到底什麼是值傳遞，什麼是引用傳遞，否則，討論 Java 到底是值傳遞還是引用傳遞就顯得毫無意義。
當一個參數按照值的方式在兩個方法之間傳遞時，調用者和被調用者其實是用的兩個不同的變量——被調用者中的變量（原始值）是調用者中變量的一份拷貝，對它們當中的任何一個變量修改都不會影響到另外一個變量。
而當一個參數按照引用傳遞的方式在兩個方法之間傳遞時，調用者和被調用者其實用的是同一個變量，當該變量被修改時，雙方都是可見的。
Java 程序員之所以容易搞混值傳遞和引用傳遞，主要是因為 Java 有兩種數據類型，一種是基本類型，比如說 int，另外一種是引用類型，比如說 String。
基本類型的變量存儲的都是實際的值，而引用類型的變量存儲的是對象的引用——指向了對象在內存中的地址。值和引用存儲在 stack（棧）中，而對象存儲在 heap（堆）中。
之所以有這個區別，是因為：
- 棧的優勢是，存取速度比堆要快，僅次於直接位於 CPU 中的寄存器。但缺點是，棧中的數據大小與生存周期必須是確定的。
- 堆的優勢是可以動態地分配內存大小，生存周期也不必事先告訴編譯器，Java 的垃圾回收器會自動收走那些不再使用的數據。但由於要在運行時動態分配內存，存取速度較慢。
02、基本類型的參數傳遞
眾所周知，Java 有 8 種基本數據類型，分別是 int、long、byte、short、float、double 、char 和 boolean。它們的值直接存儲在棧中，每當作為參數傳遞時，都會將原始值（實參）複製一份新的出來，給形參用。形參將會在被調用方法結束時從棧中清除。
來看下面這段代碼：
public class PrimitiveTypeDemo {
public static void main(String[] args) {
int age = 18;
modify(age);
System.out.println(age);
}
private static void modify(int age1) {
age1 = 30;
}
}
1）main 方法中的 age 是基本類型，所以它的值 18 直接存儲在棧中。
2）調用 modify() 方法的時候，將為實參 age 創建一個副本（形參 age1），它的值也為 18，不過是在棧中的其他位置。
3）對形參 age 的任何修改都只會影響它自身而不會影響實參。
03、引用類型的參數傳遞
來看一段創建引用類型變量的代碼：
Writer writer = new Writer(18, "沉默王二");
writer 是對象嗎？還是對象的引用？為了搞清楚這個問題，我們可以把上面的代碼拆分為兩行代碼：
Writer writer;
writer = new Writer(18, "沉默王二");
假如 writer 是對象的話，就不需要通過 new 關鍵字創建對象了，對吧？那也就是說，writer 並不是對象，在“=”操作符執行之前，它僅僅是一個變量。那誰是對象呢？new Writer(18, "沉默王二")，它是對象，存儲於堆中；然後，“=”操作符將對象的引用賦值給了 writer 變量，於是 writer 此時應該叫對象引用，它存儲在棧中，保存了對象在堆中的地址。
每當引用類型作為參數傳遞時，都會創建一個對象引用（實參）的副本（形參），該形參保存的地址和實參一樣。
來看下面這段代碼：
public class ReferenceTypeDemo {
public static void main(String[] args) {
Writer a = new Writer(18);
Writer b = new Writer(18);
modify(a, b);
System.out.println(a.getAge());
System.out.println(b.getAge());
}
private static void modify(Writer a1, Writer b1) {
a1.setAge(30);
b1 = new Writer(18);
b1.setAge(30);
}
}
1）在調用 modify() 方法之前，實參 a 和 b 指向的對象是不一樣的，儘管 age 都為 18。
2）在調用 modify() 方法時，實參 a 和 b 都在棧中創建了一個新的副本，分別是 a1 和 b1，但指向的對象是一致的（a 和 a1 指向對象 a，b 和 b1 指向對象 b）。
3）在 modify() 方法中，修改了形參 a1 的 age 為 30，意味着對象 a 的 age 從 18 變成了 30，而實參 a 指向的也是對象 a，所以 a 的 age 也變成了 30；形參 b1 指向了一個新的對象，隨後 b1 的 age 被修改為 30。
修改 a1 的 age，意味着同時修改了 a 的 age，因為它們指向的對象是一個；修改 b1 的 age，對 b 卻沒有影響，因為它們指向的對象是兩個。
程序輸出的結果如下所示：
30
18
果然和我們的分析是吻合的。
七、Java 的類和對象
類和對象是 Java 中最基本的兩個概念，可以說撐起了面向對象編程（OOP）的一片天。對象可以是現實中看得見的任何物體（一隻特立獨行的豬），也可以是想象中的任何虛擬物體（能七十二變的孫悟空），Java 通過類（class）來定義這些物體，有什麼狀態（通過字段，或者叫成員變量定義，比如說豬的顏色是純色還是花色），有什麼行為（通過方法定義，比如說豬會吃，會睡覺）。
來，讓我來定義一個簡單的類給你看看。
public class Pig {
private String color;
public void eat() {
System.out.println("吃");
}
}
默認情況下，每個 Java 類都會有一個空的構造方法，儘管它在源代碼中是缺省的，但卻可以通過反編譯字節碼看到它。
public class Pig {
private String color;
public Pig() {
}
public void eat() {
System.out.println("吃");
}
}
沒錯，就是多出來的那個 public Pig() {}，參數是空的，方法體是空的。我們可以通過 new 關鍵字利用這個構造方法來創建一個對象，代碼如下所示：
Pig pig = new Pig();
當然了，我們也可以主動添加帶參的構造方法。
public class Pig {
private String color;
public Pig(String color) {
this.color = color;
}
public void eat() {
System.out.println("吃");
}
}
這時候，再查看反編譯后的字節碼時，你會發現缺省的無參構造方法消失了——和源代碼一模一樣。
public class Pig {
private String color;
public Pig(String color) {
this.color = color;
}
public void eat() {
System.out.println("吃");
}
}
這意味着無法通過 new Pig() 來創建對象了——編譯器會提醒你追加參數。
比如說你將代碼修改為 new Pig("純白色")，或者添加無參的構造方法。
public class Pig {
private String color;
public Pig(String color) {
this.color = color;
}
public Pig() {
}
public void eat() {
System.out.println("吃");
}
}
使用無參構造方法創建的對象狀態默認值為 null（color 字符串為引用類型），如果是基本類型的話，默認值為對應基本類型的默認值，比如說 int 為 0，更詳細的見下圖。
（圖片中有一處錯誤，boolean 的默認值為 false）
接下來，我們來創建多個 Pig 對象，它的顏色各不相同。
public class PigTest {
public static void main(String[] args) {
Pig pigNoColor = new Pig();
Pig pigWhite = new Pig("純白色");
Pig pigBlack = new Pig("純黑色");
}
}
你看，我們創建了 3 個不同花色的 Pig 對象，全部來自於一個類，由此可見類的重要性，只需要定義一次，就可以多次使用。
那假如我想改變對象的狀態呢？該怎麼辦？目前毫無辦法，因為沒有任何可以更改狀態的方法，直接修改 color 是行不通的，因為它的訪問權限修飾符是 private 的。
最好的辦法就是為 Pig 類追加 getter/setter 方法，就像下面這樣：
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
通過 setColor() 方法來修改，通過 getColor() 方法獲取狀態，它們的權限修飾符是 public 的。
Pig pigNoColor = new Pig();
pigNoColor.setColor("花色");
System.out.println(pigNoColor.getColor()); // 花色
為什麼要這樣設計呢？可以直接將 color 字段的訪問權限修飾符換成是 public 的啊，不就和 getter/setter 一樣的效果了嗎？
因為有些情況，某些字段是不允許被隨意修改的，它只有在對象創建的時候初始化一次，比如說豬的年齡，它只能每年長一歲（舉個例子），沒有月光寶盒讓它變回去。
private int age;
public int getAge() {
return age;
}
public void increaseAge() {
this.age++;
}
你看，age 就沒有 setter 方法，只有一個每年可以調用一次的 increaseAge() 方法和 getter 方法。如果把 age 的訪問權限修飾符更改為 public，age 就完全失去控制了，可以隨意將其重置為 0 或者負數。
訪問權限修飾符對於 Java 來說，非常重要，目前共有四種：public、private、protected 和 default（缺省）。
一個類只能使用 public 或者 default 修飾，public 修飾的類你之前已經見到過了，現在我來定義一個缺省權限修飾符的類給你欣賞一下。
class Dog {
}
哈哈，其實也沒啥可以欣賞的。缺省意味着這個類可以被同一個包下的其他類進行訪問；而 public 意味着這個類可以被所有包下的類進行訪問。
假如硬要通過 private 和 protected 來修飾類的話，編譯器會生氣的，它不同意。
private 可以用來修飾類的構造方法、字段和方法，只能被當前類進行訪問。protected 也可以用來修飾類的構造方法、字段和方法，但它的權限範圍更寬一些，可以被同一個包中的類進行訪問，或者當前類的子類。
可以通過下面這張圖來對比一下四個權限修飾符之間的差別：
- 同一個類中，不管是哪種權限修飾符，都可以訪問；
- 同一個包下，private 修飾的無法訪問；
- 子類可以訪問 public 和 protected 修飾的；
- public 修飾符面向世界，哈哈，可以被所有的地方訪問到。
八、Java 構造方法
假設現在有一個 Writer 類，它有兩個字段，姓名和年紀：
public class Writer {
private String name;
private int age;
@Override
public String toString() {
return "Writer{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
重寫了 toString() 方法，用於打印 Writer 類的詳情。由於沒有構造方法，意味着當我們創建 Writer 對象時，它的字段值並沒有初始化：
Writer writer = new Writer();
System.out.println(writer.toString());
輸出結果如下所示：
Writer{name='null', age=0}
name 是字符串類型，所以默認值為 null，age 為 int 類型，所以默認值為 0。
讓我們為 Writer 類主動加一個無參的構造方法：
public Writer() {
this.name = "";
this.age = 0;
}
構造方法也是一個方法，只不過它沒有返回值，默認返回創建對象的類型。需要注意的是，當前構造方法沒有參數，它被稱為無參構造方法。如果我們沒有主動創建無參構造方法的話，編譯器會隱式地自動添加一個無參的構造方法。這就是為什麼，一開始雖然沒有構造方法，卻可以使用 new Writer() 創建對象的原因，只不過，所有的字段都被初始化成了默認值。
接下來，讓我們添加一個有參的構造方法：
public Writer(String name, int age) {
this.name = name;
this.age = age;
}
現在，我們創建 Writer 對象的時候就可以通過對字段值初始化值了。
Writer writer1 = new Writer("沉默王二",18);
System.out.println(writer1.toString());
來看一下打印結果：
Writer{name='沉默王二', age=18}
可以根據字段的數量添加不同參數數量的構造方法，比如說，我們可以單獨為 name 字段添加一個構造方法：
public Writer(String name) {
this.name = name;
}
為了能夠兼顧 age 字段，我們可以通過 this 關鍵字調用其他的構造方法：
public Writer(String name) {
this(name,18);
}
把作者的年齡都默認初始化為 18。如果需要使用父類的構造方法，還可以使用 super 關鍵字，手冊後面有詳細的介紹。
九、Java 抽象類
當我們要完成的任務是確定的，但具體的方式需要隨後開個會投票的話，Java 的抽象類就派上用場了。這句話怎麼理解呢？搬個小板凳坐好，聽我來給你講講。
01、抽象類的 5 個關鍵點
1）定義抽象類的時候需要用到關鍵字 abstract，放在 class 關鍵字前。
public abstract class AbstractPlayer {
}
關於抽象類的命名，阿里出品的 Java 開發手冊上有強調，“抽象類命名要使用 Abstract 或 Base 開頭”，記住了哦。
2）抽象類不能被實例化，但可以有子類。
嘗試通過 new 關鍵字實例化的話，編譯器會報錯，提示“類是抽象的，不能實例化”。
通過 extends 關鍵字可以繼承抽象類，繼承后，BasketballPlayer 類就是 AbstractPlayer 的子類。
public class BasketballPlayer extends AbstractPlayer {
}
3）如果一個類定義了一個或多個抽象方法，那麼這個類必須是抽象類。
當在一個普通類（沒有使用 abstract 關鍵字修飾）中定義了抽象方法，編譯器就會有兩處錯誤提示。
第一處在類級別上，提醒你“這個類必須通過 abstract 關鍵字定義”，or 的那個信息沒必要，見下圖。
第二處在方法級別上，提醒你“抽象方法所在的類不是抽象的”，見下圖。
4）抽象類可以同時聲明抽象方法和具體方法，也可以什麼方法都沒有，但沒必要。就像下面這樣：
public abstract class AbstractPlayer {
abstract void play();
public void sleep() {
System.out.println("運動員也要休息而不是挑戰極限");
}
}
5）抽象類派生的子類必須實現父類中定義的抽象方法。比如說，抽象類中定義了 play() 方法，子類中就必須實現。
public class BasketballPlayer extends AbstractPlayer {
@Override
void play() {
System.out.println("我是張伯倫，籃球場上得過 100 分");
}
}
如果沒有實現的話，編譯器會提醒你“子類必須實現抽象方法”，見下圖。
02、什麼時候用抽象類
與抽象類息息相關的還有一個概念，就是接口，我們留到下一篇文章中詳細說，因為要說的知識點還是蠻多的。你現在只需要有這樣一個概念就好，接口是對行為的抽象，抽象類是對整個類（包含成員變量和行為）進行抽象。
（是不是有點明白又有點不明白，別著急，翹首以盼地等下一篇文章出爐吧）
除了接口之外，還有一個概念就是具體的類，就是不通過 abstract 修飾的普通類，見下面這段代碼中的定義。
public class BasketballPlayer {
public void play() {
System.out.println("我是詹姆斯，現役第一人");
}
}
有接口，有具體類，那什麼時候該使用抽象類呢？
1）我們希望一些通用的功能被多個子類復用。比如說，AbstractPlayer 抽象類中有一個普通的方法 sleep()，表明所有運動員都需要休息，那麼這個方法就可以被子類復用。
public abstract class AbstractPlayer {
public void sleep() {
System.out.println("運動員也要休息而不是挑戰極限");
}
}
雖然 AbstractPlayer 類可以不是抽象類——把 abstract 修飾符去掉也能滿足這種場景。但 AbstractPlayer 類可能還會有一個或者多個抽象方法。
BasketballPlayer 繼承了 AbstractPlayer 類，也就擁有了 sleep() 方法。
public class BasketballPlayer extends AbstractPlayer {
}
BasketballPlayer 對象可以直接調用 sleep() 方法：
BasketballPlayer basketballPlayer = new BasketballPlayer();
basketballPlayer.sleep();
FootballPlayer 繼承了 AbstractPlayer 類，也就擁有了 sleep() 方法。
public class FootballPlayer extends AbstractPlayer {
}
FootballPlayer 對象也可以直接調用 sleep() 方法：
FootballPlayer footballPlayer = new FootballPlayer();
footballPlayer.sleep();
2）我們需要在抽象類中定義好 API，然後在子類中擴展實現。比如說，AbstractPlayer 抽象類中有一個抽象方法 play()，定義所有運動員都可以從事某項運動，但需要對應子類去擴展實現。
public abstract class AbstractPlayer {
abstract void play();
}
BasketballPlayer 繼承了 AbstractPlayer 類，擴展實現了自己的 play() 方法。
public class BasketballPlayer extends AbstractPlayer {
@Override
void play() {
System.out.println("我是張伯倫，我籃球場上得過 100 分，");
}
}
FootballPlayer 繼承了 AbstractPlayer 類，擴展實現了自己的 play() 方法。
public class FootballPlayer extends AbstractPlayer {
@Override
void play() {
System.out.println("我是C羅，我能接住任意高度的頭球");
}
}
3）如果父類與子類之間的關係符合 is-a 的層次關係，就可以使用抽象類，比如說籃球運動員是運動員，足球運動員是運動員。
03、具體示例
為了進一步展示抽象類的特性，我們再來看一個具體的示例。假設現在有一個文件，裏面的內容非常簡單——“Hello World”，現在需要有一個讀取器將內容讀取出來，最好能按照大寫的方式，或者小寫的方式。
這時候，最好定義一個抽象類，比如說 BaseFileReader：
public abstract class BaseFileReader {
protected Path filePath;
protected BaseFileReader(Path filePath) {
this.filePath = filePath;
}
public List<String> readFile() throws IOException {
return Files.lines(filePath)
.map(this::mapFileLine).collect(Collectors.toList());
}
protected abstract String mapFileLine(String line);
}
filePath 為文件路徑，使用 protected 修飾，表明該成員變量可以在需要時被子類訪問。
readFile() 方法用來讀取文件，方法體裏面調用了抽象方法 mapFileLine()——需要子類擴展實現大小寫的方式。
你看，BaseFileReader 設計的就非常合理，並且易於擴展，子類只需要專註於具體的大小寫實現方式就可以了。
小寫的方式：
public class LowercaseFileReader extends BaseFileReader {
protected LowercaseFileReader(Path filePath) {
super(filePath);
}
@Override
protected String mapFileLine(String line) {
return line.toLowerCase();
}
}
大寫的方式：
public class UppercaseFileReader extends BaseFileReader {
protected UppercaseFileReader(Path filePath) {
super(filePath);
}
@Override
protected String mapFileLine(String line) {
return line.toUpperCase();
}
}
你看，從文件裏面一行一行讀取內容的代碼被子類復用了——抽象類 BaseFileReader 類中定義的普通方法 readFile()。與此同時，子類只需要專註於自己該做的工作，LowercaseFileReader 以小寫的方式讀取文件內容，UppercaseFileReader 以大寫的方式讀取文件內容。
接下來，我們來新建一個測試類 FileReaderTest：
public class FileReaderTest {
public static void main(String[] args) throws URISyntaxException, IOException {
URL location = FileReaderTest.class.getClassLoader().getResource("helloworld.txt");
Path path = Paths.get(location.toURI());
BaseFileReader lowercaseFileReader = new LowercaseFileReader(path);
BaseFileReader uppercaseFileReader = new UppercaseFileReader(path);
System.out.println(lowercaseFileReader.readFile());
System.out.println(uppercaseFileReader.readFile());
}
}
項目的 resource 目錄下有一個文本文件，名字叫 helloworld.txt。
可以通過 ClassLoader.getResource() 的方式獲取到該文件的 URI 路徑，然後就可以使用 LowercaseFileReader 和 UppercaseFileReader 兩種方式讀取到文本內容了。
輸出結果如下所示：
[hello world]
[HELLO WORLD]
十、Java 接口
對於面向對象編程來說，抽象是一個極具魅力的特徵。如果一個程序員的抽象思維很差，那他在編程中就會遇到很多困難，無法把業務變成具體的代碼。在 Java 中，可以通過兩種形式來達到抽象的目的，一種是抽象類，另外一種就是接口。
如果你現在就想知道抽象類與接口之間的區別，我可以提前給你說一個：
- 一個類只能繼承一個抽象類，但卻可以實現多個接口。
當然了，在沒有搞清楚接口到底是什麼，它可以做什麼之前，這個區別理解起來會有點難度。
01、接口是什麼
接口是通過 interface 關鍵字定義的，它可以包含一些常量和方法，來看下面這個示例。
public interface Electronic {
// 常量
String LED = "LED";
// 抽象方法
int getElectricityUse();
// 靜態方法
static boolean isEnergyEfficient(String electtronicType) {
return electtronicType.equals(LED);
}
// 默認方法
default void printDescription() {
System.out.println("电子");
}
}
1）接口中定義的變量會在編譯的時候自動加上 public static final 修飾符，也就是說 LED 變量其實是一個常量。
Java 官方文檔上有這樣的聲明：
Every field declaration in the body of an interface is implicitly public, static, and final.
換句話說，接口可以用來作為常量類使用，還能省略掉 public static final，看似不錯的一種選擇，對吧？
不過，這種選擇並不可取。因為接口的本意是對方法進行抽象，而常量接口會對子類中的變量造成命名空間上的“污染”。
2）沒有使用 private、default 或者 static 關鍵字修飾的方法是隱式抽象的，在編譯的時候會自動加上 public abstract 修飾符。也就是說 getElectricityUse() 其實是一個抽象方法，沒有方法體——這是定義接口的本意。
3）從 Java 8 開始，接口中允許有靜態方法，比如說 isEnergyEfficient() 方法。
靜態方法無法由（實現了該接口的）類的對象調用，它只能通過接口的名字來調用，比如說 Electronic.isEnergyEfficient("LED")。
接口中定義靜態方法的目的是為了提供一種簡單的機制，使我們不必創建對象就能調用方法，從而提高接口的競爭力。
4）接口中允許定義 default 方法也是從 Java 8 開始的，比如說 printDescription()，它始終由一個代碼塊組成，為實現該接口而不覆蓋該方法的類提供默認實現，也就是說，無法直接使用一個“;”號來結束默認方法——編譯器會報錯的。
允許在接口中定義默認方法的理由是很充分的，因為一個接口可能有多個實現類，這些類就必須實現接口中定義的抽象類，否則編譯器就會報錯。假如我們需要在所有的實現類中追加某個具體的方法，在沒有 default 方法的幫助下，我們就必須挨個對實現類進行修改。
來看一下 Electronic 接口反編譯后的字節碼吧，你會發現，接口中定義的所有變量或者方法，都會自動添加上 public 關鍵字——假如你想知道編譯器在背後都默默做了哪些輔助，記住反編譯字節碼就對了。
public interface Electronic
{
public abstract int getElectricityUse();
public static boolean isEnergyEfficient(String electtronicType)
{
return electtronicType.equals("LED");
}
public void printDescription()
{
System.out.println("\u7535\u5B50");
}
public static final String LED = "LED";
}
有些讀者可能會問，“二哥，為什麼我反編譯后的字節碼和你的不一樣，你用了什麼反編譯工具？”其實沒有什麼秘密，微信搜「沉默王二」回復關鍵字「JAD」就可以免費獲取了，超級好用。
02、定義接口的注意事項
由之前的例子我們就可以得出下面這些結論：
- 接口中允許定義變量
- 接口中允許定義抽象方法
- 接口中允許定義靜態方法（Java 8 之後）
- 接口中允許定義默認方法（Java 8 之後）
除此之外，我們還應該知道：
1）接口不允許直接實例化。
需要定義一個類去實現接口，然後再實例化。
public class Computer implements Electronic {
public static void main(String[] args) {
new Computer();
}
@Override
public int getElectricityUse() {
return 0;
}
}
2）接口可以是空的，既不定義變量，也不定義方法。
public interface Serializable {
}
Serializable 是最典型的一個空的接口，我之前分享過一篇文章《Java Serializable：明明就一個空的接口嘛》，感興趣的讀者可以去我的個人博客看一看，你就明白了空接口的意義。
http://www.itwanger.com/java/2019/11/14/java-serializable.html
3）不要在定義接口的時候使用 final 關鍵字，否則會報編譯錯誤，因為接口就是為了讓子類實現的，而 final 阻止了這種行為。
4）接口的抽象方法不能是 private、protected 或者 final。
5）接口的變量是隱式 public static final，所以其值無法改變。
03、接口可以做什麼
1）使某些實現類具有我們想要的功能，比如說，實現了 Cloneable 接口的類具有拷貝的功能，實現了 Comparable 或者 Comparator 的類具有比較功能。
Cloneable 和 Serializable 一樣，都屬於標記型接口，它們內部都是空的。實現了 Cloneable 接口的類可以使用 Object.clone() 方法，否則會拋出 CloneNotSupportedException。
public class CloneableTest implements Cloneable {
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public static void main(String[] args) throws CloneNotSupportedException {
CloneableTest c1 = new CloneableTest();
CloneableTest c2 = (CloneableTest) c1.clone();
}
}
運行后沒有報錯。現在把 implements Cloneable 去掉。
public class CloneableTest {
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public static void main(String[] args) throws CloneNotSupportedException {
CloneableTest c1 = new CloneableTest();
CloneableTest c2 = (CloneableTest) c1.clone();
}
}
運行后拋出 CloneNotSupportedException：
Exception in thread "main" java.lang.CloneNotSupportedException: com.cmower.baeldung.interface1.CloneableTest
at java.base/java.lang.Object.clone(Native Method)
at com.cmower.baeldung.interface1.CloneableTest.clone(CloneableTest.java:6)
at com.cmower.baeldung.interface1.CloneableTest.main(CloneableTest.java:11)
至於 Comparable 和 Comparator 的用法，感興趣的讀者可以參照我之前寫的另外一篇文章《來吧，一文徹底搞懂Java中的Comparable和Comparator》。
http://www.itwanger.com/java/2020/01/04/java-comparable-comparator.html
2）Java 原則上只支持單一繼承，但通過接口可以實現多重繼承的目的。
可能有些讀者會問，“二哥，為什麼 Java 只支持單一繼承？”簡單來解釋一下。
如果有兩個類共同繼承（extends）一個有特定方法的父類，那麼該方法會被兩個子類重寫。然後，如果你決定同時繼承這兩個子類，那麼在你調用該重寫方法時，編譯器不能識別你要調用哪個子類的方法。這也正是著名的菱形問題，見下圖。
ClassC 同時繼承了 ClassA 和 ClassB，ClassC 的對象在調用 ClassA 和 ClassB 中重載的方法時，就不知道該調用 ClassA 的方法，還是 ClassB 的方法。
接口沒有這方面的困擾。來定義兩個接口，Fly 會飛，Run 會跑。
public interface Fly {
void fly();
}
public interface Run {
void run();
}
然後讓一個類同時實現這兩個接口。
public class Pig implements Fly,Run{
@Override
public void fly() {
System.out.println("會飛的豬");
}
@Override
public void run() {
System.out.println("會跑的豬");
}
}
這就在某種形式上達到了多重繼承的目的：現實世界里，豬的確只會跑，但在雷軍的眼裡，站在風口的豬就會飛，這就需要賦予這隻豬更多的能力，通過抽象類是無法實現的，只能通過接口。
3）實現多態。
什麼是多態呢？通俗的理解，就是同一個事件發生在不同的對象上會產生不同的結果，鼠標左鍵點擊窗口上的 X 號可以關閉窗口，點擊超鏈接卻可以打開新的網頁。
多態可以通過繼承（extends）的關係實現，也可以通過接口的形式實現。來看這樣一個例子。
Shape 是表示一個形狀。
public interface Shape {
String name();
}
圓是一個形狀。
public class Circle implements Shape {
@Override
public String name() {
return "圓";
}
}
正方形也是一個形狀。
public class Square implements Shape {
@Override
public String name() {
return "正方形";
}
}
然後來看測試類。
List<Shape> shapes = new ArrayList<>();
Shape circleShape = new Circle();
Shape squareShape = new Square();
shapes.add(circleShape);
shapes.add(squareShape);
for (Shape shape : shapes) {
System.out.println(shape.name());
}
多態的存在 3 個前提：
1、要有繼承關係，Circle 和 Square 都實現了 Shape 接口
2、子類要重寫父類的方法，Circle 和 Square 都重寫了 name() 方法
3、父類引用指向子類對象，circleShape 和 squareShape 的類型都為 Shape，但前者指向的是 Circle 對象，後者指向的是 Square 對象。
然後，我們來看一下測試結果：
圓
正方形
也就意味着，儘管在 for 循環中，shape 的類型都為 Shape，但在調用 name() 方法的時候，它知道 Circle 對象應該調用 Circle 類的 name() 方法，Square 對象應該調用 Square 類的 name() 方法。
04、接口與抽象類的區別
好了，關於接口的一切，你應該都搞清楚了。現在回到讀者春夏秋冬的那條留言，“兄弟，說說抽象類和接口之間的區別？”
1）語法層面上
- 接口中不能有 public 和 protected 修飾的方法，抽象類中可以有。
- 接口中的變量只能是隱式的常量，抽象類中可以有任意類型的變量。
- 一個類只能繼承一個抽象類，但卻可以實現多個接口。
2）設計層面上
抽象類是對類的一種抽象，繼承抽象類的類和抽象類本身是一種 is-a 的關係。
接口是對類的某種行為的一種抽象，接口和類之間並沒有很強的關聯關係，所有的類都可以實現 Serializable 接口，從而具有序列化的功能。
就這麼多吧，能說道這份上，我相信面試官就不會為難你了。
十一、Java 繼承
在 Java 中，一個類可以繼承另外一個類或者實現多個接口，我想這一點，大部分的讀者應該都知道了。還有一點，我不確定大家是否知道，就是一個接口也可以繼承另外一個接口，就像下面這樣：
public interface OneInterface extends Cloneable {
}
這樣做有什麼好處呢？我想有一部分讀者應該已經猜出來了，就是實現了 OneInterface 接口的類，也可以使用 Object.clone() 方法了。
public class TestInterface implements OneInterface {
public static void main(String[] args) throws CloneNotSupportedException {
TestInterface c1 = new TestInterface();
TestInterface c2 = (TestInterface) c1.clone();
}
}
除此之外，我們還可以在 OneInterface 接口中定義其他一些抽象方法（比如說深拷貝），使該接口擁有 Cloneable 所不具有的功能。
public interface OneInterface extends Cloneable {
void deepClone();
}
看到了吧？這就是繼承的好處：子接口擁有了父接口的方法，使得子接口具有了父接口相同的行為；同時，子接口還可以在此基礎上自由發揮，添加屬於自己的行為。
以上，把“接口”換成“類”，結論同樣成立。讓我們來定義一個普通的父類 Wanger：
public class Wanger {
int age;
String name;
void write() {
System.out.println("我寫了本《基督山伯爵》");
}
}
然後，我們再來定義一個子類 Wangxiaoer，使用關鍵字 extends 來繼承父類 Wanger：
public class Wangxiaoer extends Wanger{
@Override
void write() {
System.out.println("我寫了本《茶花女》");
}
}
我們可以將通用的方法和成員變量放在父類中，達到代碼復用的目的；然後將特殊的方法和成員變量放在子類中，除此之外，子類還可以覆蓋父類的方法（比如write() 方法）。這樣，子類也就煥發出了新的生命力。
Java 只支持單一繼承，這一點，我在上一篇接口的文章中已經提到過了。如果一個類在定義的時候沒有使用 extends 關鍵字，那麼它隱式地繼承了 java.lang.Object 類——在我看來，這恐怕就是 Java 號稱萬物皆對象的真正原因了。
那究竟子類繼承了父類的什麼呢？
子類可以繼承父類的非 private 成員變量，為了驗證這一點，我們來看下面這個示例。
public class Wanger {
String defaultName;
private String privateName;
public String publicName;
protected String protectedName;
}
父類 Wanger 定義了四種類型的成員變量，缺省的 defaultName、私有的 privateName、共有的 publicName、受保護的 protectedName。
在子類 Wangxiaoer 中定義一個測試方法 testVariable()：
可以確認，除了私有的 privateName，其他三種類型的成員變量都可以繼承到。
同理，子類可以繼承父類的非 private 方法，為了驗證這一點，我們來看下面這個示例。
public class Wanger {
void write() {
}
private void privateWrite() {
}
public void publicWrite() {
}
protected void protectedWrite() {
}
}
父類 Wanger 定義了四種類型的方法，缺省的 write、私有的 privateWrite()、共有的 publicWrite()、受保護的 protectedWrite()。
在子類 Wangxiaoer 中定義一個 main 方法，並使用 new 關鍵字新建一個子類對象：
可以確認，除了私有的 privateWrite()，其他三種類型的方法都可以繼承到。
不過，子類無法繼承父類的構造方法。如果父類的構造方法是帶有參數的，代碼如下所示：
public class Wanger {
int age;
String name;
public Wanger(int age, String name) {
this.age = age;
this.name = name;
}
}
則必須在子類的構造器中顯式地通過 super 關鍵字進行調用，否則編譯器將提示以下錯誤：
修復后的代碼如下所示：
public class Wangxiaoer extends Wanger{
public Wangxiaoer(int age, String name) {
super(age, name);
}
}
is-a 是繼承的一個明顯特徵，就是說子類的對象引用類型可以是一個父類類型。
public class Wangxiaoer extends Wanger{
public static void main(String[] args) {
Wanger wangxiaoer = new Wangxiaoer();
}
}
同理，子接口的實現類的對象引用類型也可以是一個父接口類型。
public interface OneInterface extends Cloneable {
}
public class TestInterface implements OneInterface {
public static void main(String[] args) {
Cloneable c1 = new TestInterface();
}
}
儘管一個類只能繼承一個類，但一個類卻可以實現多個接口，這一點，我在上一篇文章也提到過了。另外，還有一點我也提到了，就是 Java 8 之後，接口中可以定義 default 方法，這很方便，但也帶來了新的問題：
如果一個類實現了多個接口，而這些接口中定義了相同簽名的 default 方法，那麼這個類就要重寫該方法，否則編譯無法通過。
FlyInterface 是一個會飛的接口，裏面有一個簽名為 sleep() 的默認方法：
public interface FlyInterface {
void fly();
default void sleep() {
System.out.println("睡着飛");
}
}
RunInterface 是一個會跑的接口，裏面也有一個簽名為 sleep() 的默認方法：
public interface RunInterface {
void run();
default void sleep() {
System.out.println("睡着跑");
}
}
Pig 類實現了 FlyInterface 和 RunInterface 兩個接口，但這時候編譯出錯了。
原本，default 方法就是為實現該接口而不覆蓋該方法的類提供默認實現的，現在，相同方法簽名的 sleep() 方法把編譯器搞懵逼了，只能重寫了。
public class Pig implements FlyInterface, RunInterface {
@Override
public void fly() {
System.out.println("會飛的豬");
}
@Override
public void sleep() {
System.out.println("只能重寫了");
}
@Override
public void run() {
System.out.println("會跑的豬");
}
}
類雖然不能繼承多個類，但接口卻可以繼承多個接口，這一點，我不知道有沒有觸及到一些讀者的知識盲區。
public interface WalkInterface extends FlyInterface,RunInterface{
void walk();
}
十二、this 關鍵字
在 Java 中，this 關鍵字指的是當前對象（它的方法正在被調用）的引用，能理解吧，各位親？不理解的話，我們繼續往下看。
看完再不明白，你過來捶爆我，我保證不還手，只要不打臉。
01、消除字段歧義
我敢賭一毛錢，所有的讀者，不管男女老少，應該都知道這種用法，畢竟寫構造方法的時候經常用啊。誰要不知道，過來，我給你發一毛錢紅包，只要你臉皮夠厚。
public class Writer {
private int age;
private String name;
public Writer(int age, String name) {
this.age = age;
this.name = name;
}
}
Writer 類有兩個成員變量，分別是 age 和 name，在使用有參構造函數的時候，如果參數名和成員變量的名字相同，就需要使用 this 關鍵字消除歧義：this.age 是指成員變量，age 是指構造方法的參數。
02、引用類的其他構造方法
當一個類的構造方法有多個，並且它們之間有交集的話，就可以使用 this 關鍵字來調用不同的構造方法，從而減少代碼量。
比如說，在無參構造方法中調用有參構造方法：
public class Writer {
private int age;
private String name;
public Writer(int age, String name) {
this.age = age;
this.name = name;
}
public Writer() {
this(18, "沉默王二");
}
}
也可以在有參構造方法中調用無參構造方法：
public class Writer {
private int age;
private String name;
public Writer(int age, String name) {
this();
this.age = age;
this.name = name;
}
public Writer() {
}
}
需要注意的是，this() 必須是構造方法中的第一條語句，否則就會報錯。
03、作為參數傳遞
在下例中，有一個無參的構造方法，裏面調用了 print() 方法，參數只有一個 this 關鍵字。
public class ThisTest {
public ThisTest() {
print(this);
}
private void print(ThisTest thisTest) {
System.out.println("print " +thisTest);
}
public static void main(String[] args) {
ThisTest test = new ThisTest();
System.out.println("main " + test);
}
}
來打印看一下結果：
print com.cmower.baeldung.this1.ThisTest@573fd745
main com.cmower.baeldung.this1.ThisTest@573fd745
從結果中可以看得出來，this 就是我們在 main() 方法中使用 new 關鍵字創建的 ThisTest 對象。
04、鏈式調用
學過 JavaScript，或者 jQuery 的讀者可能對鏈式調用比較熟悉，類似於 a.b().c().d()，彷彿能無窮無盡調用下去。
在 Java 中，對應的專有名詞叫 Builder 模式，來看一個示例。
public class Writer {
private int age;
private String name;
private String bookName;
public Writer(WriterBuilder builder) {
this.age = builder.age;
this.name = builder.name;
this.bookName = builder.bookName;
}
public static class WriterBuilder {
public String bookName;
private int age;
private String name;
public WriterBuilder(int age, String name) {
this.age = age;
this.name = name;
}
public WriterBuilder writeBook(String bookName) {
this.bookName = bookName;
return this;
}
public Writer build() {
return new Writer(this);
}
}
}
Writer 類有三個成員變量，分別是 age、name 和 bookName，還有它們仨對應的一個構造方法，參數是一個內部靜態類 WriterBuilder。
內部類 WriterBuilder 也有三個成員變量，和 Writer 類一致，不同的是，WriterBuilder 類的構造方法裏面只有 age 和 name 賦值了，另外一個成員變量 bookName 通過單獨的方法 writeBook() 來賦值，注意，該方法的返回類型是 WriterBuilder，最後使用 return 返回了 this 關鍵字。
最後的 build() 方法用來創建一個 Writer 對象，參數為 this 關鍵字，也就是當前的 WriterBuilder 對象。
這時候，創建 Writer 對象就可以通過鏈式調用的方式。
Writer writer = new Writer.WriterBuilder(18,"沉默王二")
.writeBook("《Web全棧開發進階之路》")
.build();
05、在內部類中訪問外部類對象
說實話，自從 Java 8 的函數式編程出現后，就很少用到 this 在內部類中訪問外部類對象了。來看一個示例：
public class ThisInnerTest {
private String name;
class InnerClass {
public InnerClass() {
ThisInnerTest thisInnerTest = ThisInnerTest.this;
String outerName = thisInnerTest.name;
}
}
}
在內部類 InnerClass 的構造方法中，通過外部類.this 可以獲取到外部類對象，然後就可以使用外部類的成員變量了，比如說 name。
十三、super 關鍵字
簡而言之，super 關鍵字就是用來訪問父類的。
先來看父類：
public class SuperBase {
String message = "父類";
public SuperBase(String message) {
this.message = message;
}
public SuperBase() {
}
public void printMessage() {
System.out.println(message);
}
}
再來看子類：
public class SuperSub extends SuperBase {
String message = "子類";
public SuperSub(String message) {
super(message);
}
public SuperSub() {
super.printMessage();
printMessage();
}
public void getParentMessage() {
System.out.println(super.message);
}
public void printMessage() {
System.out.println(message);
}
}
1）super 關鍵字可用於訪問父類的構造方法
你看，子類可以通過 super(message) 來調用父類的構造方法。現在來新建一個 SuperSub 對象，看看輸出結果是什麼：
SuperSub superSub = new SuperSub("子類的message");
new 關鍵字在調用構造方法創建子類對象的時候，會通過 super 關鍵字初始化父類的 message，所以此此時父類的 message 會輸出“子類的message”。
2）super 關鍵字可以訪問父類的變量
上述例子中的 SuperSub 類中就有，getParentMessage() 通過 super.message 方法父類的同名成員變量 message。
3）當方法發生重寫時，super 關鍵字可以訪問父類的同名方法
上述例子中的 SuperSub 類中就有，無參的構造方法 SuperSub() 中就使用 super.printMessage() 調用了父類的同名方法。
十四、重寫和重載
先來看一段重寫的代碼吧。
class LaoWang{
public void write() {
System.out.println("老王寫了一本《基督山伯爵》");
}
}
public class XiaoWang extends LaoWang {
@Override
public void write() {
System.out.println("小王寫了一本《茶花女》");
}
}
重寫的兩個方法名相同，方法參數的個數也相同；不過一個方法在父類中，另外一個在子類中。就好像父類 LaoWang 有一個 write() 方法（無參），方法體是寫一本《基督山伯爵》；子類 XiaoWang 重寫了父類的 write() 方法（無參），但方法體是寫一本《茶花女》。
來寫一段測試代碼。
public class OverridingTest {
public static void main(String[] args) {
LaoWang wang = new XiaoWang();
wang.write();
}
}
大家猜結果是什麼？
小王寫了一本《茶花女》
在上面的代碼中，們聲明了一個類型為 LaoWang 的變量 wang。在編譯期間，編譯器會檢查 LaoWang 類是否包含了 write() 方法，發現 LaoWang 類有，於是編譯通過。在運行期間，new 了一個 XiaoWang 對象，並將其賦值給 wang，此時 Java 虛擬機知道 wang 引用的是 XiaoWang 對象，所以調用的是子類 XiaoWang 中的 write() 方法而不是父類 LaoWang 中的 write() 方法，因此輸出結果為“小王寫了一本《茶花女》”。
再來看一段重載的代碼吧。
class LaoWang{
public void read() {
System.out.println("老王讀了一本《Web全棧開發進階之路》");
}
public void read(String bookname) {
System.out.println("老王讀了一本《" + bookname + "》");
}
}
重載的兩個方法名相同，但方法參數的個數不同，另外也不涉及到繼承，兩個方法在同一個類中。就好像類 LaoWang 有兩個方法，名字都是 read()，但一個有參數（書名），另外一個沒有（只能讀寫死的一本書）。
來寫一段測試代碼。
public class OverloadingTest {
public static void main(String[] args) {
LaoWang wang = new LaoWang();
wang.read();
wang.read("金");
}
}
這結果就不用猜了。變量 wang 的類型為 LaoWang，wang.read() 調用的是無參的 read() 方法，因此先輸出“老王讀了一本《Web全棧開發進階之路》”；wang.read("金") 調用的是有參的 read(bookname) 方法，因此後輸出“老王讀了一本《》”。在編譯期間，編譯器就知道這兩個 read() 方法時不同的，因為它們的方法簽名（=方法名稱+方法參數）不同。
簡單的來總結一下：
1）編譯器無法決定調用哪個重寫的方法，因為只從變量的類型上是無法做出判斷的，要在運行時才能決定；但編譯器可以明確地知道該調用哪個重載的方法，因為引用類型是確定的，參數個數決定了該調用哪個方法。
2）多態針對的是重寫，而不是重載。
哎，後悔啊，早年我要是能把這道面試題吃透的話，也不用被老馬刁難了。吟一首詩感慨一下人生吧。
青青園中葵，朝露待日晞。
陽春布德澤，萬物生光輝。
常恐秋節至，焜黃華恭弘=叶 恭弘衰。
百川東到海，何時復西歸?
少壯不努力，老大徒傷悲
另外，我想要告訴大家的是，重寫（Override）和重載（Overload）是 Java 中兩個非常重要的概念，新手經常會被它們倆迷惑，因為它們倆的英文名字太像了，中文翻譯也只差一個字。難，太難了。
十五、static 關鍵字
先來個提綱挈領（唉呀媽呀，成語區博主上線了）吧：
static 關鍵字可用於變量、方法、代碼塊和內部類，表示某個特定的成員只屬於某個類本身，而不是該類的某個對象。
01、靜態變量
靜態變量也叫類變量，它屬於一個類，而不是這個類的對象。
public class Writer {
private String name;
private int age;
public static int countOfWriters;
public Writer(String name, int age) {
this.name = name;
this.age = age;
countOfWriters++;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
其中，countOfWriters 被稱為靜態變量，它有別於 name 和 age 這兩個成員變量，因為它前面多了一個修飾符 static。
這意味着無論這個類被初始化多少次，靜態變量的值都會在所有類的對象中共享。
Writer w1 = new Writer("沉默王二",18);
Writer w2 = new Writer("沉默王三",16);
System.out.println(Writer.countOfWriters);
按照上面的邏輯，你應該能推理得出，countOfWriters 的值此時應該為 2 而不是 1。從內存的角度來看，靜態變量將會存儲在 Java 虛擬機中一個名叫“Metaspace”（元空間，Java 8 之後）的特定池中。
靜態變量和成員變量有着很大的不同，成員變量的值屬於某個對象，不同的對象之間，值是不共享的；但靜態變量不是的，它可以用來統計對象的數量，因為它是共享的。就像上面例子中的 countOfWriters，創建一個對象的時候，它的值為 1，創建兩個對象的時候，它的值就為 2。
簡單小結一下：
1）由於靜態變量屬於一個類，所以不要通過對象引用來訪問，而應該直接通過類名來訪問；
2）不需要初始化類就可以訪問靜態變量。
public class WriterDemo {
public static void main(String[] args) {
System.out.println(Writer.countOfWriters); // 輸出 0
}
}
02、靜態方法
靜態方法也叫類方法，它和靜態變量類似，屬於一個類，而不是這個類的對象。
public static void setCountOfWriters(int countOfWriters) {
Writer.countOfWriters = countOfWriters;
}
setCountOfWriters() 就是一個靜態方法，它由 static 關鍵字修飾。
如果你用過 java.lang.Math 類或者 Apache 的一些工具類（比如說 StringUtils）的話，對靜態方法一定不會感動陌生。
Math 類的幾乎所有方法都是靜態的，可以直接通過類名來調用，不需要創建類的對象。
簡單小結一下：
1）Java 中的靜態方法在編譯時解析，因為靜態方法不能被重寫（方法重寫發生在運行時階段，為了多態）。
2）抽象方法不能是靜態的。
3）靜態方法不能使用 this 和 super 關鍵字。
4）成員方法可以直接訪問其他成員方法和成員變量。
5）成員方法也可以直接方法靜態方法和靜態變量。
6）靜態方法可以訪問所有其他靜態方法和靜態變量。
7）靜態方法無法直接訪問成員方法和成員變量。
03、靜態代碼塊
靜態代碼塊可以用來初始化靜態變量，儘管靜態方法也可以在聲明的時候直接初始化，但有些時候，我們需要多行代碼來完成初始化。
public class StaticBlockDemo {
public static List<String> writes = new ArrayList<>();
static {
writes.add("沉默王二");
writes.add("沉默王三");
writes.add("沉默王四");
System.out.println("第一塊");
}
static {
writes.add("沉默王五");
writes.add("沉默王六");
System.out.println("第二塊");
}
}
writes 是一個靜態的 ArrayList，所以不太可能在聲明的時候完成初始化，因此需要在靜態代碼塊中完成初始化。
簡單小結一下：
1）一個類可以有多個靜態代碼塊。
2）靜態代碼塊的解析和執行順序和它在類中的位置保持一致。為了驗證這個結論，可以在 StaticBlockDemo 類中加入空的 main 方法，執行完的結果如下所示：
第一塊
第二塊
04、靜態內部類
Java 允許我們在一個類中聲明一個內部類，它提供了一種令人信服的方式，允許我們只在一個地方使用一些變量，使代碼更具有條理性和可讀性。
常見的內部類有四種，成員內部類、局部內部類、匿名內部類和靜態內部類，限於篇幅原因，前三種不在我們本次文章的討論範圍，以後有機會再細說。
public class Singleton {
private Singleton() {}
private static class SingletonHolder {
public static final Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
}
以上這段代碼是不是特別熟悉，對，這就是創建單例的一種方式，第一次加載 Singleton 類時並不會初始化 instance，只有第一次調用 getInstance() 方法時 Java 虛擬機才開始加載 SingletonHolder 並初始化 instance，這樣不僅能確保線程安全也能保證 Singleton 類的唯一性。不過，創建單例更優雅的一種方式是使用枚舉。
簡單小結一下：
1）靜態內部類不能訪問外部類的所有成員變量。
2）靜態內部類可以訪問外部類的所有靜態變量，包括私有靜態變量。
3）外部類不能聲明為 static。
十六、Java 枚舉
開門見山地說吧，enum（枚舉）是 Java 1.5 時引入的關鍵字，它表示一種特殊類型的類，默認繼承自 java.lang.Enum。
為了證明這一點，我們來新建一個枚舉 PlayerType：
public enum PlayerType {
TENNIS,
FOOTBALL,
BASKETBALL
}
兩個關鍵字帶一個類名，還有大括號，以及三個大寫的單詞，但沒看到繼承 Enum 類啊？別著急，心急吃不了熱豆腐啊。使用 JAD 查看一下反編譯后的字節碼，就一清二楚了。
public final class PlayerType extends Enum
{
public static PlayerType[] values()
{
return (PlayerType[])$VALUES.clone();
}
public static PlayerType valueOf(String name)
{
return (PlayerType)Enum.valueOf(com/cmower/baeldung/enum1/PlayerType, name);
}
private PlayerType(String s, int i)
{
super(s, i);
}
public static final PlayerType TENNIS;
public static final PlayerType FOOTBALL;
public static final PlayerType BASKETBALL;
private static final PlayerType $VALUES[];
static
{
TENNIS = new PlayerType("TENNIS", 0);
FOOTBALL = new PlayerType("FOOTBALL", 1);
BASKETBALL = new PlayerType("BASKETBALL", 2);
$VALUES = (new PlayerType[] {
TENNIS, FOOTBALL, BASKETBALL
});
}
}
看到沒？PlayerType 類是 final 的，並且繼承自 Enum 類。這些工作我們程序員沒做，編譯器幫我們悄悄地做了。此外，它還附帶幾個有用靜態方法，比如說 values() 和 valueOf(String name)。
01、內部枚舉
好的，小夥伴們應該已經清楚枚舉長什麼樣子了吧？既然枚舉是一種特殊的類，那它其實是可以定義在一個類的內部的，這樣它的作用域就可以限定於這個外部類中使用。
public class Player {
private PlayerType type;
public enum PlayerType {
TENNIS,
FOOTBALL,
BASKETBALL
}
public boolean isBasketballPlayer() {
return getType() == PlayerType.BASKETBALL;
}
public PlayerType getType() {
return type;
}
public void setType(PlayerType type) {
this.type = type;
}
}
PlayerType 就相當於 Player 的內部類，isBasketballPlayer() 方法用來判斷運動員是否是一個籃球運動員。
由於枚舉是 final 的，可以確保在 Java 虛擬機中僅有一個常量對象（可以參照反編譯后的靜態代碼塊「static 關鍵字帶大括號的那部分代碼」），所以我們可以很安全地使用“==”運算符來比較兩個枚舉是否相等，參照 isBasketballPlayer() 方法。
那為什麼不使用 equals() 方法判斷呢？
if(player.getType().equals(Player.PlayerType.BASKETBALL)){};
if(player.getType() == Player.PlayerType.BASKETBALL){};
“==”運算符比較的時候，如果兩個對象都為 null，並不會發生 NullPointerException，而 equals() 方法則會。
另外， “==”運算符會在編譯時進行檢查，如果兩側的類型不匹配，會提示錯誤，而 equals() 方法則不會。
02、枚舉可用於 switch 語句
這個我在之前的一篇我去的文章中詳細地說明過了，感興趣的小夥伴可以點擊鏈接跳轉過去看一下。
switch (playerType) {
case TENNIS:
return "網球運動員費德勒";
case FOOTBALL:
return "足球運動員C羅";
case BASKETBALL:
return "籃球運動員詹姆斯";
case UNKNOWN:
throw new IllegalArgumentException("未知");
default:
throw new IllegalArgumentException(
"運動員類型: " + playerType);
}
03、枚舉可以有構造方法
如果枚舉中需要包含更多信息的話，可以為其添加一些字段，比如下面示例中的 name，此時需要為枚舉添加一個帶參的構造方法，這樣就可以在定義枚舉時添加對應的名稱了。
public enum PlayerType {
TENNIS("網球"),
FOOTBALL("足球"),
BASKETBALL("籃球");
private String name;
PlayerType(String name) {
this.name = name;
}
}
04、EnumSet
EnumSet 是一個專門針對枚舉類型的 Set 接口的實現類，它是處理枚舉類型數據的一把利器，非常高效（內部實現是位向量，我也搞不懂）。
因為 EnumSet 是一個抽象類，所以創建 EnumSet 時不能使用 new 關鍵字。不過，EnumSet 提供了很多有用的靜態工廠方法：
下面的示例中使用 noneOf() 創建了一個空的 PlayerType 的 EnumSet；使用 allOf() 創建了一個包含所有 PlayerType 的 EnumSet。
public class EnumSetTest {
public enum PlayerType {
TENNIS,
FOOTBALL,
BASKETBALL
}
public static void main(String[] args) {
EnumSet<PlayerType> enumSetNone = EnumSet.noneOf(PlayerType.class);
System.out.println(enumSetNone);
EnumSet<PlayerType> enumSetAll = EnumSet.allOf(PlayerType.class);
System.out.println(enumSetAll);
}
}
程序輸出結果如下所示：
[]
[TENNIS, FOOTBALL, BASKETBALL]
有了 EnumSet 后，就可以使用 Set 的一些方法了：
05、EnumMap
EnumMap 是一個專門針對枚舉類型的 Map 接口的實現類，它可以將枚舉常量作為鍵來使用。EnumMap 的效率比 HashMap 還要高，可以直接通過數組下標（枚舉的 ordinal 值）訪問到元素。
和 EnumSet 不同，EnumMap 不是一個抽象類，所以創建 EnumMap 時可以使用 new 關鍵字：
EnumMap<PlayerType, String> enumMap = new EnumMap<>(PlayerType.class);
有了 EnumMap 對象后就可以使用 Map 的一些方法了：
和 HashMap 的使用方法大致相同，來看下面的例子：
EnumMap<PlayerType, String> enumMap = new EnumMap<>(PlayerType.class);
enumMap.put(PlayerType.BASKETBALL,"籃球運動員");
enumMap.put(PlayerType.FOOTBALL,"足球運動員");
enumMap.put(PlayerType.TENNIS,"網球運動員");
System.out.println(enumMap);
System.out.println(enumMap.get(PlayerType.BASKETBALL));
System.out.println(enumMap.containsKey(PlayerType.BASKETBALL));
System.out.println(enumMap.remove(PlayerType.BASKETBALL));
程序輸出結果如下所示：
{TENNIS=網球運動員, FOOTBALL=足球運動員, BASKETBALL=籃球運動員}
籃球運動員
true
籃球運動員
06、單例
通常情況下，實現一個單例並非易事，不信，來看下面這段代碼
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
但枚舉的出現，讓代碼量減少到極致：
public enum EasySingleton{
INSTANCE;
}
完事了，真的超級短，有沒有？枚舉默認實現了 Serializable 接口，因此 Java 虛擬機可以保證該類為單例，這與傳統的實現方式不大相同。傳統方式中，我們必須確保單例在反序列化期間不能創建任何新實例。
07、枚舉可與數據庫交互
我們可以配合 Mybatis 將數據庫字段轉換為枚舉類型。現在假設有一個數據庫字段 check_type 的類型如下：
`check_type` int(1) DEFAULT NULL COMMENT '檢查類型（1：未通過、2：通過）',
它對應的枚舉類型為 CheckType，代碼如下：
public enum CheckType {
NO_PASS(0, "未通過"), PASS(1, "通過");
private int key;
private String text;
private CheckType(int key, String text) {
this.key = key;
this.text = text;
}
public int getKey() {
return key;
}
public String getText() {
return text;
}
private static HashMap<Integer,CheckType> map = new HashMap<Integer,CheckType>();
static {
for(CheckType d : CheckType.values()){
map.put(d.key, d);
}
}
public static CheckType parse(Integer index) {
if(map.containsKey(index)){
return map.get(index);
}
return null;
}
}
1）CheckType 添加了構造方法，還有兩個字段，key 為 int 型，text 為 String 型。
2）CheckType 中有一個public static CheckType parse(Integer index)方法，可將一個 Integer 通過 key 的匹配轉化為枚舉類型。
那麼現在，我們可以在 Mybatis 的配置文件中使用 typeHandler 將數據庫字段轉化為枚舉類型。
<resultMap id="CheckLog" type="com.entity.CheckLog">
<id property="id" column="id"/>
<result property="checkType" column="check_type" typeHandler="com.CheckTypeHandler"></result>
</resultMap>
其中 checkType 字段對應的類如下：
public class CheckLog implements Serializable {
private String id;
private CheckType checkType;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public CheckType getCheckType() {
return checkType;
}
public void setCheckType(CheckType checkType) {
this.checkType = checkType;
}
}
CheckTypeHandler 轉換器的類源碼如下：
public class CheckTypeHandler extends BaseTypeHandler<CheckType> {
@Override
public CheckType getNullableResult(ResultSet rs, String index) throws SQLException {
return CheckType.parse(rs.getInt(index));
}
@Override
public CheckType getNullableResult(ResultSet rs, int index) throws SQLException {
return CheckType.parse(rs.getInt(index));
}
@Override
public CheckType getNullableResult(CallableStatement cs, int index) throws SQLException {
return CheckType.parse(cs.getInt(index));
}
@Override
public void setNonNullParameter(PreparedStatement ps, int index, CheckType val, JdbcType arg3) throws SQLException {
ps.setInt(index, val.getKey());
}
}
CheckTypeHandler 的核心功能就是調用 CheckType 枚舉類的 parse() 方法對數據庫字段進行轉換。
恕我直言，我覺得小夥伴們肯定會用 Java 枚舉了，如果還不會，就過來砍我！
十七、final 關鍵字
儘管繼承可以讓我們重用現有代碼，但有時處於某些原因，我們確實需要對可擴展性進行限制，final 關鍵字可以幫助我們做到這一點。
01、final 類
如果一個類使用了 final 關鍵字修飾，那麼它就無法被繼承。如果小夥伴們細心觀察的話，Java 就有不少 final 類，比如說最常見的 String 類。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence,
Constable, ConstantDesc {}
為什麼 String 類要設計成 final 的呢？原因大致有以下三個：
- 為了實現字符串常量池
- 為了線程安全
- 為了 HashCode 的不可變性
更詳細的原因，可以查看我之前寫的一篇文章。
任何嘗試從 final 類繼承的行為將會引發編譯錯誤，為了驗證這一點，我們來看下面這個例子，Writer 類是 final 的。
public final class Writer {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
嘗試去繼承它，編譯器會提示以下錯誤，Writer 類是 final 的，無法繼承。
不過，類是 final 的，並不意味着該類的對象是不可變的。
Writer writer = new Writer();
writer.setName("沉默王二");
System.out.println(writer.getName()); // 沉默王二
Writer 的 name 字段的默認值是 null，但可以通過 settter 方法將其更改為“沉默王二”。也就是說，如果一個類只是 final 的，那麼它並不是不可變的全部條件。
如果，你想了解不可變類的全部真相，請查看我之前寫的文章這次要說不明白immutable類，我就怎麼地。突然發現，寫系列文章真的妙啊，很多相關性的概念全部涉及到了。我真服了自己了。
把一個類設計成 final 的，有其安全方面的考慮，但不應該故意為之，因為把一個類定義成 final 的，意味着它沒辦法繼承，假如這個類的一些方法存在一些問題的話，我們就無法通過重寫的方式去修復它。
02、final 方法
被 final 修飾的方法不能被重寫。如果我們在設計一個類的時候，認為某些方法不應該被重寫，就應該把它設計成 final 的。
Thread 類就是一個例子，它本身不是 final 的，這意味着我們可以擴展它，但它的 isAlive() 方法是 final 的：
public class Thread implements Runnable {
public final native boolean isAlive();
}
需要注意的是，該方法是一個本地（native）方法，用於確認線程是否處於活躍狀態。而本地方法是由操作系統決定的，因此重寫該方法並不容易實現。
Actor 類有一個 final 方法 show()：
public class Actor {
public final void show() {
}
}
當我們想要重寫該方法的話，就會出現編譯錯誤：
如果一個類中的某些方法要被其他方法調用，則應考慮事被調用的方法稱為 final 方法，否則，重寫該方法會影響到調用方法的使用。
一個類是 final 的，和一個類不是 final，但它所有的方法都是 final 的，考慮一下，它們之間有什麼區別？
我能想到的一點，就是前者不能被繼承，也就是說方法無法被重寫；後者呢，可以被繼承，然後追加一些非 final 的方法。沒毛病吧？看把我聰明的。
03、final 變量
被 final 修飾的變量無法重新賦值。換句話說，final 變量一旦初始化，就無法更改。之前被一個小夥伴問過，什麼是 effective final，什麼是 final，這一點，我在之前的文章也有闡述過，所以這裏再貼一下地址：
http://www.itwanger.com/java/2020/02/14/java-final-effectively.html
1）final 修飾的基本數據類型
來聲明一個 final 修飾的 int 類型的變量：
final int age = 18;
嘗試將它修改為 30，結果編譯器生氣了：
2）final 修飾的引用類型
現在有一個普通的類 Pig，它有一個字段 name：
public class Pig {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
在測試類中聲明一個 final 修飾的 Pig 對象：
final Pig pig = new Pig();
如果嘗試將 pig 重新賦值的話，編譯器同樣會生氣：
但我們仍然可以去修改 Pig 的字段值：
final Pig pig = new Pig();
pig.setName("特立獨行");
System.out.println(pig.getName()); // 特立獨行
3）final 修飾的字段
final 修飾的字段可以分為兩種，一種是 static 的，另外一種是沒有 static 的，就像下面這樣：
public class Pig {
private final int age = 1;
public static final double PRICE = 36.5;
}
非 static 的 final 字段必須有一個默認值，否則編譯器將會提醒沒有初始化：
static 的 final 字段也叫常量，它的名字應該為大寫，可以在聲明的時候初始化，也可以通過 static [代碼塊初始化]()。
4) final 修飾的參數
final 關鍵字還可以修飾參數，它意味着參數在方法體內不能被再修改：
public class ArgFinalTest {
public void arg(final int age) {
}
public void arg1(final String name) {
}
}
如果嘗試去修改它的話，編譯器會提示以下錯誤：
。。。。。。
後續還會繼續更新，但有些小夥伴可能就忍不住了，這份小白手冊有沒有 PDF 版可以白嫖啊，那必須得有啊，直接「沉默王二」公眾號後台回復「小白」就可以了，不要手軟，覺得不錯的，請多多分享——贈人玫瑰，手有餘香哦。
沒關注的話，掃描上面的二維碼就可以了，然後回復「小白」。
我是沉默王二，一枚有顏值卻靠才華苟且的程序員。關注即可提升學習效率，別忘了三連啊，點贊、收藏、留言，我不挑，嘻嘻。
本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】
※為什麼 USB CONNECTOR 是電子產業重要的元件?
※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!
※台北網頁設計公司全省服務真心推薦
※想知道最厲害的網頁設計公司"嚨底家"!
※推薦評價好的iphone維修中心