1. Java概述
1.1 Java語言發(fā)展史
Java語言是美國Sun公司（Stanford University Network）在1995年推出的計算機語言， 2009年Oracle甲骨文公司收購Sun公司。Java之父：詹姆斯·高斯林（James Gosling）。
1.2 Java語言跨平臺原理
Java可以在任意操作系統(tǒng)上運行，Windows、Mac、Linux。我們只需要在運行Java應(yīng)用程序的操作系統(tǒng)上，安裝一個與操作系統(tǒng)對應(yīng)的Java虛擬機（JVM Java Virtual Machine）就可以實現(xiàn)Java的跨平臺使用了。
1.3 JRE和JDK
（1）JRE（Java Runtime Environment） 是Java程序的運行時環(huán)境，它包括JVM和運行時所需要的核心類庫。需要注意的是，JRE是包含JVM的，因此只安裝JRE也是可以實現(xiàn)Java的跨平臺使用的。
（2）JDK（Java Development Kit） 是Java程序的開發(fā)工具包，包含JRE和開發(fā)人員使用的工具。其中的開發(fā)工具包括：編譯工具（javac.exe）和運行工具（java.exe）。如果想開發(fā)一個全新的Java程序，必須安裝JDK。
（3）JDK、JRE和JVM的關(guān)系 由下圖我們可以看出，JDK包含JRE，JRE包含JVM。對于開發(fā)人員來說，我們只需要使用JDK就可以滿足一切開發(fā)和應(yīng)用的需求。
1.4 JDK和Eclipse的下載和安裝
（1）在這里，我引用了另一位博主的安裝教程 ：eclipse安裝教程（2021最新版）超級易懂到吐血
（2）JDK的安裝目錄及說明：**
2. 基礎(chǔ)語法
2.1 注釋
（1）什么是注釋：注釋是在程序指定位置添加的說明性信息。注釋不參與程序運行，僅起到說明作用。
（2）注釋的分類：
| 注釋類別 | 格式 |
|---|---|
| 單行注釋 | // 注釋信息 |
| 多行注釋 | /* 注釋信息 */ |
| 文檔注釋 | /** 注釋信息 */ |
（3）示例
/*
Java程序中最基本的組成單位是類。
類的定義格式：
public class 類名{
}
這是定義的HelloWorld類
*/
public class HelloWorld{
/*
這是main方法
main方法是程序的入口，代碼的執(zhí)行是從main方法開始的
*/
public static void main(String[] args) {
// 這是輸出語句，“”里面的內(nèi)容是可以改變的
System.out.println("HelloWorld");
}
}
2.2 關(guān)鍵字
（1）概念：關(guān)鍵字是被Java賦予了特定含義的單詞。
（2）特點：
????*關(guān)鍵字的字母全部小寫；
????*常用的代碼編輯器，針對關(guān)鍵字有特殊的顏色標(biāo)記，非常直觀
2.3 常量
（1）概念：在程序運行過程中，其值不可以發(fā)生改變的量。
（2）常量分類：
2.4 數(shù)據(jù)類型
（1）計算機存儲單元：計算機存儲設(shè)備的最小信息單元是“位（bit）”，又稱為比特位，常用小寫字母“b”表示。計算機中最小的存儲單元是“字節(jié)（byte）”，通常用大寫字母“B”表示，字節(jié)是由連續(xù)的8個位組成。其他常用的存儲單位如下：
????1B = 8bit；
????1KB = 1024B；
????1MB = 1024KB；
????1GB = 1024MB；
????1TB = 1024GB
（2）數(shù)據(jù)類型：Java語言是強類型語言，對于每一種數(shù)據(jù)都給出了明確的數(shù)據(jù)類型，不同的數(shù)據(jù)類型也分配了不同的內(nèi)存空間，所有它們表示的數(shù)據(jù)大小也是不一樣的。
（3）數(shù)據(jù)類型內(nèi)存占用和取值范圍：
2.5 變量
（1）概念：變量是在程序運行過程中，其值可以改變的量。從本質(zhì)上講，變量是內(nèi)存中一小塊區(qū)域。
（2）變量定義：數(shù)據(jù)類型 變量名 = 變量值； 例如，int a = 10;
（3）變量的使用：包括取值和修改值。
public class VariableDemo{
public static void main(String[] args){
//定義變量
int a = 10;
//輸出變量
System.out.println(a);
//修改變量
a = 20;
System.out.println(a);
}
}
（4）變量使用的注意事項：
????*變量名稱不能重復(fù)；
????*變量必須先賦值再使用；
????*long類型變量定義的時候，為了防止整數(shù)過大，后面要加L；
????*float類型變量定義的時候，為了防止類型不兼容，后面要加F。
2.6 標(biāo)識符
（1）概念：標(biāo)識符是給類、方法、變量等起名字的符號。
（2）標(biāo)識符定義規(guī)則：
????*由數(shù)字、字母、下劃線和美元符組成；
????*不能以數(shù)字開頭；
????*不能是關(guān)鍵字；
????*要區(qū)分大小寫
（3）常見命名約定：
??*小駱峰命名法：方法、變量
?????**約定1：標(biāo)識符是一個單詞的時候，首字母小寫；
?????**約定2：標(biāo)識符由多個單詞組成的時候，第一個單詞首字母小寫，其他單詞首字母大寫；
??*大駱峰命名法：類
?????**約定1：標(biāo)識符是一個單詞的時候，首字母大寫；
?????**約定2：標(biāo)識符由多個單詞組成的時候，每個單詞的首字母大寫；
2.7 類型轉(zhuǎn)換
（1）類型轉(zhuǎn)換分類：自動類型轉(zhuǎn)換；強制類型轉(zhuǎn)換
（2）自動類型轉(zhuǎn)換：把一個表示數(shù)據(jù)范圍小的數(shù)值或者變量賦值給另一個表示數(shù)據(jù)范圍大的變量。
例如：double d = 10;
（3）強制類型轉(zhuǎn)換：把一個表示數(shù)據(jù)范圍大的數(shù)值或者變量賦值給另一個表示數(shù)據(jù)范圍小的變量。
例如：int k = (int)88.88
3. 運算符
3.1 算數(shù)運算符
3.1.1 運算符
運算符是對常量或者變量進(jìn)行操作的符號。
3.1.2 表達(dá)式
用運算符把常量或者變量連接起來符合java語法的式子即為表達(dá)式。不同運算符連接的表達(dá)式體現(xiàn)的是不同類型的表達(dá)式。
???例如：int a =10; int b = 20; int c = a + b;
???+：是運算符，并且是算術(shù)運算符；a + b：是表達(dá)式，由于+是算術(shù)運算符，所以這個表達(dá)式稱為算術(shù)表達(dá)式。
示例：
/*
算術(shù)運算符
*/
public class OperatorDemo1{
public static void main(String[] args){
//定義兩個變量
int a = 6;
int b = 4;
System.out.println(a + b); # out>>10
System.out.println(a - b); # out>>2
System.out.println(a * b); # out>>24
System.out.println(a / b); # out>>1
System.out.println(a % b); # out>>2
//除法得到的是商，取余得到的是余數(shù)
//整數(shù)相除只能得到整數(shù)，要想得到小數(shù)，必須有浮點數(shù)的參與
System.out.println(6.0 / 4); # out>>1.5
}
}
3.1.3 字符的 ‘+’ 操作
字符的 ‘+’ 操作是字符在計算機底層對應(yīng)的數(shù)值來進(jìn)行計算的。
算術(shù)表達(dá)式中包含多個基本數(shù)據(jù)類型的值的時候，整個算術(shù)表達(dá)式的類型會自動進(jìn)行提升。
提升規(guī)則：
??*byte類型，short類型和char類型將被提升到int類型；
??*整個表達(dá)式的類型自動提示到表達(dá)式中最高等級操作數(shù)同樣的類型
??等級順序：byte, short, char ->int->long->float->
3.1.4 字符串的 ‘+’ 操作
（1）當(dāng) ‘+’ 操作中出現(xiàn)字符串時，這個 ‘+’ 是字符串連接符，而不是算術(shù)運算；
（2）在 ‘+’ 操作中，如果出現(xiàn)了字符串，就是連接運算符，否則就說算術(shù)運算。當(dāng)連續(xù)進(jìn)行 ‘+’ 操作時，從左到右逐個執(zhí)行。
示例：
/*
字符串的 ‘+’ 操作
*/
public class OperatorDemo03{
public static void main(String[] args){
System.out.println("it" + "heima"); # out>>itheima
System.out.println("itheima" + "666"); # out>>itheima666
System.out.println("666" + "itheima"); # out>>666itheima
System.out.println("黑馬" + 6 + 66); # out>>黑馬666
System.out.println(1 + 99 + "年黑馬"); # out>>100年黑馬
}
}
3.2 賦值運算符
3.3 自增自減運算符
3.4 關(guān)系運算符
3.5 邏輯運算符
概念：邏輯運算符是用來連接關(guān)系表達(dá)式的運算符，也可以直接連接布爾類型的常量或變量。
3.6 短路運算符
注意：
（1）邏輯與&，無論左邊真假，右邊都要執(zhí)行。
（2）短路與&&，如果左邊為真，右邊執(zhí)行；如果左邊為假，右邊不執(zhí)行。
（3）邏輯或|，無論左邊真假，右邊都要執(zhí)行。
（4）短路或|，如果左邊為假，右邊執(zhí)行；如果左邊為真，右邊不執(zhí)行。
3.7 三元運算符
格式：關(guān)系表達(dá)式？表達(dá)式1：表達(dá)式2
計算規(guī)則：首先計算關(guān)系表達(dá)式的值，如果值為true，表達(dá)式1的值就是運算結(jié)果；如果值為false，表達(dá)式2的值就是運算結(jié)果。
示例：
/*
三元運算符
*/
public class OperatorDemo{
public static void main(String[] args){
//定義兩個變量
int a = 10;
int b = 20;
//獲取兩個數(shù)據(jù)中的較大值
int max = a > b ? a : b;
//輸出結(jié)果
System.out.println("max:" + max); # out>>max:20
}
}
4. 數(shù)據(jù)輸入
Scanner使用的基本步驟：
（1）導(dǎo)包：import java.util.Scanner;???????????導(dǎo)包的動作必須出現(xiàn)在類定義的上邊
（2）創(chuàng)建對象：Scanner sc = new Scanner(System.in);???這里面只有sc是變量名，可以改變。其他的都不能變
（3）接收數(shù)據(jù)：int i = sc.nextInt(); ????????????上面這個格式，只有i是變量名，可以變，其他都不能變
（4）示例：
/*
數(shù)據(jù)輸入：
（1）導(dǎo)包：
import java.util.Scanner;
（2）創(chuàng)建對象：
Scanner sc = new Scanner(System.in);
（3）接收數(shù)據(jù)：
int x = sc.nextInn();
*/
import java.util.Scanner;
public class ScannerDemo{
public static void main(String[] args){
//創(chuàng)建對象
Scanner sc = new Scanner(System.in);
//接收數(shù)據(jù)
int x = sc.nextInt();
//輸出數(shù)據(jù)
System.out.println("x:" + x);
}
}
5. 分支語句
5.1 流程控制
流程控制語句分類：（1）順序結(jié)構(gòu)；（2）分支結(jié)構(gòu)（if, switch）；（3）循環(huán)結(jié)構(gòu)(for, while, do…while)
5.2 順序結(jié)構(gòu)
概念：順序結(jié)構(gòu)是程序中最簡單、最基本的流程控制，沒用特定的語法結(jié)構(gòu)，按照代碼的先后順序，依次執(zhí)行，程序中大多數(shù)的代碼都是這樣執(zhí)行的。
5.3 if語句
（1）格式1：
if (關(guān)系表達(dá)式){
語句體；
}
執(zhí)行流程：
首先計算關(guān)系表達(dá)式的值；
如果關(guān)系表達(dá)式的值為true，則執(zhí)行語句體；
如果關(guān)系表達(dá)式的值為false就不執(zhí)行語句體；
繼續(xù)執(zhí)行后面的語句內(nèi)容。
（2）格式2：
if (關(guān)系表達(dá)式){
語句體1；
}else{
語句體2；
}
執(zhí)行流程：
首先計算關(guān)系表達(dá)式的值；
如果關(guān)系表達(dá)式的值為true，則執(zhí)行語句體1；
如果關(guān)系表達(dá)式的值為false，則執(zhí)行語句體2；
繼續(xù)執(zhí)行后面的語句內(nèi)容。
（3）格式3：
if (關(guān)系表達(dá)式1){
語句體1;
}else if(關(guān)系表達(dá)式2){
語句體2;
}
···
else{
語句體n+1;
}
執(zhí)行流程：
（1）首先計算關(guān)系表達(dá)式的值；
（2）如果關(guān)系表達(dá)式的值為true，則執(zhí)行語句體1；
（3）如果關(guān)系表達(dá)式的值為false，則執(zhí)行語句體2；
（4）繼續(xù)執(zhí)行后面的語句內(nèi)容。
5.4 switch語句
格式：
switch(表達(dá)式){
case 值1：
語句體1;
break;
case 值2：
語句體2；
break;
···
default：
語句體n+1;
[break;]
}
格式說明：
（1）表達(dá)式：取值為byte, short, int, char, string.
（2）case：后面跟的是要和表達(dá)式進(jìn)行比較的值。
（3）break：表示中斷，結(jié)束的意思，用來結(jié)束switch語句。
（4）default：表示所有情況都不匹配的時候，就執(zhí)行該處的內(nèi)容，和if語句的else相似。
6. 循環(huán)語句
6.1 for 循環(huán)語句
格式：
for (初始化語句;條件判斷語句;條件控制語句){
循環(huán)體語句;
}
執(zhí)行流程：
（1）執(zhí)行初始化語句；
（2）執(zhí)行條件判斷語句，看其結(jié)果是true還是false，如果是false，循環(huán)結(jié)束，如果是true，繼續(xù)執(zhí)行；
（3）執(zhí)行循環(huán)體語句；
（4）執(zhí)行條件控制語句；
（5）回到（2）繼續(xù)。
6.2 while 循環(huán)語句
格式：
初始化語句;
while (條件判斷語句){
循環(huán)體語句;
條件控制語句;
}
執(zhí)行流程：
（1）執(zhí)行初始化語句；
（2）執(zhí)行條件判斷語句，看其結(jié)果是true還是false，如果是false，循環(huán)結(jié)束，如果是true，繼續(xù)執(zhí)行；
（3）執(zhí)行循環(huán)體語句；
（4）執(zhí)行條件控制語句；
（5）回到（2）繼續(xù)。
6.3 do…while 循環(huán)語句
格式：
初始化語句;
do{
循環(huán)體語句;
條件控制語句;
}while(條件判斷語句);
執(zhí)行流程：
（1）執(zhí)行初始化語句；
（2）執(zhí)行循環(huán)體語句；
（3）執(zhí)行條件控制語句；
（2）執(zhí)行條件判斷語句，看其結(jié)果是true還是false，如果是false，循環(huán)結(jié)束，如果是true，繼續(xù)執(zhí)行；
（5）回到（2）繼續(xù)。
6.4 三種循環(huán)的區(qū)別
三種循環(huán)的區(qū)別：
（1）for循環(huán)和while循環(huán)先判斷條件是否成立，然后決定是否執(zhí)行循環(huán)體（先判斷后執(zhí)行）；
（2）do…while循環(huán)先執(zhí)行一次循環(huán)體，然后判斷條件是否成立，是否繼續(xù)執(zhí)行循環(huán)體（先執(zhí)行后判斷）。
for和while的區(qū)別：
（1）條件控制語句所控制的自增變量，因為歸屬for循環(huán)的語法結(jié)構(gòu)中，在for循環(huán)結(jié)束后，就不能再次被訪問了；
（2）條件控制語句所控制的自增變量，對于while循環(huán)來說不歸屬其語法結(jié)構(gòu)中，在while循環(huán)結(jié)束后，該變量還可以繼續(xù)使用。
死循環(huán)格式：
（1）for(; ; ){}
（2）while(true){}
（3）do{}while(true);
6.5 Random
作用： 產(chǎn)生一個隨機數(shù)。
使用步驟：
（1）導(dǎo)包：import java.util.Random;
（2）創(chuàng)建對象：Random r = new Random();
（3）獲取隨機數(shù)：int number = r.nextInt(10); //獲取數(shù)據(jù)的范圍：[0,10]，包括0，不包括10
示例：
/*
Random
*/
import java.util.Random
public class RandomDemo{
public static void main(String[] args){
//創(chuàng)建對象
Random r = new Random();
//用循環(huán)獲取10個隨機數(shù)
for(int i=0; i<10; i++){
//獲取隨機數(shù)
int number = r.nextInt(10);
System.out.println("number:" + number);
//需求：獲取一個1-100之間的隨機數(shù)
int x = r.nextInt(100) + 1;
System.out.println(x);
}
}
}
7. IDEA
7.1 IDEA概述
（1）IDEA概述：IDEA全稱IntelliJ IDEA，是用于Java語言開發(fā)的集成環(huán)境，是業(yè)界公認(rèn)的目前用于Java程序開發(fā)最好的工具。
是可以把代碼編寫、編譯、執(zhí)行、調(diào)試等多種功能綜合到一起的開發(fā)工具。
（2）IDEA的下載和安裝： 參考這篇博客：IDEA的下載和使用安裝
7.2 IDEA中HelloWorld
步驟：
（1）創(chuàng)建一個空項目（JavaSE_Code）
（2）創(chuàng)建一個新模塊（idea_test）
（3）在idea_test模塊下的src下創(chuàng)建一個包（com.itheima）
（4）在com.itheima包下新建一個類（Helloworld）
（5）在Helloworld類中編寫代碼
（6）在idea中執(zhí)行程序
7.3 IDEA中項目結(jié)構(gòu)
Project–>模塊–>包–>類
7.4 IDEA中內(nèi)容輔助鍵和快捷鍵
（1）快速生成語句：
快速生成main()方法：psvm，回車
快速生成輸出語句：sout，回車
（2）內(nèi)容輔助鍵：
ctrl+alt+space，內(nèi)容提示，代碼補全等
（3）快捷鍵：
注釋：
??單行：選中代碼，ctrl+/
??多行：選址代碼，ctrl+shift+/
格式化：
??ctrl+alt+L
8. 數(shù)組
8.1 數(shù)組定義格式
概念：數(shù)組（array）是一種用于存儲多個相同類型數(shù)據(jù)的存儲模型
數(shù)組的定義格式：
（1）格式1：數(shù)據(jù)類型[ ] 變量名，例如：int [ ] arr。定義了一個int類型的數(shù)組，數(shù)組名是arr。
（2）格式2：數(shù)據(jù)類型 變量名[ ]， 例如：int arr[ ]。定義了一個int類型的變量，變量名是arr數(shù)組。
8.2 數(shù)組初始化之動態(tài)初始化
初始化：就說為數(shù)組中的數(shù)組元素分配內(nèi)存空間，并為每個數(shù)組元素賦值。
數(shù)組初始化類型：動態(tài)初始化、靜態(tài)初始化
動態(tài)初始化：初始化時只指定數(shù)組長度，由系統(tǒng)為數(shù)組分配初始值。
動態(tài)初始化格式：數(shù)據(jù)類型 [ ] 變量名 = new 數(shù)據(jù)類型[數(shù)組長度]，例如：int [] arr = new int[3]
示例：
public class ArrayDemo{
public static void main(String[] args){
int[] arr = new int[3]
/*
左邊：
int：說明數(shù)組中的元素是int類型
[]：說明這是一個數(shù)組
arr：這是數(shù)組的名稱
右邊：
new：為數(shù)組申請內(nèi)存空間
int：說明數(shù)組中的元素類型是int類型
[]：說明這是一個數(shù)組
3：數(shù)組長度，其實就說數(shù)組中的元素個數(shù)
}
}
8.3 數(shù)組元素訪問
數(shù)組變量訪問方式：數(shù)組名
數(shù)組內(nèi)部保存數(shù)據(jù)的訪問方式：數(shù)組名[索引]
什么是索引：索引是數(shù)組中數(shù)據(jù)的編號方式，用于訪問數(shù)組中的數(shù)據(jù)使用，數(shù)組名[索引]等同于變量名，是一種特殊的變量名。注意：索引是從0開始的、索引是連續(xù)的、索引逐一增加，每次加1。
示例：
public class ArrayDemo{
public static void main(String[] args){
int[] arr = new int[3]
//輸出數(shù)組名
System.out.println(arr); # out>> [i@880ec60 內(nèi)存地址
//輸出數(shù)組中的元素
System.out.println(arr[0]); # out>> 0
System.out.println(arr[0]); # out>> 0
System.out.println(arr[0]); # out>> 0
}
}
8.4 Java中內(nèi)存分配
8.5 數(shù)組初始化之靜態(tài)初始化
靜態(tài)初始化：初始化時指定每個數(shù)組元素的初始值，由系統(tǒng)決定數(shù)組長度。
格式1：數(shù)據(jù)類型 [ ] 變量名 = new 數(shù)據(jù)類型[ ] {數(shù)據(jù)1， 數(shù)據(jù)2， 數(shù)據(jù)3， …}，例如：int [ ] arr = new int[ ] {1, 2, 3};
格式2：數(shù)據(jù)類型 [ ] 變量名 = {數(shù)據(jù)1， 數(shù)據(jù)2， 數(shù)據(jù)3， …}，例如：int [ ] arr = {1, 2, 3};
8.6 數(shù)組操作的兩個常見小問題
（1）索引越界
（2）空指針異常
8.7 數(shù)組常見操作
** 遍歷**：for循環(huán) + 數(shù)組名.length
示例：
public class ArrayTest01{
public static void main(String[] args){
//定義數(shù)組
int[] arr = {1 , 2, 3, 4, 5};
//使用通用的遍歷格式
for(int x=0; x<arr.length; x++){
System.out.println(arr[x]);
}
}
}
9. 方法
9.1 方法概述
概念：方法（Method）是將具有獨立功能的代碼塊組織成為一個整體，使其具有特殊功能的代碼集。
注意：
（1）方法必須先創(chuàng)建才可以使用，該過程稱為方法定義；
（2）方法創(chuàng)建后并不是直接運行的，需要手動使用后才執(zhí)行，該過程稱為方法調(diào)用。
9.2 方法的定義和調(diào)用
方法定義與調(diào)用：
// 方法定義
public static void method_name(){
//方法體
}
//方法調(diào)用
method_name()
示例：
public class MethodDemo
{
public static void main(String[] args)
{
//調(diào)用方法
isEvenNumber();
}
//需求：定義一個方法，在方法中定義一個變量，判斷該數(shù)據(jù)是否是偶數(shù)
public static void isEvenNumber()
{
//定義變量
int number = 10;
number = 9;
//判斷該數(shù)是否是偶數(shù)
if(number%2 ==0)
{
System.out.println(true);
}
else
{
Systm.println(false);
}
}
}
9.3 帶參數(shù)方法的定義和調(diào)用
帶參數(shù)方法定義：
（1）格式： public static void 方法名(參數(shù)){... ...}
（2）格式（單個參數(shù)）：public static void 方法名(數(shù)據(jù)類型 變量名){... ...}
（3）格式（多個參數(shù)）：public static void 方法名（數(shù)據(jù)類型 變量名1, 數(shù)據(jù)類型 變量名2, ......）{... ...}
注意
（1）方法定義時，參數(shù)中的數(shù)據(jù)類型與變量名都不能缺少，缺少任意一個程序?qū)箦e；
（2）方法定義時，多個參數(shù)之間使用逗號分隔。
帶參數(shù)方法調(diào)用：
（1）格式：方法名(參數(shù))；
（2）格式（單個參數(shù)）：方法名(變量名/常量值)；
（3）格式（多個參數(shù)）：方法名(變量名1/常量值1， 變量名2/常量值2);
注意：
（1）方法調(diào)用時，參數(shù)的數(shù)量與類型必須與方法定義中的設(shè)置相匹配，否則程序?qū)箦e。
形參和實參：
形參：方法定義中的參數(shù)，等同于變量定義格式；
實參：方法調(diào)用中的參數(shù)，等同于使用變量或常量
9.3 方法的注意事項
（1）方法不能嵌套定義
（2）void表示無返回值，可以省略return，也可以單獨書寫return，后面不加數(shù)據(jù)。
（3）方法的通用格式：
public static 返回值類型 方法名(參數(shù))
{
方法體；
return 數(shù)據(jù);
}
其中：
public static----修飾符，目前先記住這個格式
返回值類型--------方法操作完畢之后返回的數(shù)據(jù)的數(shù)據(jù)類型
方法名------------調(diào)用方法的時候使用的標(biāo)識
參數(shù)--------------由數(shù)據(jù)類型和變量名組成，多個參數(shù)之間使用逗號隔開
方法體------------完成功能的代碼塊
return-----------如果方法操作完畢，有數(shù)據(jù)返回，用于把數(shù)據(jù)返回給調(diào)用者
（4）定義方法時需要注意：
明確返回值類型：主要是明確方法操作完畢之后是否有數(shù)據(jù)返回，如果沒用，寫void；如果有，寫對應(yīng)的數(shù)據(jù)類型；
明確參數(shù)：主要是明確參數(shù)的類型和數(shù)量
（5）調(diào)用方法時需要注意：
void類型的方法可以直接調(diào)用；
非void類型的方法，推薦用變量接收調(diào)用；
9.4 方法重載
方法重載概念：方法重載指同一個類中定義的多個方法之間的關(guān)系，滿足下列條件的多個方法相互構(gòu)成重載：
（1）多個方法在同一個類中；
（2）多個方法具有相同的方法名；
（3）多個方法的參數(shù)不相同，類型不同或者數(shù)量不同。
方法重載特點：
（1）重載僅對應(yīng)方法的定義，與方法的調(diào)用無關(guān)，調(diào)用方式參照標(biāo)準(zhǔn)格式；
（2）重載僅針對同一個類中方法的名稱與參數(shù)進(jìn)行識別，與返回值無關(guān)，換句話說不能通過返回值來判斷兩個方法是否相互構(gòu)成重載。
示例;
/*
方法重載：
多個方法在同一個類中；
多個方法具有相同的方法名；
多個方法的參數(shù)不相同，類型不同或者數(shù)量不同
與返回值無關(guān)，在調(diào)用方法的時候，Java虛擬機會通過參數(shù)的不同來區(qū)分同名的方法
*/
public class MethoDemo
{
public static void main(String[] args)
{
//調(diào)用方法
int result = sum(a:10, b:20);
System.out.println(result);
double result2 = sum(a:10.0, b:20.0);
System.out.println(result2);
int reslult3 = sum(a:10, b:20, c:30);
System.out.println(result3);
//需求1：求兩個int類型數(shù)據(jù)和的方法
public static int sum(int a, int b)
{
return a + b;
}
//需求2：求兩個double類型數(shù)據(jù)和的方法
public static int sum(double a, double b)
{
return a + b;
}
//需求3：求三個int類型數(shù)據(jù)和的方法
public static int sum(int a, int b, int c)
{
return a + b + c;
}
}
9.5 方法的參數(shù)的傳遞
（1）對于基本數(shù)據(jù)類型的參數(shù)，形參的改變，不影響實際參數(shù)的值。
（2）對于引用類型的參數(shù)，形參的改變，影響實際參數(shù)的值。
10 面向?qū)ο蠡A(chǔ)
10.1 類和對象
1. 什么是對象：萬物皆對象，客觀存在的事物皆為對象。
2. 什么是對象的屬性： 對象具有的各種特征，每個對象的每個屬性都擁有特定的值。
3. 什么是對象的行為： 對象能夠執(zhí)行的操作。
4. 什么是類：類是對現(xiàn)實生活中一類具有共同屬性和行為的事物的抽象，確定對象將會擁有的屬性和行為。類是JAVA程序的基本組成單位。
??類的特點：
??（1）類是對象的數(shù)據(jù)類型；
??（2）類是具有相同屬性和行為的一組對象的集合。
5. 類和對象的關(guān)系：類是對象的抽象，對象是類的實體。
6. 類的組成：屬性和行為。
??屬性：在類中通過成員變量來體現(xiàn)（類中方法外的變量）
??行為：在類中通過成員方法來體現(xiàn)（和前面的方法相比去掉static關(guān)鍵字即可）
7. 類的定義：
public calss 類名{
// 成員變量
變量1的數(shù)據(jù)類型 變量1;
變量2的數(shù)據(jù)類型 變量2;
...
//成員方法
方法1;
方法2;
...
}
8. 對象的使用:
??（1）創(chuàng)建對象：類名 對象名 = new 類名();
??（2）使用對象：使用成員變量：對象名.變量名；使用成員方法：對象名.方法名()
10.2 成員變量和局部變量
1. 成員變量：類中方法外的變量。
2. 局部變量：類中方法中的變量。
public class Student{
String name; // 成員變量
public void study(){
int i = 0; // 局部變量
System.out.println('Good good study!');
}
int age; // 成員變量
}
3. 成員變量和局部變量的區(qū)別：
10.3 封裝
10.3.1 private關(guān)鍵字
作用：private是一個關(guān)鍵字；它可以修飾成員（成員變量和成員方法）；作用是保護(hù)成員不被別的類使用，被private修飾的成員只能在本類中才能訪問。
使用：針對private修飾的成員變量，如果需要被其他類使用，應(yīng)提供相應(yīng)的操作。
（1）提供 get變量名() 方法，用于獲取成員變量的值，方法用public修飾；
（2）提供 set變量名(參數(shù))方法，用于設(shè)置成員變量的值，方法用public修飾。
public class Student{
//成員變量
String name;
private int age;
//提供get/set方法
public void setAge(int a){
if (a<0 || a>120){
System.out.println("你給的年齡有誤");
}else{
age = a;
}
}
public int getAge(){
return age;
}
}
10.3.2 this關(guān)鍵字
（1）this修飾的變量用于指代成員變量。
????方法的形參如果與成員變量同名，不帶this修飾的變量指的是形參，而不是成員變量；
????方法的形參沒用與成員變量同名，不帶this修飾的變量指的是成員變量。
（2）this代表所在類的對象引用。方法被哪個對象調(diào)用，this就代表哪個對象。
10.3.3 封裝
1. 封裝概述：封裝是面向?qū)ο笕筇卣髦唬ǚ庋b、繼承、多態(tài)），是面向?qū)ο缶幊陶Z言對客觀世界的模擬，客觀世界里成員變量都是隱藏在對象內(nèi)部的，外界是無法直接操作的。
2. 封裝原則：將類的某些信息隱藏在類內(nèi)部，不允許外部程序直接訪問，而是通過該類提供的方法來實現(xiàn)對隱藏信息的操作和訪問成員變量private，提供對應(yīng)的getXxx() / setXxx()方法。
3. 封裝優(yōu)點：通過方法來控制成員變量的操作，提高了代碼的安全性。把代碼用方法進(jìn)行封裝，提高了代碼的復(fù)用性。
10.3.4 構(gòu)造方法
概念：構(gòu)造方法是一種特殊的方法，用于創(chuàng)建對象，功能是完成對數(shù)據(jù)的初始化。
格式：
public class 類名{
修飾符 類名(參數(shù)){
}
}
注意事項：
（1）構(gòu)造方法的創(chuàng)建：如果沒有定義構(gòu)造方法，系統(tǒng)將給出一個默認(rèn)的無參數(shù)構(gòu)造方法；如果定義了構(gòu)造方法，系統(tǒng)將不再提供默認(rèn)的構(gòu)造方法。
（2）構(gòu)造方法的重載：如果自定義了帶參構(gòu)造方法，還要使用無參數(shù)構(gòu)造方法，就必須再寫一個無參數(shù)構(gòu)造方法。
（3）推薦的使用方式：無論是否使用，都手工書寫無參數(shù)構(gòu)造方法。
10.3.5 標(biāo)準(zhǔn)類的制作
（1）成員變量：使用private修飾
（2）構(gòu)造方法：提供一個無參構(gòu)造方法、提供一個帶多個參數(shù)的構(gòu)造方法。
（3）成員方法：提供每一個成員變量對應(yīng)的setXxx() / getXxx()；提供一個顯示對象信息的show()。
（4）創(chuàng)建對象并為其成員變量賦值的兩種方式：無參構(gòu)造方法創(chuàng)建對象后使用setXxx()賦值；使用帶參構(gòu)造方法直接創(chuàng)建帶有屬性值的對象。
public class Student{
// 成員變量
private String name;
private int age;
// 構(gòu)造方法
public Student() {}
public Student(String name, int age){
this.name = name;
this.age = age;
}
// 成員方法
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(){
this.age = age;
}
public int getAge(){
return age;
}
public void show(){
System.out.println(name + "," + age);
}
}
public class StudentTest{
public static void main(String[] args){
// 無參數(shù)構(gòu)造方法創(chuàng)建對象后使用setXxx()賦值
Student s1 = new Student();
s1.setName("Kobe");
s1.setAge("24");
s1.show();
// 使用帶參構(gòu)造方法直接創(chuàng)建帶有屬性值的對象
Student s2 = new Student(name:"Kobe", age:24);
s2.show();
}
}
11. String
String類在java.lang包下，所以使用的時候不需要導(dǎo)包。
11.1 String構(gòu)造方法
11.2 案例：用戶登錄
package string;
import java.util.Scanner;
public class string001 {
public static void main(String[] args){
// 已知用戶名和密碼
String username = "Kobe";
String password = "24&8";
// 用循環(huán)實現(xiàn)多次機會，這里的次數(shù)明確，采用for循環(huán)實現(xiàn)
for(int i=0; i<3; i++){
// 鍵盤要錄入登錄的用戶名和密碼，用Scanner實現(xiàn)
Scanner sc = new Scanner(System.in);
System.out.println("請輸入用戶名：");
String name = sc.nextLine();
System.out.println("請輸入密碼：");
String pwd = sc.nextLine();
// 用鍵盤錄入的用戶名和密碼和已知的用戶名和密碼進(jìn)行比較，并給出相應(yīng)的提示
if (username.equals(name) && password.equals(pwd)){
System.out.println("登錄成功");
break;
} else{
if ((2-i) == 0){
System.out.println("登錄失敗，你的賬號已被凍結(jié)！");
} else{
System.out.println("用戶名或密碼輸入錯誤，你還有" + (2-i) + "次輸入機會！");
}
}
}
}
}
11.3 案例：遍歷字符串
package string;
import java.util.Scanner;
public class string002 {
public static void main(String[] args){
// new一個Scanner對象接收輸入的字符串
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個字符串：");
String line = sc.nextLine();
// 定義for循環(huán)，用charAt()方法遍歷字符串
for (int i=0; i< line.length(); i++){
System.out.println(line.charAt(i));
}
}
11.4 StringBuilder
11.4.1 StringBuilder概述
StringBuilder是一個可變的字符串類，我們可以把它看成是一個容器，這里的可變指的是StringBuilder對象中的內(nèi)容是可變的。
11.4.2 String和StringBuilder的區(qū)別
String的內(nèi)容是不可變的；StringBuilder的內(nèi)容是可變的。
11.4.3 StringBuilder構(gòu)造方法
package string;
/*
StringBuilder構(gòu)造方法：
public StringBuilder():創(chuàng)建一個空白可變字符串對象，不含有任何內(nèi)容。
public StringBuilder(String str):根據(jù)字符串的內(nèi)容，來創(chuàng)建可變字符串對象。
*/
public class string003 {
public static void main(String[] args){
// public StringBuilder()
StringBuilder sb = new StringBuilder();
System.out.println("sb:" + sb);
System.out.println("sb.length():" + sb.length());
// public StringBuilder(String str)
StringBuilder sb2 = new StringBuilder("hello");
System.out.println("sb2:" + sb2);
System.out.println("sb2.length():" + sb2.length());
}
}
11.4.4 StringBuilder的添加和反轉(zhuǎn)方法
package string;
/*
StringBuilder的添加和反轉(zhuǎn)方法：
pubic StringBuilder append(任意類型)：添加數(shù)據(jù)，并返回對象本身；
public StringBuilder reverse(): 返回相反的字符序列
*/
public class string004 {
public static void main(String[] args){
// 創(chuàng)建對象
StringBuilder sb = new StringBuilder();
// 鏈?zhǔn)骄幊?/span>
sb.append("hello ").append("world ").append("!");
System.out.println("sb: " + sb);
// public StringBuilder reverse():返回相反的字符序列
sb.reverse();
System.out.println("sb: " + sb);
}
}
11.4.5 StringBuilder 和 String 的相互轉(zhuǎn)換
1. StringBuilder轉(zhuǎn)換為String
public String toString()：通過toString()就可以實現(xiàn)把StringBuilder轉(zhuǎn)換為String。
2. String轉(zhuǎn)換為StringBuilder
public StringBuilder(String s):通過構(gòu)造方法就可以實現(xiàn)把String轉(zhuǎn)換為StringBuilder。
package string;
public class string005 {
public static void main(String[] args){
// 先創(chuàng)建一個對象
StringBuilder sb = new StringBuilder();
sb.append("hello");
// 將StringBuilder轉(zhuǎn)換為String
String s = sb.toString();
System.out.println(s);
// 將String轉(zhuǎn)換為StringBuilder
StringBuilder s2 = new StringBuilder(s);
System.out.println(s2);
}
}
11.4.6 案例：拼接字符串
需求：定義一個方法，把int數(shù)組中的數(shù)據(jù)按照指定的格式拼接成一個字符串返回，調(diào)用該方法，并在控制臺輸出結(jié)果。例如，數(shù)組為int [] arr = {1, 2, 3}; ，執(zhí)行方法后的輸出結(jié)果為：[1,2,3]。
public class string006 {
public static void main(String[] args){
int[] arr = {1,2,3,4,5};
//調(diào)用方法，用一個變量接收結(jié)果
String s = array2string(arr); // 對數(shù)組的格式進(jìn)行轉(zhuǎn)換
// 輸出結(jié)果
System.out.println(s);
}
public static String array2string(int[] arr){
// 在方法中用 StringBuilder 按照要求進(jìn)行拼接，并把結(jié)果轉(zhuǎn)成 String 返回。
StringBuilder sb = new StringBuilder(); // new一個StringBuilder對象
sb.append('[');
for (int i=0; i<arr.length; i++){
if(i == arr.length-1){
sb.append(arr[i]);
}
else{
sb.append(arr[i]).append(','); // 這里不可以用 + 號來拼接字符串
}
}
sb.append(']');
String s = sb.toString();
return s;
}
}
11.4.7 案例：字符串反轉(zhuǎn)
需求：定義一個方法，實現(xiàn)字符串反轉(zhuǎn)。鍵盤錄入一個字符串，調(diào)用該方法后，在控制臺輸出結(jié)果。例如，鍵盤錄入abc，輸出結(jié)果cba。
import java.util.Scanner;
public class string007 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("請輸入一個字符串：");
String line = sc.nextLine();
// 調(diào)用方法，傳入輸入的字符串，返回反轉(zhuǎn)后的字符串
String s = reverse(line);
System.out.println(s);
}
public static String reverse(String s){
StringBuilder sb = new StringBuilder(s);
String reverse_s = sb.reverse().toString();
return reverse_s;
// 簡便的語句：return new StringBuilder(s).reverse().toString();
}
}
12. 集合
12.1 集合基礎(chǔ)
集合類的特點：提供一種存儲空間可變的存儲模型，存儲的數(shù)據(jù)容量可以發(fā)生改變。集合類有很多，本章著重介紹：ArrayList。
**ArrayList：是可調(diào)整大小的數(shù)組實現(xiàn)。是一種特殊的數(shù)據(jù)類型，泛型。文章來源：http://www.zghlxwxcb.cn/news/detail-724100.html
12.2 ArrayList構(gòu)造方法和添加方法
12.3 ArrayList集合常用方法
文章來源地址http://www.zghlxwxcb.cn/news/detail-724100.html
到了這里，關(guān)于【學(xué)習(xí)筆記】黑馬程序員Java課程學(xué)習(xí)筆記（更新至第12章---集合）的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
![[學(xué)習(xí)筆記]黑馬程序員python教程](https://imgs.yssmx.com/Uploads/2024/02/723818-1.png)
![[學(xué)習(xí)筆記]黑馬程序員-Hadoop入門視頻教程](https://imgs.yssmx.com/Uploads/2024/02/648432-1.png)
