當前位置：首頁 >

Java 基础学习记录

發布時間：2023/12/1 29 生活家

生活随笔收集整理的這篇文章主要介紹了 Java 基础学习记录小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

Java 基礎

- DAY1
- - 1、關于進制的運算
  - 2、關于存儲單元
  - 3、關于CMD的基本命令
  - 4、JRE與JDK
  - 5、Java環境變量
  - 6、程序開發步驟
  - 7、HelloWorld
  - 8、標識符
  - 9、常量
  - 10、數據類型
  - - - 數據類型分類
      - 基本數據類型
      - 注意事項：
  - 11、變量
- DAY2
- - 1、數據類型轉換
  - - 自動類型轉換（隱式）
    - 強制類型轉換（顯式）
  - 2、ASCII編碼表
  - 3、算術運算符
  - - 四則運算當中的加號“+”有常見的三種用法：
  - 4、自增自減運算符
  - 5、賦值運算符
  - 6、比較運算符
  - 7、邏輯運算符
  - 8、三元運算符
  - 9、方法定義與調用
  - 10、編譯器的兩點優化
  - - 1、自動添加隱含類型
    - 2、常量優化
- DAY3
- - 1、ifelse語句
  - 2、ifelseifelse語句
  - 3、ifelse練習
  - 4、使用if語句替換三元運算符
  - 5、switch
  - 6、循環結構
  - 7、求出1-100之間的偶數和
  - 8、三種循環的區別
  - 9、break
  - 10、continue
  - 11、死循環
  - 12、嵌套循環
- DAY4
- - 1、IDEA
  - - psvm
    - sout
    - 常用設置
    - 代碼模板
  - 2、項目結構
  - 3、IDEA常用快捷鍵
  - 4、復習一下嵌套循環
  - 5、方法的定義與調用
  - 6、有參與無參
  - 7、練習題1
  - 8、練習題2
  - 9、練習題3
  - 10、練習題4
  - 11、使用方法的注意事項
  - 12、方法的重載
  - 13、重載練習一
  - 14、重載練習二
  - 15、重載練習三
- DAY5
- - 1、數組的概念
  - 2、動態初始化與靜態初始化
  - 3、靜態初始化（省略格式）
  - 4、訪問數組元素（獲取）
  - 5、訪問數組元素（賦值）
  - 6、內存的劃分
  - 7、一個數組的內存圖
  - 8、兩個數組的內存圖
  - 9、兩個數組指向同一個地址值的內存圖
  - 10、數組索引越界異常
  - 11、空指針異常
  - 12、獲取數組的長度
  - 13、數組遍歷輸出
  - 14、求數組中的最值
  - 15、數組元素反轉
  - 16、傳遞地址（數組作為方法參數）
  - 17、返回地址（數組作為方法返回值）
- DAY6
- - 1、面向對象
  - 2、面向對象思想舉例
  - 3、類和對象的關系
  - 4、類的定義
  - 5、對象的創建及使用
  - 6、手機類練習
  - 7、一個對象的內存圖
  - 8、兩個對象使用同一個方法的內存圖
  - 9、兩個引用指向同一個對象的內存圖
  - 10、使用對象類型作為方法的參數
  - 11、使用對象類型作為方法的返回值
  - 12、局部變量和成員變量
  - 13、面向對象三大特征之封裝性
  - 14、private關鍵字的作用及使用
  - 15、練習使用private關鍵字定義學生類（特殊boolean）
  - 16、this關鍵字的作用
  - 17、構造方法
  - 18、定義一個標準的類
- DAY7
- - 1、API概述和使用步驟
  - 2、Scanner類鍵盤輸入
  - 3、Scanner練習一鍵盤輸入兩個數字求和
  - 4、Scanner練習二鍵盤輸入三個數字求最大值
  - 5、匿名對象的說明
  - 6、匿名對象作為方法的參數和返回值
  - 7、Random 隨機數
  - 8、Random生成指定范圍的隨機數
  - 9、Random練習一生成1-n之間的隨機數
  - 10、Random練習二猜數字小游戲
  - 11、Random練習二猜數字小游戲（題目變形）
  - 12、對象數組
  - 13、ArrayList集合概述和基本使用
  - 14、ArrayList集合的常用方法
  - 15、ArrayList集合的遍歷
  - 16、ArrayList集合存儲基本數據類型
  - 17、ArrayList練習一存儲隨機數字
  - 18、ArrayList練習二存儲自定義對象
  - 19、ArrayList練習三按指定格式遍歷集合字符串
  - 20、ArrayList練習四篩選集合中的隨機數
- DAY8
- - 1、字符串概述和特點
  - 2、字符串的構造方法和直接創建創建字符串的常見3+1種方式。
  - 3、字符串的常量池
  - 4、字符串的比較相關方法
  - 5、字符串的獲取相關方法
  - 6、字符串的截取方法
  - 7、字符串的轉換相關方法
  - 8、字符串的分割方法
  - 9、練習一：按指定格式拼接字符串
  - 10、練習二：統計輸入的字符串中各種字符的個數
  - 11、靜態static關鍵字概述
  - 12、靜態static關鍵字修飾成員變量
  - 13、靜態static關鍵字修飾成員方法
  - 14、靜態static的內存圖
  - 15、靜態代碼塊
  - 16、數組工具類Arrays
  - 17、Arrays練習：字符串倒序排列
  - 18、數學工具類Math
  - 19、Math練習：小學數學真題
- DAY9
- - 1、繼承的概述
  - 2、繼承的格式
  - 3、繼承中成員變量的訪問特點
  - 4、區分子類方法中重名的三種變量
  - 5、繼承中成員方法的訪問特點
  - 6、繼承中方法的覆蓋重寫概念與特點
  - 7、繼承中方法的覆蓋重寫注意事項
  - 8、繼承中方法的覆蓋重寫應用場景
  - 9、繼承中構造方法的訪問特點
  - 10、super關鍵字的三種用法
  - 11、this關鍵字的三種用法
  - 12、super與this關鍵字圖解
  - 13、Java繼承的三個特點
  - 14、抽象的概念
  - 15、抽象方法和抽象類的格式
  - 16、抽象方法和抽象類的使用
  - 17、抽象方法和抽象類的注意事項
  - 18、發紅包案例
  - - 分析
    - 實現
- DAY10
- - 1、接口概述與生活舉例
  - 2、接口的定義基本格式
  - 3、接口的抽象方法定義
  - 4、接口的抽象方法使用
  - 5、接口的默認方法定義
  - 6、接口的默認方法使用
  - 7、接口的靜態方法定義
  - 8、接口的靜態方法使用
  - 9、接口的私有方法定義
  - 10、接口的私有方法使用
  - - 同樣接口中的靜態方法也是如此
  - 11、接口的常量定義和使用
  - 12、接口的內容小結
  - 13、繼承父類并實現多個接口
  - - 1、接口是沒有靜態代碼塊或者構造方法的。
    - 2、一個類的直接父類是唯一的，但是一個類可以同時實現多個接口。
    - 3、如果實現類所實現的多個接口當中，存在重復的抽象方法，那么只需要覆蓋重寫一次即可.
    - 4、如果實現類沒有覆蓋重寫所有接口當中的所有抽方法，那么實現類就必須是一個抽象類。
    - 5、如果實現類所實現的多個接口當中，存在重復的默認方法，那么實現類一定要對沖突的默認方法進行覆蓋重寫。
    - 6、一個類如果直接父類當中的方法，和接口當中的默認方法產生了沖突，優先用父類當中的方法
  - 14、接口之間的多繼承
  - 15、多態的概述
  - 16、多態的格式與使用
  - 17、多態中成員變量的使用特點
  - 18、多態中成員方法的使用特點
  - 19、使用多態的好處
  - 20、對象的向上轉型與向下轉型
  - - 向上轉型
    - 向下轉型
  - 21、用instanceof關鍵字進行類型判斷
  - 22、筆記本USB接口案例
  - - 分析
    - 實現
- DAY11
- - 1、final關鍵字
  - - 1、可以用來修飾一個類
    - 2、可以用來修飾一個方法
    - 3、可以用來修飾一個局部變量
    - 4、可以用來修飾一個成員變量
  - 2、四種權限修飾符
  - - 同一個類
    - 同一個包
    - 不同包子類
    - 不同包非子類
  - 3、內部類的概念與分類
  - 4、成員內部類的定義
  - 5、成員內部類的使用
  - - 1、間接方式：
    - 2、直接方式：
  - 6、內部類的同名變量訪問
  - 7、局部內部類定義
  - 8、局部內部類的final問題
  - 9、匿名內部類的定義格式與注意事項
  - 10、類作為成員變量類型
  - 11、接口作為成員變量類型
  - 12、接口作為方法的參數和或返回值
  - 13、紅包案例
  - - 紅包頁面

DAY1

1、關于進制的運算

2、關于存儲單元

3、關于CMD的基本命令

4、JRE與JDK

JRE：是Java程序的運行時環境，包括JVM和運行時所需的核心類庫。

JDK：是Java程序開發工具包，包含JRE和開發人員使用的工具。

5、Java環境變量

變量名：JAVA_HOME

變量值：C:\Java\jdk-10.0.0（JAVA路徑）

變量名：Path

變量值：%JAVA_HOME%\bin;（在前面添加，注意加上；間隔）

6、程序開發步驟

7、HelloWorld

package Day1;public class HelloWord {public static void main(String[] args){System.out.println("Hello World!");}
}

8、標識符

標識符：是指在程序中，我們自己定義內容。比如類的名字、方法的名字和變量的名字等都是標識符
命名規則：硬性要求
- 標識符可以包含26個英文字母(區分大小寫)、0-9數字、$(美元符號)、_(下劃線)
- 標識符不能以數字開頭
- 標識符不能是關鍵字
命名規范：軟性建議
- 類名規范：首字母大寫，后面每個單詞首字母大寫（大駝峰式）
- 變量名規范：首字母小寫，后面每個單詞首字母大寫（小駝峰式）
- 方法名規范：同變量名

9、常量

類型	含義	數據舉例
整數常量	所有的整數	0，1，567，9
小數常量	所有的小數	0.0，-0.1，2.55
字符常量	單引號引起來，只能寫一個字符，必須有內容（可以為空格）	‘a’，’ '，‘好’
字符串常量	雙引號引起來，可以寫多個字符，也可以不寫	“A”，“Hello”，“您好”，""
布爾常量	只有一個值	true，false
空常量	只有一個值	null

10、數據類型

數據類型分類

Java的數據類型分為兩大類：

基本數據類型：包括整數、浮點數、字符、布爾
引用數據類型：包括類、數組、接口

基本數據類型

四類八種基本數據類型：

數據類型	關鍵字	內存占用	取值范圍
字節型	byte	1個字節	-128~127
短整型	short	2個字節	-32768~32767
整型	int（默認）	4個字節	-2³¹～2³¹-1
長整型	long	8個字節	-2⁶³～2⁶³-1
單精度浮點數	float	4個字節	1.4013E-45～3.4028E+38
雙精度浮點數	double（默認）	8個字節	4.9E-324~1.7977E+308
字符型	char	2個字節	0-65535
布爾類型	boolean	1個字節	true、false

注意事項：

字符串不是基本類型，而是引用類型
浮點型可能只是一個近似值，并非精確的值
數據范圍與字節數不一定相關，例如float數據范圍比long更加廣泛，但是float是4字節，long是8字節
浮點數當中默認類型是doube，如果一定要使用float類型，需要加上一個后綴F。大小寫都可以，推薦使用大寫字母后綴
整數當中默認類型是int，如果一定要使用long類型，需要加上一個后綴L。大小寫都可以，推薦使用大寫字母后綴

11、變量

變量：程序運行期間，內容可以發生改變的量

創建一個變量并且使用的格式：

數據類型變量名稱； //創建了一個變量
變量名稱 = 數據值； //賦值，將右邊的數據值，賦值交給左邊的變量

一步到位的格式：

數據類型變量名稱 = 數據值； //在創建一個變量的同時，立刻放入指定的數據值

注意事項：

如果創建多個變量，那么變量之間的名稱不可以重復
對于float和long類型來說，字母后綴F和L不要丟掉
如果使用byte或者short類型的變量，那么右側的數據值不能超過左側類型的范圍
沒有進行賦值的變量，不能直接使用，一定要賦值之后，才能使用
變量使用不能超過作用域的范圍
可以通過一個語句來創建多個變量，但是一般情況不推薦這么寫

DAY2

1、數據類型轉換

當數據類型不一樣時，將會發生數據類型轉換

自動類型轉換（隱式）

特點：代碼不需要進行特殊處理，自動完成
規則：數據范圍從小到大

System.out.println(1024);   // 這就是一個整數，默認就是int類型
System.out.println(3.14);   // 這就是一個浮點數，默認就是double類型// 左邊是long類型，右邊是默認的int類型，左右不一樣
// 一個等號代表賦值，將左側的int常量，交給左側的long變量進行存儲
// int --> long,符合了數據范圍從小到大的要求
// 這一行代碼發生了自動類型轉換
long num1 = 100;
System.out.println(num1);   // 100// 左邊是double類型，右邊是float類型，左右不一樣
// float --> double,符合從小到大的規則
// 也發生了自動類型轉換
double num2 = 2.5F;
System.out.println(num2);   //2.5// 左邊是float類型，右邊是long類型，左右不一樣
// long --> float,范圍是float更大一些，符合從小到大的規則
// 也發生了自動類型轉換
float num3 = 30L;
System.out.println(num3);   //30.0

強制類型轉換（顯式）

特點：代碼需要進行特殊的格式處理，不能自動完成

格式：范圍小的類型范圍小的變量名 = （范圍小的類型）原本范圍大的數據

注意事項：

強制類型轉換一般不推薦使用，因為有可能發生精度損失、數據溢出
byte/short/char這三種類型都可以發生數學運算，例如加法“+”
byte/short/char這三種類型在運算的時候，都會被首先提升成為int類型，然后再計算
boolean類型不能發生數據類型轉換

// 左邊是int類型，右邊是long類型，不一樣
// long --> int，不是從小到大
// 不能發生自動類型轉換
// 格式：范圍小的類型  范圍小的變量名  =  （范圍小的類型）  原本范圍大的數據
int num = (int) 100L;
System.out.println(num);// long強制轉換成為int類型
int num2 = (int) 6000000000L;
System.out.println(num2);   // 結果：1705032704// double --> int，強制類型轉換
int num3 = (int) 3.99;
System.out.println(num3);   // 這并不是四舍五入，所有的小數位都會被舍棄char zifu1 = 'A';   // 這是一個字符型變量，里面是大寫字母A
System.out.println(zifu1 + 1);  // 66,也就是大寫字母A被當做65進行處理
// 計算機的底層會用一個數字（二進制）來代表字符A，就是65
// 一旦char類型進行數學運算，那么字符就會按照一定的規則翻譯成為一個數字byte num4 = 40; // 注意！右側的數值大小不能超過左側的類型范圍
byte num5 = 50;
// byte + byte --> int + int --> int
int result1 = num4 + num5;
System.out.println(result1);    //90short num6 = 60;
// byte + short --> int + int --> int
// int強制轉換為short：注意不需保證邏輯上真實大小本來就沒有超過short范圍，否則會發生數據溢出
short result2 = (short) (num4 + num6);
System.out.println(result2);    //100

2、ASCII編碼表

數字和字符的對照關系表（編碼表）:

ASCII碼表：American Standard Code for Information Interchange，美國信息交換標準代碼。
Unicode碼表：萬國碼。也是數字和符號的對照關系，開頭0-127部分和ASCII完全一樣，但是從128開始包含有更多字符

48 - ‘0’
65 - ‘A’
97 - ‘a’

char zifu1 = '1';System.out.println(zifu1 + 0);      //49char zifu2 = 'A';   //其實底層保存的是65數字char zifu3 = 'c';//左側是int類型，右邊是char類型//char --> int，確實是從小到大//發生了自動類型轉換int num = zifu3;System.out.println(num);    //99char zifu4 = '中';   //正確寫法System.out.println(zifu4 + 0);  //20013

3、算術運算符

運算符：進行特定操作的符號。例如： +
表達式：用運算符連起來的式子叫做表達式。例如：20+5、a+b

四則運算：
加： +
減： -
乘： *
除： /

取模（取余數）： %

首先計算得到表達式的結果，然后再打印輸出這個結果。
除法：被除數 / 除數 = 商 … 余數

對于一個整數的表達式來說，除法用的是整數，整數除以整數，結果仍然是整數。只看商，不看余數
只有對于整數的除法來說，取模運算符才有余數的意義。

注意事項：
1、一旦運算當中有不同類型的數據，那么結果將會是數據類型范圍大的那種。

// 兩個常量之間可以進行數學運算
System.out.println(20+30);// 兩個變量之間也可以進行數學運算
int a = 20;
int b = 30;
System.out.println(a - b);  // -10// 變量和常量之間可以混合使用
System.out.println(a * 10); // 200int x = 10;
int y = 3;int result1 = x / y;
System.out.println(result1);    // 3int result2 = x % y;
System.out.println(result2);    // 余數，模，1// int + double --> double + double --> double
double result3 = x + 2.5;
System.out.println(result3);    // 12.5

四則運算當中的加號“+”有常見的三種用法：

1、對于數值來說，那就是加法。
2、對于字符char類型來說，在計算之前，char會被提升成為int，然后再計算。
char類型字符，和int類型數字，之間的對照關系表：ASCII、Unicode
3、對于字符串String(首字母大寫，并不是關鍵字)來說，加號代表字符串連接。
任何數據類型和字符串進行連接的時候，結果都會變成字符串

// 字符串類型的變量基本使用
// 數據類型  變量名稱  =  數據值；
String str1 = "Hello";
System.out.println(str1);   // HelloSystem.out.println("Hello" + "World");  //HelloWorldString str2 = "Java";
// String + int --> String
System.out.println(str2 + 20);  //Java20// 優先級問題
// String + int + int
// String       + int
// String
System.out.println(str2 + 20 + 30); //Java2030System.out.println(str2 + (20 + 30));   //Java50

4、自增自減運算符

自增運算符： ++
自減運算符： –

基本定義：讓一個變量漲一個數字1，或者讓一個變量降一個數字1
使用格式：寫在變量名稱之前，或者寫在變量名稱之后。例如： ++num，也可以num++
使用方法：
1.單獨使用：不和其他任何操作混合，自己獨立成為一個步驟。
2.混合使用:和其他操作混合，例如與賦值混合，或者與打印操作混合等。
使用區別：
1.在單獨使用的時候，前++和后++沒有任何區別。也就是：++num；和num++；是完全一樣的。
2.在混合的時候，有重大區別
A.如果是前++，那么變量立刻馬上+1，然后拿著結果進行使用。 先加后用
B.如果是后++，那么首先使用變量本來的數值，然后在讓變量+1. 先用后加

注意事項：
只有變量才能使用自增、自減運算符。常量不可以發生改變，所有不能用。

int num1 = 10;
System.out.println(num1);   // 10
++num1; // 單獨使用，前++
System.out.println(num1);   // 11
num1++; // 單獨使用，后++
System.out.println(num1);   // 12System.out.println("====================");// 與打印操作混合的時候
int num2 = 20;
// 混合使用，先++，變量立刻馬上變成21，然后打印結果21
System.out.println(++num2); // 21
System.out.println(num2);   // 21System.out.println("====================");int num3 = 30;
// 混合使用，后++，首先使用變量本來的30，然后在讓變量+1得到31
System.out.println(num3++); // 30
System.out.println(num3);   // 31System.out.println("====================");int num4 = 40;
// 和賦值操作混合
int result1 = --num4;   // 混合使用，前--，變量立刻馬上-1變成39，然后將結果39交給result1變量
System.out.println(result1);    // 39
System.out.println(num4);       // 39System.out.println("====================");int num5 = 50;
// 混合使用，后--，首先把本來的數字50交給result2，然后自己再-1變成49
int result2 = num5--;
System.out.println(result2);    // 50
System.out.println(num5);       // 49System.out.println("====================");int x = 10;
int y = 20;
// 11 + 20 = 31
int result3 = ++x + y--;
System.out.println(result3);    //31
System.out.println(x);  // 11
System.out.println(y);  // 19// 30++;    // 錯誤寫法！ 常量不可以使用++或者--

5、賦值運算符

賦值運算符分為：

基本賦值運算符：就是一個等號“=”，代表將右側的數據交給左側的變量。
int a = 30;

復合賦值運算符：

    +=      a += 1      相當于     a = a + 1-=      b -= 1      相當于     b = b - 1*=      c *= 1      相當于     c = c * 1/=      d /= 1      相當于     d = d / 1%=      e %= 1      相當于     e = e % 1

注意事項：
1、只有變量才能使用賦值運算符，常量不能進行賦值。
2、復合賦值運算符其中隱含了一個強制類型轉換。

int a = 10;
// 按照公式進行翻譯： a = a + 5
a += 5;
System.out.println(a);  // 15int x = 10;
// x = x % 3;
x %= 3;
System.out.println(x);  // 1byte num = 30;
// num = num + 5;
// num = byte + int
// num = int + int
// num = int
// num = (byte) int
num += 5;
System.out.println(num);    //35

6、比較運算符

比較運算符：
大于： >
小于： <
大于等于： >=
小于等于： <=
相等： == [兩個等號連寫才是相等，一個等號代表的是賦值]
不相等： !=

注意事項：
1、比較運算符的結果一定是一個boolean值，成立就是true，不成立就是false。
2、如果進行多次判斷，不能連這些。
數學當中的寫法，例如： 1 < x < 3
程序當中不予許這種寫法。

System.out.println(10 > 5);         // true
int num1 = 10;
int num2 = 12;
System.out.println(num1 < num2);    // true
System.out.println(num2 >= 100);    // false
System.out.println(num2 <= 100);    // true
System.out.println(num2 <= 12);     // true
System.out.println("==================");System.out.println(10 == 10);       // true
System.out.println(20 != 25);       // true
System.out.println(20 != 20);       // false

7、邏輯運算符

與（并且） && 全部都是true，才是true；否則就是false
或（或者） || 還少一個true，就是true；全部是false，才是false
非（取反）！本來是true，變成false；本來是false，變成true

與"&&"，或"||"，具有短路效果：如果根據左邊已經可以判斷得到最終結果，那么右邊的代碼將不在執行，從而節省一定的性能

注意事項：
1、邏輯運算符只能用于boolean值。
2、與、或需要左右各自有一個boolean值，但是取反只要有唯一的一個boolean即可。
3、與、或兩種運算符，如果有多個條件，可以連續寫。
兩個條件：條件A && 條件B
多個條件：條件A && 條件B && 條件C

TIPS：
對于1 < x < 3的情況，應該拆成兩個部分，然后使用與運算符連接起來：
int x = 2;
1 < x && x < 3

System.out.println(true && false);   // false
// true && true --> true
System.out.println(3 < 4 && 10 > 5);    // trueSystem.out.println("================");System.out.println(true || false);  // true
System.out.println(true || true);  // true
System.out.println(false || false);  // falseSystem.out.println("================");System.out.println(true);   // true
System.out.println(!true);  // falseSystem.out.println("================");int a = 10;
// false && ...
System.out.println(3 > 4 && ++a < 100); // false
System.out.println(a);  //10System.out.println("================");int b = 20;
// true || ...
System.out.println(3 < 4 || ++b < 100); // true
System.out.println(b);  // 20

8、三元運算符

一元運算符：只需要一個數據就可以進行操作的運算符。例如：取反！、自增++、自減–
二元運算符：需要兩個數據才可以進行操作的運算符。例如：加法+、賦值=
三元運算符：需要三個數據才可以進行操作的運算符。

格式：
數據類型變量名稱 = 條件判斷？表達式A ：表達式B；

流程：
首先判斷條件是否成立：
如果成立為true，那么將表達式A的值賦值給左側的變量；
如果不成立為false，那么將表達式B的值賦值給左側的變量；
二者選其一

注意事項：
1、必須同時保證表達式A和表達式B都符合左側數據類型的要求。
2、三元運算符的結果必須被使用。

public static void main(String[] args) {int a = 10;int b = 20;// 數據類型  變量名稱  =  條件判斷  ？  表達式A  ：  表達式B；// 潘丹a > b是否成立，如果成立將a的值賦值給max；如果不成立將b的值賦值給max。二者選其一int max = a > b ? a : b;    // 最大值的變量System.out.println("最大值：" + max);   // 20// int result = 3 > 4 ? 2.5 : 10;   // 錯誤寫法！System.out.println(a > b ? a : b);  // 正確寫法！// a > b ? a : b;   // 錯誤寫法！
}

9、方法定義與調用

定義一個方法的格式：
public static void 方法名稱() {
方法體
}

方法名稱的命名規則和變量一樣，使用小駝峰規則（首字母小寫，后面單詞的首字母大寫）。
方法體：也就是大括號當中可以包含任意條語句。

注意事項：
1、方法定義的先后順序無所謂。
2、方法的定義不能產生嵌套包含關系。
3、方法定義好了之后，不會自動執行。如果想要執行，一定要進行方法的調用

如何調用方法，格式：

方法名稱();

public static void main(String[] args) {farmer();   // 調用農民的方法seller();   // 調用小商販的方法cook();     // 調用廚子的方法me();       // 調用自己s的方法
}// 我
public static void me() {System.out.println("吃");
}// 廚子
public static void cook() {System.out.println("洗菜");System.out.println("切菜");System.out.println("炒菜");System.out.println("裝盤");
}// 小商販
public static void seller() {System.out.println("運輸到農貿市場");System.out.println("抬高價格");System.out.println("吆喝");System.out.println("賣給廚子");
}// 農民
public static void farmer() {System.out.println("播種");System.out.println("澆水");System.out.println("施肥");System.out.println("除蟲");System.out.println("收割");System.out.println("賣給小商販");
}

10、編譯器的兩點優化

1、自動添加隱含類型

對于byte/short/char三種類型來說，如果右側賦值的數值沒有超過范圍，
那么javac編譯器將會自動隱含的為我們補上一個(byte)(short)(char)

1、如果沒有超過左側的范圍，編譯器補上強轉。
2、如果右側超過了左側范圍，那么直接編譯器報錯。

public static void main(String[] args) {// 右側確實時一個int數字，但是沒有超過左側的范圍，就是正確的。// int --> byte，不是自動類型轉換byte num1 = /*(byte)*/ 30;  // 右側沒有超過左側的范圍System.out.println(num1);   // 30// byte num2 = 128;     // 右側超過了左側的范圍// int --> char，沒有超過左側的范圍// 編譯器將會自動補上一個隱含的(char)char zifu = /*(char)*/ 65;System.out.println(zifu);   // A
}

2、常量優化

在給變量進行賦值的時候，如果右側的表達式當中全都是常量，沒有任何變量，
那么編譯器javac將會直接將若干個常量表達式計算得到結果。
short result = 5 + 8; // 等號右邊全都是常量，沒有任何變量參與運算
編譯之后，得到的.class字節碼文件當中相當于直接就是：
short result = 12;
右側的常量結果數值，沒有超過左側范圍，所以正確。

這稱為“編譯器的常量優化”。

但是注意：一旦表達式當中有變量參與，那么就不能進行這種優化了。

public static void main(String[] args) {short num1 = 10;    // 正確寫法，右側沒有超過左側的范圍，short a = 5;short b = 8;// short + short --> int + int --> int// short result = a + b;    // 錯誤寫法！左側需要是int類型// 右側不用變量，而時采用常量，而且只有兩個常量，沒有別人short result = 5 + 8;System.out.println(result);// short result2 = 5 + a + 8;  // 含有變量即出錯
}

DAY3

1、ifelse語句

標準的if-else語句

public static void main(String[] args) {int num = 666;if (num % 2 == 0) {     // 如果除以2能夠余數為0，說明時偶數System.out.println("偶數");} else {System.out.println("奇數");}
}

2、ifelseifelse語句

x和y的關系滿足如下：
如果x >= 3，那么y = 2x + 1；
如果-1 < x < 3，那么y = 2x；
如果x <= -1，那么y = 2x - 1；

public static void main(String[] args) {int x = -10;int y;if (x >= 3) {y = 2 * x + 1;} else if (-1 < x && x < 3) {y = 2 * x;} else {y = 2 * x - 1;}System.out.println("結果是：" + y);
}

3、ifelse練習

public static void main(String[] args) {int score = 98;if (score >= 90 && score <= 100) {System.out.println("優秀");} else if (score >= 70 && score < 90) {System.out.println("良好");} else if (score >= 60 && score < 70) {System.out.println("及格");} else if (score >= 0 && score < 60) {System.out.println("不及格");} else {    // 單獨處理邊界之外的不合理情況System.out.println("分數錯誤");}
}

4、使用if語句替換三元運算符

使用三元運算符和標準的if-else語句分別實現：取兩個數字當中的最大值

public static void main(String[] args) {int a = 105;int b = 20;// 首先使用三元運算符// int max = a > b ? a : b// 使用if語句int max;if (a > b) {max = a;} else {max = b;}System.out.println("最大值：" + max);
}

5、switch

switch語句使用的注意事項：

1、多個case后面的數值不可以重復。

2、switch后面小括號當中只能時下列數據類型：
基本數據類型： byte/short/char/int
引用數據類型： String字符串、enum枚舉

3、switch語句格式可以很靈活：前后順序可以顛倒，而且break語句還可以省略
“匹配哪一個case就從哪一個位置向下執行，知道遇到lebreak或者整體結束為止。”

public static void main(String[] args) {int num = 1;switch (num) {case 1:System.out.println("星期一");break;case 2:System.out.println("星期二");break;case 3:System.out.println("星期三");break;case 4:System.out.println("星期四");break;case 5:System.out.println("星期五");break;case 6:System.out.println("星期六");break;case 7:System.out.println("星期七");break;default:System.out.println("數據不合理");break;  // 最后一個break語句可以省略，但是強烈推薦不要省略}
}

6、循環結構

循環結構的基本組成部分，一般可以分成四部分：

1、初始化語句：在循環開始最初執行，而且只能做唯一一次。

2、條件判斷：如果成立，則循環繼續；如果不成立，則循環退出。

3、循環體：重復要做的事情內容，若干行語句。

4、步行語句：每次循環之后都要進行的掃尾工作，每次循環結束之后都要執行一次。

7、求出1-100之間的偶數和

題目：求出1-100之間的偶數和。

思路：
1、既然范圍已經確定了是1到100之間，那么我就從1、2、3……一直到100那么多數字一個一個檢查。
2、總共有100個數字，并非所有數字都有用。必須要是偶數才能用，判斷（if語句）偶數： num % 2 == 0
3、需要一個變量，用來進行累加操作。如同一個存錢罐

public static void main(String[] args) {int sum = 0;    // 用來累加的存錢罐for (int i = 1; i <= 100; i++) {if (i % 2 == 0) {   // 如果時偶數sum += i;}}System.out.println("1-100之間的偶數和：" + sum);
}

8、三種循環的區別

1、如果條件判斷從來沒有滿足過，那么for循環和while循環將會執行0次，但是do-while循環會執行最少一次。
2、for循環的變量在小括號當中定義，只有循環內部才可以使用。while循環和do-while循環初始化語句本來就在外面，所以出來循環之后還可以繼續使用。

public static void main(String[] args) {for (int i = 1; i < 0; i++) {System.out.println("Hello");}// System.out.println(i);  // 這一行時錯誤寫法！因為變量i定義在for循環下括號內，只有for循環自己才能用。System.out.println("===============");int i = 1;do {System.out.println("World");i++;} while (i < 0);// 現在已經超出了do-while循環的范圍，我們仍然可以使用變量iSystem.out.println(i);  // 2
}

9、break

break關鍵字的用法有常見的兩種：
1、可以用在switch語句當中，一旦執行，整個switch語句立刻結束。
2、還可以用在循環語句當中，一旦執行，整個循環語句立刻結束。打斷循環。

關于循環的選擇，有一個小建議：
凡是次數確定的場景多用for循環；否則多用while循環。

public static void main(String[] args) {for (int i = 1; i <= 10; i++) {// 如果希望從第4次開始，后續全都不要了，就要打斷循環if (i == 4) {   // 如果當前是第4次break;  // 那么就打斷整個循環}System.out.println("Hello" + i);}
}

10、continue

另一種循環控制語句時continue關鍵字。
一旦執行，立刻跳過當前次循環剩余內容，馬上開始下一次循環。

public static void main(String[] args) {for (int i = 1; i <= 10; i++) {if (i == 4) {   // 如果當前是第4層continue;   // 那么跳過當前次循環，馬上開始下一次(第5層)}System.out.println(i + "層到了。");}
}

11、死循環

永遠停不下來的循環，叫做死循環。

死循環的標準格式：

while (true) {循環體
}

public static void main(String[] args) {while (true) {System.out.println("Hello");}
}

12、嵌套循環

題目：顯示時間小時分鐘秒

public static void main(String[] args) {for (int hour = 0; hour < 24; hour++) { // 外層控制小時for (int minute = 0; minute < 60; minute++) {   // 內置控制小時之內的分鐘for (int second = 0; second < 60; second++){    // 內置控制分鐘之內的秒System.out.println(hour + "點" + minute + "分" + second + "秒");}}}
}

DAY4

1、IDEA

Integrated Development Environment，IDE，集成開發環境

開發Java程序的步驟：
1、編寫代碼
2、啟動cmd
3、調用javac編譯
4、調用java運行

集成開發環境，是一種專門用來提高Java開發效率的軟件。

免費的IDE當中：Eclipse

收費的IDE當中：IntelliJ IDEA

免費+收費所有的IDE當中：全世界用得最多的就是IntelliJ IDEA

psvm

public static void main(String[] args) {}

sout

System.out.println();

常用設置

File→Settings

字體設置

Editor→Font

快捷鍵設置

數據庫

Keymap→Tool Windows→Database Ctrl+8

代碼補全

Main menu→Code→Completion→Basic Alt+/

代碼模板

Template	IntelliJ IDEA
Define a main method	psvm
Iterate over an array	itar
Iterate over a collection	itco
Iterate over a list	itli
Iterate over an iterable using foreach syntax	iter
Print to System.out	sout
Print to System.err	serr
Define a static field	psf

2、項目結構

Create New Project

New Module

New Package

3、IDEA常用快捷鍵

快捷鍵	功能
Alt+Enter	導入包，自動修正代碼
Ctrl+Y	刪除光標所在行
Ctrl+D	復制光標所在行的內容，插入光標位置下面
Ctrl+Alt+L	格式化代碼
Ctrl+/	單行注釋
Ctrl+Shift+/	選中代碼注釋，多行注釋，再按取消注釋
Alt+Ins	自動生成代碼，toString，get，set等方法
Alt+Shift+上下箭頭	移動當前代碼行
shift + F6	選中修改對象

4、復習一下嵌套循環

public static void main(String[] args) {for (int i = 0; i < 5; i++) {for (int j = 0; j < 20; j++) {System.out.print("*");}System.out.println();}
}

5、方法的定義與調用

方法其實就是若干語句的功能集合。

方法好比是一個工廠。
蒙牛工廠原料：奶牛、飼料、水
產出物：奶制品

鋼鐵工廠原料：鐵礦石、煤炭
產出物：鋼鐵建材

參數（原料）：就是進入方法的數據。
返回值（產出物）：就是從方法中出來的數據。

定義方法的完整格式：
修飾符返回值類型方法名稱（參數類型參數名稱，……）{
方法體
return 返回值；
}

修飾符：現階段的固定寫法，public static
返回值類型：也就是方法最終產生的數據結果是什么類型
方法名稱：方法的名字，規則和變量一樣，小駝峰
參數類型：進入方法的數據是什么類型
參數名稱：進入方法的數據對應的變量名稱
PS：參數如果有多個，使用逗號進行分隔
方法體：方法需要做的事情，若干行代碼
return：兩個作用，第一停止當前方法，第二將后面的返回值還給調用處
返回值：也就是方法執行后最終產生的數據結果

注意：return后面的“返回值”，必須和方法名稱前面的“返回值類型”，保持對應。

定義一個兩個int數字相加的方法。三要素：
返回值類型：int
方法名稱：sum
參數列表：int a, int b

方法的三種調用格式。
1、單獨調用：方法名稱(參數);
2、打印調用：System.out.println(方法名稱(參數));
3、賦值調用：數據類型變量名稱 = 方法名稱(參數);

注意：此前學習的方法，返回值類型固定寫為void，這種方法只能夠單獨調用，不能進行打印調用或者賦值調用。

public static void main(String[] args) {// 單獨調用sum(10,20);System.out.println("===========");// 打印調用System.out.println(sum(10,20));     // 30System.out.println("===========");// 賦值調用int number = sum(15,25);System.out.println("變量的值為：" + number);
}public static int sum(int a, int b) {System.out.println("方法已執行");int result = a + b;return result;
}

6、有參與無參

有參數：小括號當中有內容，當一個方法需要一些數據條件，才能完成任務的時候就是有參數。
例如兩個數字相加，必須知道兩個數字是多少，才能相加。

無參數：小括號當中留空。一個方法不需要任何數據條件，自己就能獨立完成任務，就是無參數。
例如定義一個方法，打印固定10次HelloWorld。

public static void main(String[] args) {method1(10,20);System.out.println("=================");method2();
}// 兩個數字相乘，做乘法，必須知道兩個數字各自是多少，否則無法進行計算
// 有參數
public static void method1(int a, int b) {int result = a * b;System.out.println("結果是：" + result);
}// 例如打印輸出固定10次文本字符串
public static void method2() {for (int i = 0; i < 10; i++) {System.out.println("Hello,World!" + i);}
}

7、練習題1

題目要求：定義一個方法，用來求出兩個數字之和。(你幫我算，算完之后把結果告訴我。)
題目變形：定義一個方法，用來求出兩個數字之和。(你來計算，算完之后你自己負責顯示結果，不用告訴我。)

注意事項：
對于有返回值的方法，可以使用單獨調用、打印調用或者賦值調用。
但是對于無返回值的方法，只能使用單獨調用，不能使用打印調用或者賦值調用。

public static void main(String[] args) {// 我是main方法，我來調用你// 我調用你，你來幫我計算一下，算完之后，把結果告訴我的num變量int num = getSum(10,20);System.out.println("返回值是：" + num);System.out.println("========================");printSum(100,200);System.out.println("========================");System.out.println(getSum(2,3));    // 正確寫法getSum(3,5);    // 正確寫法，但是返回值沒有用到System.out.println("========================");// 對于void沒有返回值的方法，只能單獨，不能打印或者賦值
//        System.out.println(printSum(2,3);); // 錯誤寫法！
//        System.out.println(void);//        int num2 = printSum(10,20); // 錯誤寫法！
//        int num3 = void;
//        void num4 = void;}// 我是一個方法，我負責兩個數字相加。// 我有返回值int，誰調用我，我就把計算結果告訴誰public static int getSum(int a, int b) {int result = a + b;return result;}// 我是一個方法，我負責兩個數字相加。// 我沒有返回值，不會把結果告訴任何人，而是我自己進行打印輸出public static void printSum(int a, int b) {int result = a + b;System.out.println("結果是：" + result);}

8、練習題2

題目要求：
定義一個方法，用來判斷兩個數字是否相同。

public static void main(String[] args) {System.out.println(isSame(10,20));System.out.println(isSame(20,20));}/*三要素：返回值類型： boolean方法名稱： isSame參數列表： int a, int b*/public static boolean isSame(int a, int b) {// 方法一
//        boolean same;
//        if (a == b) {
//            same = true;
//        } else {
//            same = false;
//        }// 方法二
//        boolean same = a == b ? true : false;// 方法三
//        boolean same = a == b;//        return same;return a == b;}

9、練習題3

題目要求：
定義一個方法，用來求出1-100之間所有數字的和值。

public static void main(String[] args) {System.out.println("結果是：" + getSum());
}/*
三要素：
返回值： 有返回值，計算結果時一個int數字
方法名稱： getSum
參數列表： 數據范圍已經確定，是固定的，所以不需要告訴我任何條件，不需要參數*/public static int getSum() {int sum = 0;for (int i = 1; i <= 100; i++) {sum += i;}return sum;
}

10、練習題4

題目要求：
定義一個方法，從來打印制定次數的HelloWord。

public static void main(String[] args) {printCount(10);
}/*
三要素
返回值類型： 只是進行一大堆打印操作而已，沒有計算，也沒有結果要告訴調用處
方法名稱： printCount
參數列表： 到底要打印多少次？必須告訴我，否則我不知道多少次，沒法打印。次數：int*/
public static void printCount(int num) {for (int i = 0; i < num; i++) {System.out.println("Hello, World!" + (i+1));}
}

11、使用方法的注意事項

使用方法的時候，注意事項：

1、方法應該定義在類當中，但是不能在方法當中再定義方法。
2、方法定義的前后順序無所謂。
3、方法定義之后不會執行，如果希望執行，一定要調用：單獨調用、打印調用、賦值調用。
4、如果方法有返回值，那么必須寫上“return 返回值;”，不能沒有。
5、return后面的返回值數據，必須和方法的返回值類型，對應起來。
6、對于一個void沒有返回值的方法，不能寫return后面的返回值，只能寫return自己。
7、對于方法當中最后一行的return可以省略不寫。
8、一個方法當中可以有多個return語句，但是必須保證同時只有一個會被執行到,兩個return不能連寫。

public static int method1() {return 10;}public static void method2() {
//        return 10;  // 錯誤寫法！方法沒有返回值，return后面就不能寫返回值。return; // 沒有返回值，只是結束方法的執行而已。}public static void method3() {System.out.println("AAA");System.out.println("BBB");
//        return; // 最后一行的return可以省略不寫。}public static int getMax(int a, int b) {
//        int max;
//        if (a > b) {
//            max = a;
//        } else {
//            max = b;
//        }
//        return max;if (a > b) {return a;} else {return b;}}

12、方法的重載

對于功能類似的方法來說，因為參數列表不一樣，卻需要記住那么多不同的方法名稱，太麻煩。

方法的重載（Overload），多個方法的名稱一樣，但是參數列表不一樣。
好處：只需要記住唯一一個方法名稱，就可以實現類似的多個功能。

方法重載與下列因素相關：
1、參數個數不同
2、參數類型不同
3、參數的多類型順序不同

方法重載與下列因素無關：
1、與參數的名稱無關
2、與方法的返回值類型無關

public static void main(String[] args) {System.out.println(sum(10,20));      // 30  兩個參數的方法System.out.println(sum(10,20,30));     // 60    三個參數的方法System.out.println(sum(10,20,30,40));   // 100  四個參數的方法
//        System.out.println(sum(10,20,30,40,50));    // 找不到任何方法來匹配，錯誤！}// 參數的多類型順序不同public static int sum(int a, double b) {return (int) (a + b);}public static int sum(double a, int b) {return (int) (a + b);}public static int sum(int a, int b) {return a + b;}// 錯誤寫法！與方法的返回值類型無關
//    public static double sum(int a, int b) {
//        return a + b;
//    }// 錯誤寫法！與參數的名稱無關
//    public static int sum(int x, int y) {
//        return x + y;
//    }// 參數類型不同public static int sum(double a, double b) {return (int) (a + b);}public static int sum(int a, int b, int c) {return a + b + c;}public static int sum(int a, int b, int c, int d) {return a + b + c + d;}

13、重載練習一

題目要求：
比較兩個數據是否相等。
參數類型分別為兩個byte類型，兩個short類型，兩個int類型，兩個long類型，
并在main方法中進行測試。

public static void main(String[] args) {byte a = 10;byte b = 20;System.out.println(isSame(a,b));System.out.println(isSame((short) 20, (short) 20));System.out.println(isSame(11,12));System.out.println(isSame(10L,10L));
}public static boolean isSame(byte a, byte b) {System.out.print("兩個byte值是否相同：");boolean same;if (a == b) {same = true;} else {same = false;}return same;
}public static boolean isSame(short a, short b) {System.out.print("兩個short值是否相同：");boolean same = a == b ? true : false;return same;
}public static boolean isSame(int a, int b) {System.out.print("兩個int值是否相同：");return a == b;
}public static boolean isSame(long a, long b) {System.out.print("兩個long值是否相同：");if (a == b) {return true;} else {return false;}
}

14、重載練習二

判斷哪些方法時重載關系

public static void open(){}     // 正確重載
public static void open(int a){}    // 正確重載
static void open(int a,int b){}     // 代碼錯誤：與最后一個沖突
public static void open(double a,int b){}   // 正確重載
public static void open(int a,double b){}   // 代碼錯誤：與下一個沖突
public void open(int i,double d){}      // 代碼錯誤：與上一個沖突
public static void OPEN(){}     // 代碼正確不會報錯，但是并不是有效重載
public static void open(int i,int j){}  // 代碼錯誤，與第三個沖突

15、重載練習三

byte short int long float double char boolean
String
在調用輸出語句的時候，println方法其實就是進行了多種數據類型的重載方式。

public static void main(String[] args) {myPrint(100);myPrint("Hello");
}public static void myPrint(byte num) {System.out.println(num);
}public static void myPrint(short num) {System.out.println(num);
}public static void myPrint(int num) {System.out.println(num);
}public static void myPrint(long num) {System.out.println(num);
}public static void myPrint(float num) {System.out.println(num);
}public static void myPrint(double num) {System.out.println(num);
}public static void myPrint(char zifu) {System.out.println(zifu);
}public static void myPrint(boolean is) {System.out.println(is);
}public static void myPrint(String str) {System.out.println(str);
}

DAY5

1、數組的概念

數組的概念：時一種容器，可以同時存放多個數據值。

數組的特點：
1、數組是一種引用數據類型
2、數組當中的多個數據，類型必須統一
3、數組的長度在程序運行期間不可改變

數組的初始化：
在內存當中創建一個數組，并且向其中賦予一些默認值。

兩個常見的初始化方式：
1、動態初始化（指定長度）
2、靜態初始化（指定內容）

動態初始化數組的格式：
數據類型[] 數組名稱 = new 數據類型[數組長度];

解析含義：
左側數據類型：也就是數組當中保存的數據，全都是統一的數據類型
左側的中括號：代表我是一個數組
左側數組名稱：給數組取一個名字
右側的new：代表創建數組的動作
右側數據類型：必須和左邊的數據類型保持一致
右側中括號的長度：也就是數組當中，到底可以保存多少個數據，是一個int數字

public static void main(String[] args) {// 創建一個數組，里面可以存放300個int數據// 格式：數數據類型[] 數組名稱 = new 數據類型[數組長度];int[] arrayA = new int[300];// 創建一個數組，能存放10個double類型的數據double[] arrayB = new double[10];// 創建一個數組，能存放5個字符串String[] arrayC = new String[5];
}

2、動態初始化與靜態初始化

動態初始化（指定長度）：在創建數組的時候，直接指定數組當中的數據元素個數。
靜態初始化（指定內容）：在創建數組的時候，不直接指定數據個數多少，而是直接將具體的數據內容進行指定。

靜態初始化基本格式：
數據類型[] 數組名稱 = new 數據類型[] {元素1，元素2， … }

注意事項：
雖然靜態初始化沒有直接告訴長度，但是根據大括號里面的元素具體內容，也可以自動推算出來長度。

public static void main(String[] args) {// 直接創建一個數組，里面裝的全都是int數字，具體為：5、15、25int[] arrayA = new int[] { 5, 15, 25 };// 創建一個數組，用來裝字符串："Hello"、"World"、"Java"String[] arrayB = new String[] { "Hello", "World", "Java" };
}

3、靜態初始化（省略格式）

使用靜態初始化數組的時候，格式可以省略一下。

標準格式：
數據類型[] 數組名稱 = new 數據類型[] {元素1，元素2， … };

省略格式：
數據類型[] 數組名稱 = {元素1，元素2， … };

注意事項：
1、靜態初始化滅有直接指定長度，但是仍然會自動推算得到長度。
2、靜態初始化標準格式可以拆分稱為兩個步驟。
3、動態初始化也可以拆分成為兩個步驟。
4、靜態初始化一旦使用省略格式，就不能拆分成為兩個步驟了。

使用建議：
如果不確定數組當中的具體內容，用動態初始化；否則，已經確定了具體的內容，用靜態初始化。

public static void main(String[] args) {// 省略格式的靜態初始化int[] arrayA = { 10, 20 ,30 };// 靜態初始化的標準格式，可以拆分成為兩個步驟int[] arrayB;arrayB = new int[] { 11, 21, 31 };// 動態初始化也可以拆分成為兩個步驟int[] arrayC;arrayC = new int[5];// 靜態初始化的省略格式，就不能拆分成為兩個步驟。
//        int[] arrayD;
//        arrayD = { 10, 20, 30 }}

4、訪問數組元素（獲取）

直接打印數組名稱，得到的時數組對應的：內存地址哈希值。
二進制：01
十進制：0123456789
16進制：012356789abcdef

訪問數組元素的格式：數組名稱[索引值]
索引值：就是一個int數字，代表數組當中元素的編號。
【注意】索引值cong0開始，一直到“數組的長度-1”為止、

public static void main(String[] args) {// 靜態初始化的省略格式int[] array = { 10, 20, 30 };System.out.println(array);  // [I@5e2de80c  內存地址// 直接打印數組當中的元素System.out.println(array[0]);   // 10System.out.println(array[1]);   // 20System.out.println(array[2]);   // 30System.out.println("==================");// 也可以將數組當中的某一個單個元素，賦值交給變量int num = array[1];System.out.println(num);    // 20
}

5、訪問數組元素（賦值）

使用動態初始化數組的時候，其中的元素將會自動擁有一個默認值。規則如下：
如果是整數類型，那么默認為0；
如果是浮點類型，那么默認為0.0；
如果是字符類型，那么默認為’\u0000’；
如果是布爾類型，那么默認為false；
如果是引用類型，那么默認為null。

注意事項：
靜態初始化其實也有默認值的過程，只不過系統自動馬上將默認值替換成了大括號當中的具體數值。

public static void main(String[] args) {// 動態初始化一個數組int[] array = new int[3];System.out.println(array);  // 內存地址值System.out.println(array[0]);   // 0System.out.println(array[1]);   // 0System.out.println(array[2]);   // 0System.out.println("====================");// 將數據123賦值交給數組array當中的1號元素array[1] = 123;System.out.println(array[0]);   // 0System.out.println(array[1]);   // 123System.out.println(array[2]);   // 0
}

6、內存的劃分

Java的內存需要劃分成為5個部分：
1、棧（Stack）：存放的都是方法中的局部變量。方法的運行一定要在棧當中運行。
局部變量：方法的參數，或是方法{}內部的變量
作用域：一旦超出作用域，立刻從棧內存當中消失。
2、堆（Hrap）：凡是new出來的東西，都在堆當中。
堆內存里面的東西都有一個地址值：16進制
堆內存里面的數據，都有默認值。規則：
如果是整數默認為0
如果是浮點數默認為0.0
如果是字符默認為’\u0000’
如果是布爾默認為false
如果是引用類型默認為null
3、方法區（Method Area）：存儲.class相關信息，包括方法的信息。
4、本地方法棧（Native Method Stack）：與操作系統相關。
5、寄存器（pc Register）：與CPU相關。

7、一個數組的內存圖

public static void main(String[] args) {int[] array = new int[3];   // 動態初始化System.out.println(array);  // 地址值System.out.println(array[0]);   // 0System.out.println(array[1]);   // 0System.out.println(array[2]);   // 0System.out.println("=================");// 改變數組當中元素的內容array[1] = 10;array[2] = 20;System.out.println(array);  // 地址值System.out.println(array[0]);   // 0System.out.println(array[1]);   // 10System.out.println(array[2]);   // 20
}

8、兩個數組的內存圖

public static void main(String[] args) {int[] arrayA = new int[3];   // 動態初始化System.out.println(arrayA);  // 地址值System.out.println(arrayA[0]);   // 0System.out.println(arrayA[1]);   // 0System.out.println(arrayA[2]);   // 0System.out.println("=================");arrayA[1] = 10;arrayA[2] = 20;System.out.println(arrayA);  // 地址值System.out.println(arrayA[0]);   // 0System.out.println(arrayA[1]);   // 10System.out.println(arrayA[2]);   // 20System.out.println("=================");int[] arrayB = new int[3];   // 動態初始化System.out.println(arrayB);  // 地址值System.out.println(arrayB[0]);   // 0System.out.println(arrayB[1]);   // 0System.out.println(arrayB[2]);   // 0System.out.println("=================");arrayB[1] = 100;arrayB[2] = 200;System.out.println(arrayB);  // 地址值System.out.println(arrayB[0]);   // 0System.out.println(arrayB[1]);   // 100System.out.println(arrayB[2]);   // 200
}

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-a0yljPnC-1590994988917)(http://ww1.sinaimg.cn/large/dcaa95eely1fwq8j0hk18j20la0d7wg0.jpg)]

9、兩個數組指向同一個地址值的內存圖

public static void main(String[] args) {int[] arrayA = new int[3];   // 動態初始化System.out.println(arrayA);  // 地址值System.out.println(arrayA[0]);   // 0System.out.println(arrayA[1]);   // 0System.out.println(arrayA[2]);   // 0System.out.println("=================");arrayA[1] = 10;arrayA[2] = 20;System.out.println(arrayA);  // 地址值System.out.println(arrayA[0]);   // 0System.out.println(arrayA[1]);   // 10System.out.println(arrayA[2]);   // 20System.out.println("=================");// 將arrayA數組的地址值賦值給arrayB數組int[] arrayB = arrayA;System.out.println(arrayB);  // 地址值System.out.println(arrayB[0]);   // 0System.out.println(arrayB[1]);   // 10System.out.println(arrayB[2]);   // 20System.out.println("=================");arrayB[1] = 100;arrayB[2] = 200;System.out.println(arrayB);  // 地址值System.out.println(arrayB[0]);   // 0System.out.println(arrayB[1]);   // 100System.out.println(arrayB[2]);   // 200
}

10、數組索引越界異常

數組的索引編號從0開始，一直到“數組的長度-1”為止。

如果訪問數組元素的時候，索引編號并不存在，那么將會發生
數組索引越界異常
ArrayIndexOutOfBoundsException

原因：索引編號寫錯了。
解決：修改成為存在的正確索引編號。

public static void main(String[] args) {int[] array = { 15, 25, 35 };System.out.println(array[0]);   // 15System.out.println(array[1]);   // 25System.out.println(array[2]);   // 35// 錯誤寫法// 并不存在3號元素，所以發生異常
//        System.out.println(array[3]);}

11、空指針異常

所有的引用類型變量，都可以賦值為一個null值。但是代表其中什么都沒有。

數組必須進行new初始化才能使用其中的元素。
如果只是賦值了一個null，沒有進行new創建，
那么將會發生：
空指針異常 NullPointerException

原因：忘了new
解決：加上new

public static void main(String[] args) {int[] array = null;array = new int[3];System.out.println(array[0]);
}

12、獲取數組的長度

如何獲取數組的長度，格式：

數組名稱.length

這將會得到一個int數字，代表數組的長度。

數組一旦創建，程序運行期間，長度不可改變。

public static void main(String[] args) {int[] arrayA = new int[3];int[] arrayB = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };int len = arrayB.length;System.out.println("arrayB數組的長度是：" + len);System.out.println("========================");int[] arrayC = new int[3];System.out.println(arrayC.length);  // 3arrayC = new int[5];System.out.println(arrayC.length);  // 5
}

13、數組遍歷輸出

遍歷數組，說的就是對數組當中的每一個元素進行逐一、挨個處理。默認的處理方式就是打印輸出。

public static void main(String[] args) {int[] array = { 10, 20, 30 };// 首先使用原始方式System.out.println(array[0]);   // 10System.out.println(array[1]);   // 20System.out.println(array[2]);   // 30System.out.println("=================");// 使用循環，次數其實就是數組的長度。for (int i = 0; i < 3; i++) {System.out.println(array[i]);}System.out.println("=================");for (int i = 0; i < array.length; i++) {System.out.println(array[i]);}
}

14、求數組中的最值

public static void main(String[] args) {int[] array = { 5, 15, 30, 20, 1000 };int max = array[0];     // 比武擂臺for (int i = 1; i < array.length; i++) {// 如果當前元素，比max更大，則換人if (array[i] > max) {max = array[i];}}// 誰最后誰最大System.out.println("最大值：" + max);
}

public static void main(String[] args) {int[] array = { 5, 15, 30, 20, 1000 };int min = array[0];     // 擂臺for (int i = 1; i < array.length; i++) {// 如果當前元素，比min更小，則換人if (array[i] < min) {min = array[i];}}// 誰最后誰最小System.out.println("最小值：" + min);
}

15、數組元素反轉

數組元素的反轉：
本來的樣子：[1,2,3,4]
之后的樣子：[4,3,2,1]

要求不能使用新數組，就用原來的唯一一個數組。

public static void main(String[] args) {int[] array = { 10, 20, 30, 40, 50 };// 遍歷打印數組本來的樣子for (int i = 0; i < array.length; i++) {System.out.println(array[i]);}System.out.println("==================");/*初始化語句：int min = 0, max = array.length - 1條件判斷：min < max步進表達式：min--, max--循環體：用第三個變量倒手*/for (int min = 0, max = array.length - 1; min < max; min++, max--) {int temp = array[min];array[min] = array[max];array[max] = temp;}// 再次打印遍歷輸出數組后的樣子for (int i = 0; i < array.length; i++) {System.out.println(array[i]);}}
}

16、傳遞地址（數組作為方法參數）

數組可以作為方法的參數。
當調用方法的時候，向方法的小括號進行傳參，傳遞進去的其實是數組的地址值。

public static void main(String[] args) {int[] array = { 10, 20, 30, 40, 50 };printArray(array);  // 傳遞進去的就是array當中保存的地址值
}/*
三要素：
返回值類型：只是進行打印而已，不需要進行計算，也沒有結果，用void
方法名稱：printArray
參數列表：必須給我數組，我才能打印其中的元素。int[] array*/
public static void printArray(int[] array) {for (int i = 0; i < array.length; i++) {System.out.println(array[i]);}
}

17、返回地址（數組作為方法返回值）

一個方法可以有0、1、多個參數；但是只有0或者1個返回值，不能有多個返回值。
如果希望一個方法當中產生了多個結果數據進行返回，怎么辦？
解決方案：使用一個數組作為返回值類型即可。

任何數據類型都能作為方法的參數類型，或者返回值類型。

數組作為方法的參數，傳遞進去的其實是數組的地址值。
數組作為方法的返回值，返回的其實也是數組的地址值。

public static void main(String[] args) {int[] result = calculate(10,20,30);System.out.println("總和：" + result[0]);System.out.println("平均值：" + result[1]);
}public  static int[] calculate(int a, int b, int c) {int sum = a + b + c;    // 總和int avg = sum / 3;      // 平均值// 兩個結果都希望進行返回int[] array = { sum, avg };return array;
}

DAY6

1、面向對象

面向過程：當需要實現一個功能的時候，每一個具體的步驟都要親力親為，詳細處理每一個細節
面向對象：當需要實現一個功能的時候，不關心具體的步驟，而是找一個已經具有該功能的人，來幫我做這事。

public static void main(String[] args) {int[] array = { 10, 20, 30, 40, 50 };// 要求打印格式為： [10, 20， 30， 40， 50]// 使用面向過程，每一個步驟細節都要親力親為。System.out.print("[");for (int i = 0; i < array.length; i++) {if (i == array.length - 1) {    // 如果是最后一個元素System.out.println(array[i] + "]");} else {    // 如果不是最后一個元素System.out.print(array[i] + ", ");}}System.out.println("===================");// 使用面向對象// 找一個JDK給我們提供好的Arrays類，// 其中有一個toString方法，直接就能把數組變成想要的格式的字符串System.out.println(Arrays.toString(array));
}

2、面向對象思想舉例

洗衣服

面向過程：脫下衣服–>找個盆–>倒洗衣液–>洗–>晾

面向對象：脫下衣服–>放入洗衣機–>晾

吃飯

面向過程：買菜–>洗菜–>炒菜–>吃–>刷碗

面向對象：餐館–>回家

3、類和對象的關系

類是對一類實物的描述，是抽象的，相當于設計圖紙

對象是一類實物的示例，是具體的，相當于實物東西

4、類的定義

定義一個類，用來模擬“學生”實物。其中就有兩個組成部分：

屬性（是什么）：
姓名
年齡
行為（能做什么）：
吃飯
睡覺
學習

對應到Java的類當中：

成員變量（屬性）：
String name; // 姓名
int age; // 年齡
成員方法（行為）：
public void eat() {} // 吃飯
public void sleep() {} // 睡覺
public void study() {} // 學習

注意事項：
1、成員變量是直接定義在類當中的，在方法外邊。
2、成員方法不要寫static關鍵字。

public class Student {// 成員變量String name;    // 姓名int age;        // 年齡// 成員方法public void eat() {System.out.println("吃飯");}public void sleep() {System.out.println("睡覺");}public void study() {System.out.println("學習");}}

5、對象的創建及使用

通常情況下，一個類并不能直接使用，需要根據類創建一個對象，才能使用，

1、導包：也就是指出需要使用的類，在什么位置。
import 包名稱.類名稱;
import com.memory.day06.dome01.Student;
對于和當前類屬于同一個包的情況，可以省略導包語句。

2、創建，格式：
類名稱對象名 = new 類名稱();
Student stu = new Studnet();

3、使用，分為兩種情況：
使用成員變量：對象名.成員變量名
使用成員方法：對象名.成員方法名（參數）
（也就是，想要誰，就用對象名點誰。）

注意事項：
如果成員變量沒有進行賦值，那么將會有一個默認值，規則和數組一樣。

public static void main(String[] args) {// 1、導包。// 我需要使用的Studnet類，和我自己Demo02Student位于同一個包下，所以省略導包語句// 2、創建，格式：// 類名稱 對象名 = new 類名稱();// 根據Studnet類，創建了一個名為stu的對象Student stu = new Student();// 3、使用其中的成員變量，格式：// 對象名.成員變量名System.out.println(stu.name);   // nullSystem.out.println(stu.age);    // 0System.out.println("===================");// 改變對象當中的成員變量數值內容// 將右側的字符串，賦值交給stu對象當中的name成員變量stu.name = "小明";stu.age = 18;System.out.println(stu.name);System.out.println(stu.age);System.out.println("===================");// 4、使用對象的成員方法，格式：// 對象名.成員方法名()stu.eat();stu.sleep();stu.study();
}

6、手機類練習

定義一個類，用來模擬“手機“事物。

屬性：品牌、價格、顏色
行為：打電話、發短信

對應到類當中：
成員變量（屬性）：
String brand; // 品牌
double price; // 價格
String color; // 顏色
成員方法（行為）：
public void call(String who) {} // 打電話
public void sendMessage() {} // 群發短信

public class Phone {// 成員變量String brand;   // 品牌double price;   // 價格String color;   // 顏色// 成員方法public void call(String who) {System.out.println("給" + who + "打電話");}public void sendMessage() {System.out.println("群發短信");}
}

public class Demo01PhoneOne {public static void main(String[] args) {// 根據Phone類，創建一個名稱One的對象// 格式：類名稱 對象名 = new 類名稱();Phone one = new Phone();System.out.println(one.brand);  // nullSystem.out.println(one.price);  // 0.0System.out.println(one.color);  // nullSystem.out.println("===============");one.brand = "蘋果";one.price = 8388.0;one.color = "黑色";System.out.println(one.brand);  // 蘋果System.out.println(one.price);  // 8388.0System.out.println(one.color);  // 黑色System.out.println("===============");one.call("喬布斯");     	  // 給喬布斯打電話one.sendMessage();			// 群發短信}
}

7、一個對象的內存圖

8、兩個對象使用同一個方法的內存圖

public class Demo02PhoneTwo {public static void main(String[] args) {Phone one = new Phone();System.out.println(one.brand);  // nullSystem.out.println(one.price);  // 0.0System.out.println(one.color);  // nullSystem.out.println("===============");one.brand = "蘋果";one.price = 8388.0;one.color = "黑色";System.out.println(one.brand);  // 蘋果System.out.println(one.price);  // 8388.0System.out.println(one.color);  // 黑色System.out.println("===============");one.call("喬布斯");        // 給喬布斯打電話one.sendMessage();             // 群發短信System.out.println("===============");Phone two = new Phone();System.out.println(two.brand);  // nullSystem.out.println(two.price);  // 0.0System.out.println(two.color);  // nullSystem.out.println("===============");two.brand = "三星";two.price = 5999.0;two.color = "藍色";System.out.println(two.brand);  // 三星System.out.println(two.price);  // 5999.0System.out.println(two.color);  // 藍色System.out.println("===============");two.call("三星");         // 給三星打電話two.sendMessage();             // 群發短信}
}

9、兩個引用指向同一個對象的內存圖

public class Demo03PhoneSame {public static void main(String[] args) {Phone one = new Phone();System.out.println(one.brand);  // nullSystem.out.println(one.price);  // 0.0System.out.println(one.color);  // nullSystem.out.println("===============");one.brand = "蘋果";one.price = 8388.0;one.color = "黑色";System.out.println(one.brand);  // 蘋果System.out.println(one.price);  // 8388.0System.out.println(one.color);  // 黑色System.out.println("===============");one.call("喬布斯");        // 給喬布斯打電話one.sendMessage();             // 群發短信System.out.println("===============");// 將one當中保存的對象地址賦值給twoPhone two = one;System.out.println(two.brand);  // 蘋果System.out.println(two.price);  // 8388.0System.out.println(two.color);  // 黑色System.out.println("===============");two.brand = "三星";two.price = 5999.0;two.color = "藍色";System.out.println(two.brand);  // 三星System.out.println(two.price);  // 5999.0System.out.println(two.color);  // 藍色System.out.println("===============");two.call("三星");         // 給三星打電話two.sendMessage();             // 群發短信}
}

10、使用對象類型作為方法的參數

public class Demo04PhoneParam {public static void main(String[] args) {Phone one = new Phone();one.brand = "蘋果";one.price = 8388.0;one.color = "土豪金";method(one);    // 傳遞進去的參數其實就是地址值}public static void method(Phone param) {System.out.println(param.brand);    // 蘋果System.out.println(param.price);    // 8388.0System.out.println(param.color);    // 土豪金}
}

11、使用對象類型作為方法的返回值

public class Demo05PhoneReturn {public static void main(String[] args) {Phone two = getPhone();System.out.println(two.brand);  // 蘋果System.out.println(two.price);  // 8388.0System.out.println(two.color);  // 玫瑰金}public static Phone getPhone() {Phone one = new Phone();one.brand = "蘋果";one.price = 8388.0;one.color = "玫瑰金";return one;}
}

12、局部變量和成員變量

1、定義的位置不一樣【重點】
局部變量：在方法的內部
成員變量：在方法的外部，直接卸載類當中

2、作用范圍不一樣【重點】
局部變量：只有方法當中才可以使用，出了方法就不能再用
成員變量：整個類全都可以通用

3、默認值不一樣【重點】
局部變量：沒有默認值，如果要想使用，必須手動進行賦值
成員變量：如果沒有賦值，會有默認值，規則和數組一樣

4、內存的位置不一樣（了解）
局部變量：位于棧內存
成員變量：位于堆內存

5、生命周期不一樣（了解）
局部變量：隨著方法進棧而誕生，隨著方法出棧而消失
成員變量，隨著對象創建而誕生，隨著對象被垃圾回收而消失

public class Demo01VariableDifference {String name;    // 成員變量public void methodA() {int num = 20;   // 局部變量System.out.println(num);System.out.println(name);}public void methodB(int param) {    // 方法的參數就是局部變量// 參數在方法調用的時候，必然會比賦值System.out.println(param);int age;    // 局部變量
//        System.out.println(age);    // 沒有賦值不能使用
//        System.out.println(num);    // 錯誤寫法，調用不到局部變量System.out.println(name);}}

13、面向對象三大特征之封裝性

面向對象三大特征：封裝、繼承、多態

封裝性在Java當中的體現：
1、方法就是一種封裝
2、關鍵字private也是一種封裝

封裝就是將一些細節信息隱藏起來，對于外界不可見。

public class Demo02Method {public static void main(String[] args) {int[] array = { 5, 15, 25, 20, 100 };int max =getMax(array);System.out.println("最大值：" + max);}// 給我一個數組，我換給你一個最大值public static int getMax(int[] array) {int max = array[0];for (int i = 0; i < array.length; i++) {if (array[i] > max) {max = array[i];}}return max;}
}

14、private關鍵字的作用及使用

問題描述：定義Person的年齡時，無法阻止不合理的數值被設置進來。
解決方案：用private關鍵字將需要保護的成員變量進行修飾。

一旦使用了private進行修飾，那么本類當中仍然可以隨意訪問。
但是！超出了本類范圍之外就不能直接訪問了。

間接訪問private成員變量，就定義一對Getter/Setter方法

必須叫setXxx或者是getXxx命名規則。
對于Getter來說，不能有參數，返回值類型和成員變量對應；
對于Setter來說，不能有返回值，參數類型和成員變量對應。

public class Person {String name;    // 姓名private int age;        // 年齡public void show() {System.out.println("我叫：" + name + ",年齡：" + age);}// 這個成員方法，專門用于向age設置數據public void setAge(int num) {if (num < 120 && num >= 0) {age = num;} else {System.out.println();}}// 這個成員方法，專門用于獲取age的數據public int getAge() {return age;}
}

public class Demo03Person {public static void main(String[] args) {Person person = new Person();person.show();person.name = "小明";
//        person.age = 18;    // 直接訪問private內容，錯誤！person.setAge(20);person.show();}
}

15、練習使用private關鍵字定義學生類（特殊boolean）

對于基本類型當中的boolean值，Getter方法一定要寫成isXxx的形式，而setXxx規則不變。

public class Student {private String name;    // 姓名private int age;        // 年齡private boolean male;   // 是否男人public void setMale(boolean b) {male = b;}public boolean isMale() {return male;}public String getName() {return name;}public void setName(String str) {name = str;}public int getAge() {return age;}public void setAge(int num) {age = num;}
}

public class Demo04Studnet {public static void main(String[] args) {Student stu = new Student();stu.setName("小明");stu.setAge(20);stu.setMale(true);System.out.println("姓名：" + stu.getName());System.out.println("年齡：" + stu.getAge());System.out.println("是不是男的：" + stu.isMale());}
}

16、this關鍵字的作用

當方法的局部變量和類的成員變量重名的時候，根據“就近原則”，優先使用局部變量。
如果需要訪問本類當中的成員變量，需要使用格式：
this.成員變量名

“通過誰調用的方法，誰就是this。”

public class Person {String name;    // 自己的名字// 參數name是對方的名字// 成員變量name是自己的名字public void sayHello(String name) {System.out.println(name + ",您好。我是" + this.name);System.out.println(this);}
}

public class Demo01Person {public static void main(String[] args) {Person person = new Person();// 設置我自己的名字person.name = "小明";person.sayHello("小紅");System.out.println(person);}
}

17、構造方法

構造方法是專門用來創建對象的方法，當我們通過關鍵字new來創建對象時，其實就是在調用構造方法。
格式：
public 類名稱(參數類型參數名稱) {
方法體
}

注意事項：
1、構造方法的名稱必須和所在的類名稱完全一樣，就連大小寫也要一樣
2、構造方法不要寫返回值類型，連void都不寫
3、構造方法不能return一個具體的返回值
4、如果沒有編寫任何構造方法，那么編譯器將會默認有一個構造方法，沒有參數、方法體什么事情都不做。
public Studnet() {}
5、一旦編寫了至少一個構造方法，那么編譯器將去掉默認的。
6、構造方法也是可以進行重載的。
重載：方法名稱相同，參數列表不同。

public class Student {private String name;private int age;public Student() {System.out.println("無參構造方法已執行");}public Student(String name, int age) {System.out.println("全參構造方法已執行");this.name = name;this.age = age;}// Getter  Setterpublic 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;}
}

public class Demo02Student {public static void main(String[] args) {Student stu1 = new Student();   // 無參構造Student stu2 = new Student("小明",20);    // 全參構造System.out.println("姓名：" + stu2.getName() + "，年齡：" + stu2.getAge());// 如果需要改變對象當中的成員變量數據內容，仍然還需要使用setXxx方法stu2.setAge(21);    // 改變年齡System.out.println("姓名：" + stu2.getName() + "，年齡：" + stu2.getAge());}
}

18、定義一個標準的類

一個準備的類通常要擁有下面四個組成部分：

1、所有的成員變量都要使用private關鍵字修飾
2、為每一個成員變量編寫一對Getter/Setter方法
3、編寫一個無參數構造方法
4、編寫一個全參數構造方法

這樣標準的類也叫做Java Bean

public class Student {private String name;    // 姓名private int age;        // 年齡public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}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;}
}

public class Demo01Student {public static void main(String[] args) {Student stu1 = new Student();stu1.setName("小明");stu1.setAge(20);System.out.println("姓名：" + stu1.getName() + "，年齡：" + stu1.getAge());System.out.println("================");Student stu2 = new Student("小紅",22);System.out.println("姓名：" + stu2.getName() + "，年齡：" + stu2.getAge());stu2.setAge(21);System.out.println("姓名：" + stu2.getName() + "，年齡：" + stu2.getAge());}
}

DAY7

1、API概述和使用步驟

1、打開幫助文檔

2、點擊顯示，找到索引，輸入想要找的

3、看包。java.lang下的類不用導包

4、看類的解釋和說明

5、學習構造方法

6、使用成員方法

2、Scanner類鍵盤輸入

Scanner類的功能：可以實現鍵盤輸入數據，到程序當中。

引用類型的一般使用步驟：

1、導包
import 包路徑.類名稱;
如果需要使用的目標類，和當前類位于同一個包下，則可以省略導包語句不寫。
只有java.lang包下的內容不需要導包，其中的包都需要import語句。

2、創建
類名稱對象名 = new 類名稱();

3、使用
對象名.成員方法名()

獲取鍵盤輸入的一個int數字：int num = sc.nextInt();
獲取鍵盤輸入的一個字符串：String str = sc.next();

public class Demo01Scanner {public static void main(String[] args) {// 2、創建// System.in代表從鍵盤進行輸入Scanner sc = new Scanner(System.in);// 3、獲取鍵盤輸入的int數字int num = sc.nextInt();System.out.println("輸入的數字是：" + num);// 4、獲取鍵盤輸入的字符串String str = sc.next();System.out.println("輸入的字符串是：" + str);}}

3、Scanner練習一鍵盤輸入兩個數字求和

題目：
鍵盤輸入兩個int數字，并且求出和值。

思路：
1、既然需要鍵盤輸入，那么使用Scanner
2、Scanner的三個步驟：導包、創建、使用
3、需要的是兩個數字，所以要調用兩次nextInt方法
4、得到了兩個數字，就需要加在一起。
5、將結果打印輸出。

public class Demo02ScannerSum {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("請輸入第一個數字：");int a = sc.nextInt();System.out.println("請輸入第二個數字：");int b = sc.nextInt();int result = a + b;System.out.println("結果是：" + result);}
}

4、Scanner練習二鍵盤輸入三個數字求最大值

題目：
鍵盤輸入三個int數字，然后求出其中的最大值。

思路：
1、既然時鍵盤輸入，肯定需要用到Scanner
2、Scanner三個步驟：導包、創建、使用nextInt()方法
3、既然是三個數字，那么調用三次nextInt()方法，得到三個int變量
4、無法同事判斷三個數字誰最大，應該轉換成為兩個步驟：
4.1 首先判斷前兩個當中誰最大，拿到前兩個的最大值
4.2 拿著前兩個中的最大值，再和第三個數字比較，得到三個數字當中的最大值
5、打印最終結構

public class Demo03ScannerMax {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("請輸入第一個數字：");int a = sc.nextInt();System.out.println("請輸入第二個數字：");int b = sc.nextInt();System.out.println("請輸入第三個數字：");int c = sc.nextInt();// 首先得到前倆個數字當中的最大值int temp = a > b ? a : b;int max = temp > c ? temp : c;System.out.println("最大值是：" + max);}
}

5、匿名對象的說明

創建對象的標準格式：
類名稱對象名 = new 類名稱();

匿名對象就是只有右邊的對象，沒有左邊的名字和賦值運算符。
new 類名稱();

注意事項：匿名對象只能使用唯一的一次，下次再用不得不再創建一個新對象。
使用建議：如果確定有一個對象只需要使用唯一的一次，就可以使用匿名對象。

public class Demo01Anonymous {public static void main(String[] args) {// 左邊的one就是對象的名字Person one = new Person();one.name = "小明";one.showName();     // 我叫小明System.out.println("==============");// 匿名對象new Person().name = "小紅";new Person().showName();    // 我叫null}
}

6、匿名對象作為方法的參數和返回值

public class Person {String name;public void showName() {System.out.println("我叫：" + name);}
}

public class Demo02Anonymous {public static void main(String[] args) {// 普通使用方式
//        Scanner sc = new Scanner(System.in);
//        int num = sc.nextInt();// 匿名對象的方式
//        int num = new Scanner(System.in).nextInt();
//        System.out.println("輸入的是：" + num);// 使用一般寫法傳入參數
//        Scanner sc = new Scanner(System.in);
//        methodParam(sc);// 使用匿名對象來進行傳參
//        methodParam(new Scanner(System.in));Scanner sc = methodResturn();int num = sc.nextInt();System.out.println("輸入的是：" + num);}public static void methodParam(Scanner sc) {int num = sc.nextInt();System.out.println("輸入的是:" + num);}public static Scanner methodResturn() {
//        Scanner sc = new Scanner(System.in);
//        return sc;return new Scanner(System.in);}
}

7、Random 隨機數

Random類用來生成隨機數字。使用起來也是三個步驟：

1、導包
import java.util.Random;

2、創建
Random r = new Random(); // 小括號當中留空即可

3、使用
獲取一個隨機的int數字（范圍是int所有范圍，有正負兩種）：int num = r.nextInt()
獲取一個隨機的int數字（參數代表了范圍，左閉又開區間）：int num = r.nextInt(3)
實際上代表的含義時：[0,3]，也就是0~2

public class Demo01Random {public static void main(String[] args) {Random r = new Random();int num = r.nextInt();System.out.println("隨機數：" + num);}}

8、Random生成指定范圍的隨機數

public class Demo02Random {public static void main(String[] args) {Random r = new Random();for (int i = 0; i < 100; i++) {int num = r.nextInt(10);    // 范圍實際上是0~9System.out.println(num);}}
}

9、Random練習一生成1-n之間的隨機數

題目要求：
根據int變量n的值，來獲取隨機數字，范圍是[1,n]，可以去到1也可以取到n，

思路：
1、定義一個int變量n，隨意賦值
2、要使用Random：三個步驟，導包、創建、使用
3、如果寫10，那么就是0-9，而且想要的是1-10，可以發現：整體+1即可。
4、打印隨機數字

public class Demo03Random {public static void main(String[] args) {int n = 5;Random r = new Random();for (int i = 0; i < 100; i++) {// 本來范圍時[0，n]，整體+1之后變成了[1，n+1]，也就是[1,n]int result = r.nextInt(n) + 1;System.out.println(result);}}
}

10、Random練習二猜數字小游戲

題目：
用代碼模擬猜數字的小游戲。

思路：
1、首先需要產生一個隨機數字，并且一旦產生不再變化。用Random的nextInt方法
2、需要鍵盤輸入，用Scanner
3、獲取鍵盤輸入的數字，用Scanner當中的nextInt方法
4、已經得到了兩個數字，判斷（if）一下：
如果大了，提示大，并且重試；
如果小了，提示小，并且重試；
如果猜中了，游戲結束。
5、重試就是再來一次，循環。

public class Demo04RandomGame {public static void main(String[] args) {Random r = new Random();int randomNum = r.nextInt(100) + 1; // [1,100]Scanner sc = new Scanner(System.in);while (true) {System.out.println("請輸入你猜測的數字：");int guessNum = sc.nextInt();    // 鍵盤輸入猜測的數字if (guessNum > randomNum) {System.out.println("猜大了，請重試！");} else if (guessNum < randomNum) {System.out.println("猜小了，請重試！");} else {System.out.println("恭喜你，猜中了！");break;  // 如果猜中，不再重試}}System.out.println("游戲結束");}
}

11、Random練習二猜數字小游戲（題目變形）

題目：
用代碼模擬猜數字的小游戲。

題目變形：
只允許猜十次

public class Demo05RandomGame {public static void main(String[] args) {Random r = new Random();int randomNum = r.nextInt(100) + 1; // [1,100]Scanner sc = new Scanner(System.in);int order = 10; // 猜測的次數for (int i = 0; i < order; i++) {System.out.println("請輸入你猜測的數字：");int guessNum = sc.nextInt();    // 鍵盤輸入猜測的數字if (guessNum == randomNum) {System.out.println("恭喜你，猜中了！");} else if (i == order-1){System.out.println("猜測次數已用完！");} else if (guessNum > randomNum) {System.out.println("猜大了，請重試！");} else {System.out.println("猜小了，請重試！");}}System.out.println("游戲結束");}
}

12、對象數組

題目：
定義一個數組，用來存儲3個Person對象。

數組有一個缺點：一旦創建程序運行期間長度不可以發生改變。

public class Person {private String name;private int age;public Person() {}public Person(String name, int age) {this.name = name;this.age = age;}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;}
}

public class Demo01Array {public static void main(String[] args) {// 首先創建一個長度為3的數組，里面用來存放Person類型的對象Person[] array = new Person[3];Person one = new Person("小明",18);Person two = new Person("小紅",20);Person three = new Person("小藍",22);// 將one當中的地址值賦值到數組的0號元素位置array[0] = one;array[1] = two;array[2] = three;System.out.println(array[0]);   // 地址值System.out.println(array[1]);   // 地址值System.out.println(array[2]);   // 地址值System.out.println(array[1].getName());   // 小紅}
}

13、ArrayList集合概述和基本使用

數組的長度不可以發生改變。
但是ArrayList集合的長度時可以隨意變化的。

對于ArrayList來說，有一個尖括號代表泛型。
泛型：也就是裝在集合當中的所有元素，全都是統一的什么類型。
注意：泛型只能時引用類型，不能是基本類型。

注意事項：
對于ArrayList集合來說，直接打印得到的不是地址值，而是內容。
如果內容是空，得到的是空的中括號：[]

public class Demo02ArrayList {public static void main(String[] args) {// 創建了一個ArrayList集合，集合的名稱時list，里面裝的全都是String字符串類型的數據// 備注：從JDK 1.7+開始，右側的尖括號內部可以不寫內容，但是<>本身還是要寫的（兩邊相同，前面尖括號里面是什么，后面就是什么）ArrayList<String> list = new ArrayList<>();System.out.println(list);  // []// 向集合當中添加一些數據，需要用到add方法。list.add("小明");System.out.println(list);   // [小明]list.add("小紅");list.add("小蘭");System.out.println(list);   // [小明, 小紅, 小蘭]//        list.add(100);  // 錯誤寫法！因為創建的時候尖括號泛型已經說了是字符串，添加進去的元素就必須都是字符串才行}
}

14、ArrayList集合的常用方法

ArrayList當中的常用方法有：

public boolean add(E e)：向集合當中添加元素，參數的類型和泛型一致。
注意：對于ArrayList集合來說，add添加動作一定是成功的，所以返回值可用可不用。
但是對于其他集合來說，add添加動作不一定成功。

public E get(int index)：從集合當中獲取元素，參數時索引編號，返回值就是對應位置的元素。

public E remove(int index)：從集合當中刪除元素，參數時索引編號，返回值就是刪除掉的元素。

public int size()：獲取集合的尺寸長度，返回值就是集合中包含的元素個數。

public class Demo03ArrayListMethod {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();System.out.println(list);// 向集合中添加元素：addboolean success = list.add("小明");System.out.println(list);   // [小明]System.out.println("添加的動作是否成功：" + success); // 添加的動作是否成功：truelist.add("小紅");list.add("小蘭");list.add("ABC");list.add("ABB");System.out.println(list);   // [小明, 小紅, 小蘭, ABC, ABB]// 從集合中獲取元素：get、索引值從0開始String name = list.get(1);System.out.println("第1號索引位置：" + name);  // 第1號索引位置：小紅// 從集合中刪除元素：remove。索引值從0開始。String whoRemoved = list.remove(2);System.out.println("被刪除的人時：" + whoRemoved); // 被刪除的人時：小蘭System.out.println(list);   // [小明, 小紅, ABC, ABB]// 獲取集合的長度尺寸，也就是其中元素的個數int size = list.size();System.out.println("集合的長度時：" + size);   // 集合的長度時：4}
}

15、ArrayList集合的遍歷

public class Demo04ArrayListEach {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("ABC");list.add("ABB");list.add("AAB");// 遍歷集合for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}}
}

16、ArrayList集合存儲基本數據類型

如果希望向集合ArrayList當中存儲基本類型數據，必須使用基本類型對應的“包裝類”

基本類型包裝類（引用類型，包裝類都位于java.lang包下）
byte Byte
short Short
int Integer 【特殊】
long Long
float Float
double Double
char Character 【特殊】
boolean Boolean

從JDK 1.5+開始，支持自動裝箱、自動拆箱。

自動裝箱：基本類型 --> 包裝類型
自動拆箱：包裝類型 --> 基本類型

public class Demo05ArrayListBasic {public static void main(String[] args) {ArrayList<String> listA = new ArrayList<>();// 錯誤寫法！泛型只能是引用類型，不能是基本類型
//        ArrayList<int> listB =new ArrayList<int>();ArrayList<Integer> listC = new ArrayList<>();listC.add(100);listC.add(200);System.out.println(listC);  // [100, 200]int num = listC.get(1);System.out.println("第1號元素是：" + num);}
}

17、ArrayList練習一存儲隨機數字

題目：
生成6個1~33之間的隨機整數，添加到集合，并遍歷集合。

思路：
1、需要存儲6個數字，創建一個集合，
2、產生隨機數，需要用到Random
3、用循環6次，來產生6個隨機數字：for循環
4、循環內調用r.nextInt(int n)，參數是33,0_{32，整體+1才是1}33
5、把數字添加到集合中：add
6、遍歷集合：for、size、get

public class Demo01ArrayListRandom {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();Random r = new Random();for (int i = 0; i < 6; i++) {int num = r.nextInt(33) + 1;list.add(num);}// 遍歷集合for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));}}
}

18、ArrayList練習二存儲自定義對象

題目：
自定義4個學生對象，添加到集合，并遍歷。

思路：
1、自定義Studnet學生類，四個部分。
2、創建一個集合，用來存儲學生對象。泛型：
3、根據類，創建4個學生對象
4、將4個學生對象添加到集合中：add
5、遍歷集合：for、size、get

public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name = name;this.age = age;}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;}
}

public class Demo02ArrayListStudent {public static void main(String[] args) {ArrayList<Student> list = new ArrayList<>();Student one = new Student("學生A",20);Student two = new Student("學生B",22);Student three = new Student("學生C",18);Student four = new Student("學生D",30);list.add(one);list.add(two);list.add(three);list.add(four);// 遍歷集合for (int i = 0; i < list.size(); i++) {Student stu = list.get(i);System.out.println("姓名：" + stu.getName() + ",年齡：" + stu.getAge());}}
}

19、ArrayList練習三按指定格式遍歷集合字符串

題目：
定義以指定格式打印集合的方法（ArrayList類型作為參數），使用{}擴起集合，使用@分隔每個元素。
格式參照 {元素@元素@元素}

System.out.println(list); [10, 20, 30]
printArrayList(list); {10@20@30}

public class Demo03ArrayListPrint {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("ABC");list.add("ABB");list.add("AAB");System.out.println(list);printArrayList(list);}/*定義方法的三要素：返回值類型：只是進行打印而已，沒有運算，沒有結果；所以用void方法名稱：printArrayList參數列表：ArrayList*/public static void printArrayList(ArrayList<String> list) {// {10@20@30}System.out.print("{");for (int i = 0; i < list.size(); i++) {String name = list.get(i);if (i == list.size() - 1) {System.out.println(name + "}");} else {System.out.print(name + "@");}}}
}

20、ArrayList練習四篩選集合中的隨機數

題目：
用一個大集合存入20個隨機數字，然后篩選其中的偶數元素，放到小集合當中。
要求使用自定義的方法來實現篩選。

分析：
1、需要創建一個集合，用來存儲int數字：
2、隨機數字就用Random nextInt
3、循環20次，把隨機數字放入大集合：for循環、add方法
4、定義一個方法，用來進行篩選。
篩選：根據大集合，篩選符合要求的元素，得到小集合。
三要素
返回值類型：ArrayList小集合（里面元素個數不確定）
方法名稱：getSmallList
參數列表：ArrayList大集合（裝著20個隨機數字）
5、判斷（if）是偶數：num % 2 == 0
6、如果是偶數，就放到小集合當中，否則不放。

public class Demo04ArrayListReturn {public static void main(String[] args) {ArrayList<Integer> bigList = new ArrayList<>();Random r = new Random();for (int i = 0; i < 20; i++) {int num = r.nextInt(100) + 1;   // 1~100bigList.add(num);}ArrayList<Integer> smallList = getSmallList(bigList);System.out.println("偶數共有：" + smallList.size());for (int i = 0; i < smallList.size(); i++) {System.out.println(smallList.get(i));}}// 這個方法，接收大集合參數，返回小集合結果public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) {// 創建一個小集合，用來裝偶數結果ArrayList<Integer> smallList = new ArrayList<>();for (int i = 0; i < bigList.size(); i++) {int num = bigList.get(i);if (num % 2 == 0) {smallList.add(num);}}return smallList;}
}

DAY8

1、字符串概述和特點

java.long.String類代表字符串。
API當中說：Java程序中的所有字符串字面值（如“abc”）都作為此類的實例實現。
其實就是說：程序當中所有的雙引號字符串，都是String類的對象。（就算沒有new，就照樣是。）

字符串的特點：
1、字符串的內容用不可變。【重點】
2、正是因為字符串不可改變，所以字符串時可以共享使用的。
3、字符串效果上相當于char[]字符數組，但是底層原理byte[]字節數組。

2、字符串的構造方法和直接創建創建字符串的常見3+1種方式。

三種構造方法：
public String()：創建一個空白字符串，不含有任何內容。
public String(char[] array)：根據字符數組的內容，來創建對應的字符串。
public String(byte[] array)：根據字節數組的內容，來創建對應的字符串。
一種直接創建：
String str = “Hello”; // 右邊直接用雙引號

注意：直接寫上雙引號，就是字符串對象。

public class Demo01String {public static void main(String[] args) {// 使用空參構造String str1 = new String();     // 小括號留空，說明字符串什么內容都沒有   。System.out.println("第一個字符串：" + str1);// 根據字符數組創建字符串char[] charArray = { 'A', 'B', 'C'};String str2 = new String(charArray);System.out.println("第二個字符串：" + str2);// 根據字節數組創建字符串byte[] byteArray = { 97, 98, 99};String str3 = new String(byteArray);System.out.println("第三個字符串：" + str3);// 直接創建String str4 = "Hello";System.out.println("第四個字符串：" + str4);}
}

3、字符串的常量池

字符串常量池：程序當中直接寫上的雙引號字符串，就在字符串常量池中。

對于基本類型來說，==是進行數值的比較。
對于引用類型來說，==是進行地址值的比較。

public class Demo02StringPool {public static void main(String[] args) {String str1 = "abc";String str2 = "abc";char[] charArray = {'a', 'b', 'c'};String str3 = new String(charArray);System.out.println(str1 == str2);   // trueSystem.out.println(str1 == str3);   // falseSystem.out.println(str2 == str3);   // false}
}

4、字符串的比較相關方法

==是進行對象的地址值比較，如果確實需要字符串的內容比較，可以使用兩個方法：

public boolean equals(Object obj)：參數可以是任何對象，只有參數是一個字符串并且內容相同的才會給true；否則返回false。
注意事項：
1、任何對象都能用Object進行接收。
2、equals方法具有對稱性，也就是a.equals(b)和b.equals(a)效果一樣。
3、如果比較雙方一個常量一個變量，推薦把常量字符串寫在前面。
推薦：“abc”.equals(str) 不推薦：str.equals(“abc”)

public boolean equalsIgnoreCase(String str)：忽略大小寫，進行內容比較。

public class Demo01StringEquals {public static void main(String[] args) {String str1 = "Hello";String str2 = "Hello";char[] charArray = { 'H', 'e', 'l', 'l', 'o'};String str3 = new String(charArray);System.out.println(str1.equals(str2));  // trueSystem.out.println(str2.equals(str3));  // trueSystem.out.println(str3.equals("Hello"));   // trueSystem.out.println("Hello".equals(str1));   // trueString str4 = "hello";System.out.println(str1.equals(str4));  // falseSystem.out.println("==================");String str5 = null;System.out.println("abc".equals(str5)); // 推薦:false
//        System.out.println(str5.equals("abc")); // 不推薦:報錯，空指針異常NullPointerExceptionSystem.out.println("==================");String strA = "Java";String strB = "java";System.out.println(strA.equals(strB));  // false，嚴格區分大小寫System.out.println(strA.equalsIgnoreCase(strB));    // true，忽略大小寫}
}

5、字符串的獲取相關方法

public int length()：獲取字符串當中含有的字符個數，拿到字符串長度。
public String concat(String str)：將當前字符串和參數字符串拼接成為返回值新的字符串。
public char charAt(int index)：獲取指定索引位置的單個字符。（索引從0開始）
public int indexOf(String str)：查找參數字符串在本字符串當中首次出現的索引位置，如果沒有返回-1值。

public class Demo02StringGet {public static void main(String[] args) {// 獲取字符串的長度int length = "asghjklxxcbnrtyui".length();System.out.println("字符串的長度是：" + length);// 拼接字符串String str1 = "Hello";String str2 = "World";String str3 = str1.concat(str2);System.out.println(str1);   // Hello，原封不動System.out.println(str2);   // World，原封不動System.out.println(str3);   // HelloWorld，新的字符串System.out.println("==================");// 獲取指定索引位置的單個字符char ch = "Hello".charAt(1);System.out.println("在1號索引位置的字符是" + ch);System.out.println("==================");// 查找參數字符串在本來字符串當中出現的第一次索引位置// 如果根本沒有，返回-1值String original = "HelloWorldHelloWorldHelloWorld";int index = original.indexOf("llo");System.out.println("第一次索引值是：" + index); // 2System.out.println("HelloWorld".indexOf("abc"));    // -1}
}

6、字符串的截取方法

public String substring(int index)：j截取從參數位置一直到字符串末尾，返回新字符串。
public String substring(int begin, int end)：截取從begin開始，一直到end結束，中間的字符串。
注意：[begin, end]，包含左邊，不包含右邊。

public class Demo03Substring {public static void main(String[] args) {String str1 = "HelloWorld";String str2 = str1.substring(5);System.out.println(str1);   // HelloWorld，原封不動System.out.println(str2);   // World，新字符串System.out.println("===================");String str3 = str1.substring(4,7);System.out.println(str3);System.out.println("===================");// 下面這種寫法，字符串的內容任然是沒有改變的// 下面有兩個字符串："Hello","Java"// strA當中保存的是地址值。// 本來地址值是Hello的0x666// 后來地址值變成了Java的0x999String strA = "Hello";System.out.println(strA);   // HellostrA = "Java";System.out.println(strA);   // Java}
}

7、字符串的轉換相關方法

public char[] toCharArray()：將當前字符串拆分成為字符數組作為返回值。
public byte[] getBytes()：獲得當前字符串底層的字節數組。
public String replace(CharSequence oldString, CharSequence newString)
將所有出現的老字符串替換成為新的字符串，返回替換之后的結果新字符串。
注意：CharSequence意思就是說可以接受字符串類型。

public class Demo04StringConvert {public static void main(String[] args) {// 轉換圍城字符數組char[] chars = "Hello".toCharArray();System.out.println(chars[0]);   // HSystem.out.println(chars.length);   // 5System.out.println("===============");// 轉換成為字節數組byte[] bytes = "abc".getBytes();for (int i = 0; i < bytes.length; i++) {System.out.println(bytes[i]);}System.out.println("===============");// 字符串的內容替換String str1 = "How do you do?";String str2 = str1.replace("o", "*");System.out.println(str1);   // How do you do?System.out.println(str2);   // H*w d* y*u d*?System.out.println("===============");String lang1 = "會不會玩啊！草泥馬！";String lang2 = lang1.replace("草泥馬", "***");System.out.println(lang2);  // 會不會玩啊！***！}
}

8、字符串的分割方法

public String[] split(String regex)：按照參數的規則，將字符串切分成為若干部分。

注意事項：
split方法的參數其實是一個正則表達式，
如果按照英文句點“.”進行切分，必須寫“\.”（兩個反斜杠）

public class Demo05StringSplit {public static void main(String[] args) {String str1 = "aaa,bbb,ccc";String[] array1 = str1.split(",");for (int i = 0; i < array1.length; i++) {System.out.println(array1[i]);}System.out.println("=================");String str2 = "aaa bbb ccc";String[] array2 = str2.split(" ");for (int i = 0; i < array2.length; i++) {System.out.println(array2[i]);}System.out.println("=================");String str3 = "XXX.YYY.ZZZ";String[] array3 = str3.split(".");  // "."要改成"\\."才能正確切分System.out.println(array3.length);  // 0for (int i = 0; i < array3.length; i++) {System.out.println(array3[i]);}}
}

9、練習一：按指定格式拼接字符串

題目：
定義一個方法，把數組{1,2,3}按照指定格式拼接成一個字符串。格式參照如下：[world1#world2#world3]。

分析：
1、首先準備一個int[]數組，內容是：1、2、3
2、定義一個方法，用來將數組變成字符串
三要素
返回值類型：String
方法名稱：fromArrayToString
參數列表：int[]
3、格式：[world1#world2#world3]
用到：for循環、字符串拼接、每個數組元素之前都有一個word字樣、分隔使用的是#、區分一下是不是最后一個
4、調用方法，得到返回值，并打印結果字符串

public class Demo06StringPractise {public static void main(String[] args) {int[] array = {1, 2, 3};String result = fromArrayToString(array);System.out.println(result);}public static String fromArrayToString(int[] array) {String str = "[";for (int i = 0; i < array.length; i++) {if (i == array.length - 1) {str += "Word" + array[i] + "]";} else {str += "Word" + array[i] + "#";}}return str;}
}

10、練習二：統計輸入的字符串中各種字符的個數

題目：
鍵盤輸入一個字符串，并且統計其中各種字符出現的次數。
種類有：大寫字母、小寫字母、數字、其他

思路：
1、既然用來鍵盤輸入，Scanner
2、鍵盤輸入的是字符串，那么：String str = sc.next();
3、定義四個變量，分別代表四種字符各自的出現次數。
4、需要對字符串一個字、一個字檢查，String–>char[],方法就是toCharArray()
5、遍歷char[]字符數組，對當前字符的種類進行判斷，并且用四個變量進行++動作。
6、打印輸出四個變量，分別代表四種字符出現次數。

public class Demo07StringCount {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("請輸入一個字符串：");String input = sc.next();   // 獲取鍵盤輸入的一個爭風吃醋int countUpper = 0; // 大寫字母int countLower = 0; // 小寫字母int countNumber = 0;// 數字int countOther = 0; // 其他字符char[] charArray =input.toCharArray();for (int i = 0; i < charArray.length; i++) {char ch = charArray[i]; // 當前單個字符if ('A' <= ch && ch <= 'Z') {countUpper++;} else if ('a' <= ch && ch <= 'z') {countLower++;} else if ('0' <= ch && ch <= '9') {countNumber++;} else {countOther++;}}System.out.println("大寫字母有：" + countUpper + "個");System.out.println("小寫字母有：" + countLower + "個");System.out.println("數字有：" + countNumber + "個");System.out.println("其他字符有：" + countOther + "個");}
}

11、靜態static關鍵字概述

12、靜態static關鍵字修飾成員變量

如果一個成員變量使用了static關鍵字，那么這個變量不再屬于對象自己，而是屬于所在的類，多個對象共享同一份數據。

public class Student {private int id;         // 學號private String name;    // 姓名private int age;        // 年齡static String room;     // 所在教室private static int idCounter = 0;   // 學號計數器，每當new了一個新對象，計數器++public Student() {this.id = ++idCounter;}public Student(String name, int age) {this.name = name;this.age = age;this.id = ++idCounter;}public int getId() {return id;}public void setId(int id) {this.id = id;}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;}
}

public class Demo01StaticField {public static void main(String[] args) {Student one = new Student("小明",20);one.room = "101教室";System.out.println("學號：" + one.getId() + "，姓名：" + one.getName() + "，年齡：" + one.getAge() + "，所在教室：" + one.room);Student two = new Student("小紅",18);System.out.println("學號：" + two.getId() + "，姓名：" + two.getName() + "，年齡：" + two.getAge() + "，所在教室：" + one.room);}
}

13、靜態static關鍵字修飾成員方法

一旦使用static修飾成員方法，那么這就成為了靜態方法。靜態方法不屬于對象，而是屬于類的。

如果沒有static關鍵字，那么必須首先創建對象，然后通過對象才能使用它。
如果有了static關鍵字，那么不需要創建對象，直接就能通過；類名稱來使用它。

無論是成員變量，還是成員方法。如果有了static，都推薦使用類名稱進行調用。
靜態變量：類名稱.靜態變量
靜態方法：類名稱.靜態方法()

注意事項：
1、靜態只能直接訪問靜態，不能直接訪問非靜態(最好記：靜態不能直接訪問非靜態)
原因：因為在內存當中是先有的靜態內容，后有的非靜態內容
“先人不知道后人，但是后人知道先人”
2、靜態方法當中不能用this
原因：this代表當前對象，通過誰調用的方法，誰就是當前對象。

public class MyClass {int num;    // 成員變量static int numStatic;   // 靜態變量// 成員方法public void method() {System.out.println("這是一個成員方法。");// 成員方法可以訪問成員變量System.out.println(num);// 成員方法可以訪問靜態變量System.out.println(numStatic);}// 靜態方法public static void methodStatic() {System.out.println("這是一個靜態方法。");// 靜態方法可以訪問靜態變量System.out.println(numStatic);// 靜態不能直接訪問非靜態【重點】
//        System.out.println(num);    // 錯誤寫法！// 靜態方法中不能使用this關鍵字
//        System.out.println(this);   // 錯誤寫法！}
}

public class Demo02StaticMethod {public static void main(String[] args) {MyClass obj = new MyClass();    // 首先創建對象// 然后才能使用沒有static關鍵字的內容obj.method();// 對于靜態方法來說，可以通過對象名進行調用，也可以直接通過類名稱來調用。obj.methodStatic();     // 正確，不推薦，會誤以為這是成員方法（這種寫法會編譯之后也會被javac翻譯成為“類名稱.靜態方法”）MyClass.methodStatic(); // 正確，推薦，為了明確區分，使用“類名稱.靜態方法”// 對于本來當中的靜態方法，可以省略名稱myMethod();Demo02StaticMethod.myMethod();  // 完全等效}public static void myMethod() {System.out.println("自己的方法！");}
}

14、靜態static的內存圖

public class Demo03StaticStudent {public static void main(String[] args) {// 首先設置一個教室，這是靜態的東西，應該通過類名稱進行調用Student.room = "101教室";Student one = new Student("小明",20);System.out.println("one的姓名：" + one.getName());System.out.println("one的年齡：" + one.getAge());System.out.println("one的教室：" + Student.room);Student two = new Student("小紅",18);System.out.println("two的姓名：" + two.getName());System.out.println("two的年齡：" + two.getAge());System.out.println("two的教室：" + Student.room);}
}

15、靜態代碼塊

靜態代碼塊的格式是：

public class 類名稱 {
static {
// 靜態代碼塊的內容
}
}

特點：當第一次用到本類時，靜態代碼塊執行唯一的一次。
靜態內容總是優先于非靜態，所以靜態代碼塊比構造方法先執行。

靜態代碼塊的典型用途：
用來一次性地對靜態成員變量進行賦值。

public class Person {static {System.out.println("靜態代碼塊執行！");}public Person() {System.out.println("構造方法執行！");}
}

public class Demo04Static {public static void main(String[] args) {Person one = new Person();Person two = new Person();}}

16、數組工具類Arrays

java,util.Arrays是一個與數組相關的工具類，里面提供了大量靜態方法，用來實現數組常見的操作。

public static String toString(數組)：將參數數組變成字符串（按照默認格式：[元素1，元素2，元素3…]）
public static void sort(數組)：按照默認升序（從小到大）對數組的元素進行排序。

注意：
1、如果是數值，sort默認按照升序從小到大
2、如果是字符串，sort默認按照字母升序
3、如果是自定義的類型，那么這個自定義的類需要有Comparable或者Comparator接口的支持。

public class Demo01Arrays {public static void main(String[] args) {int[] intArrays = {10, 20, 30};// 將int[]數組按照默認格式變成字符串String inStr = Arrays.toString(intArrays);System.out.println(inStr);  // [10, 20, 30]int[] array1 = {2, 1, 3, 10, 6};Arrays.sort(array1);System.out.println(Arrays.toString(array1));    // [1, 2, 3, 6, 10]String[] array2 = {"bbb", "aaa", "ccc"};Arrays.sort(array2);System.out.println(Arrays.toString(array2));    // [aaa, bbb, ccc]}
}

17、Arrays練習：字符串倒序排列

題目：
請使用Arrays相關API，將一個隨機字符串中的所有字符升序排列，并倒序打印。

public class Demo02ArraysPractise {public static void main(String[] args) {String str = "xcvbn4thj7ydfg897tyugDFGUT";// 如何進行升序排列：sort// 必須是一個數組，才能用Arrays.sout方法// String --> 數組，用toCharArraychar[] chars = str.toCharArray();Arrays.sort(chars);     // 對字符數組進行升序排列// 需要倒序遍歷for (int i = chars.length - 1; i >= 0; i--) {System.out.println(chars[i]);}}
}

18、數學工具類Math

java.util.Math類是數學相關的工具類，里面提供了大量的靜態方法，完成與數學運算相關的操作。

public static double abs(double num)：獲取絕對值。
public static double ceil(double num)：向上取整。
public static double floor(double num)：向下取整。
public static long round(double num)：四舍五入

Math.PI代表近似的圓周率常量（double）

public class Demo03Math {public static void main(String[] args) {// 獲取絕對值System.out.println(Math.abs(3.14)); // 3.14System.out.println(Math.abs(0));    // 0System.out.println(Math.abs(-2.5)); // 2.5System.out.println("====================");// 向上取整System.out.println(Math.ceil(3.9)); // 4.0System.out.println(Math.ceil(3.1)); // 4.0System.out.println(Math.ceil(3.0)); // 3.0System.out.println(Math.ceil(3.0)); // 3.0System.out.println("====================");// 向下取整，抹零System.out.println(Math.floor(30.1));   // 30.0System.out.println(Math.floor(30.9));   // 30.0System.out.println(Math.floor(31.0));   // 31.0System.out.println("====================");// 四舍五入System.out.println(Math.round(20.4));   // 20System.out.println(Math.round(10.5));   // 11}}

19、Math練習：小學數學真題

題目：
計算在-10.8到5.9之間，絕對值大于6或者小于2.1的整數有多少個？

分析：
1、已經確定了范圍，for循環
2、起點位置-10.8應該轉換成-10，兩種方法：
2.1 可以使用Math.ceil方法，向上（向正方向）取整
2.2 強轉成為int，自動舍棄所有小數位
3、每一個數字都是整數，所以步進表達式應該是num++，這樣每次都是+1的。
4、如何拿到絕對值：Math.abs方法。
5、一旦發現了一個數字，需要讓計數器++進行統計。

注意：如果使用Math.ceil方法，-10.8可以變成-10.0。注意double也是可以進行++的。

public class Demo04MathPractise {public static void main(String[] args) {int count = 0;  // 符合要求的數量double min = -10.8;double max = 5.9;// 方法一  強轉成為int，自動舍棄所有小數位// 這樣處理，變量i就是區間之內所有的整數
//        for (int i = (int) min; i < max; i++) {
//            int abs = Math.abs(i);  // 絕對值
//            if (abs > 6 || abs < 2.1) {
//                System.out.print(i + "，");
//                count++;
//            }
//        }// 方法二 可以使用Math.ceil方法，向上（向正方向）取整for (double i = Math.ceil(min); i < max; i++) {double abs = Math.abs(i);  // 絕對值if (abs > 6 || abs < 2.1) {System.out.print(i + "，");count++;}}System.out.println("總共有：" + count); // 9}
}

DAY9

1、繼承的概述

2、繼承的格式

在繼承的關系中，“子類就是一個父類”。也就是說，子類可以被當做父類看待。
例如父類是員工，子類是講師，那么“講師就是一個員工”。關系：is-a。

定義父類的格式：（一個普通的類定義）
public class 父類名稱 {
// …
}

定義子類的格式：
public class 子類名稱 extend 父類名稱 {
// …
}

// 定義一個父類：員工
public class Employee {public void method() {System.out.println("方法執行！");}
}

// 定義一個員工的子類：講師
public class Teacher extends Employee {
}

// 定義員工的另一個子類：助教
public class Assistant extends Employee {
}

public class Demo01Extends {public static void main(String[] args) {// 創建一個子類對象Teacher teacher = new Teacher();// Teacher類當中雖然什么都沒寫，但是會繼承來自父類的method方法。teacher.method();// 創建另一個子類助教的對象Assistant assistant = new Assistant();assistant.method();}
}

3、繼承中成員變量的訪問特點

在父子類的繼承關系當中，如果成員變量重名，則創建子類對象時，訪問有兩種方式：

直接通過子類對象訪問成員變量：
等號左邊是睡，就優先用誰，沒有則向上找。
間接通過成員方法訪問成員變量：
該方法屬于誰，就優先用誰，沒有則向上找。

public class Fu {int numFu = 10;int num = 100;public void methodFu() {// 使用的是本類當中的num，不會向下找子類的System.out.println(num);}
}

public class Zi extends Fu {int numZi = 20;int num = 200;public void methodZi() {// y因為本類當中有num，所以這里用的是本類的numSystem.out.println(num);}
}

public class Demo01ExtendsField {public static void main(String[] args) {Fu fu = new Fu();   // 創建父類對象System.out.println(fu.numFu);   // 只能使用父類的東西，沒有任何子類內容System.out.println("=============");Zi zi = new Zi();System.out.println(zi.numFu);   // 10System.out.println(zi.numZi);   // 20System.out.println("=============");// 等號左邊是誰，就優先用誰System.out.println(zi.num); // 優先子類，200System.out.println("=============");// 這個方法是子類的，優先用子類的，沒有再向上找zi.methodZi();  // 200// 這個方法是在父類當中定義的zi.methodFu();  // 100}
}

4、區分子類方法中重名的三種變量

局部變量：直接寫成員變量名
本類的成員變量： this.成員變量名
父類的成員變狼： super.成員變量名

public class Fu {int num = 10;
}

public class Zi extends Fu {int num = 20;public void method() {int num = 30;System.out.println(num);    // 30，局部變量System.out.println(this.num);   // 20，本類的成員變量System.out.println(super.num);  // 10，父類的成員變量}
}

public class Demo01ExtendsField {public static void main(String[] args) {Zi zi = new Zi();zi.method();}
}

5、繼承中成員方法的訪問特點

在父子類的繼承關系當中，創建子類對象，訪問成員方法的規則：
創建的對象是誰就優先用誰，如果沒有則向上找。

注意事項：
無論是成員方法還是成員變量，如果沒有都是向上找父類，絕對不會向下找子類的。

public class Fu {public void methodFu() {System.out.println("父類方法執行！");}
}

public class Zi extends Fu {public void methodZi() {System.out.println("子類方法執行！");}
}

public class Demo01ExtendsMethod {public static void main(String[] args) {Zi zi = new Zi();zi.methodZi();zi.methodFu();// 創建的是new子類對象，所以優先用子類方法zi.method();}
}

6、繼承中方法的覆蓋重寫概念與特點

重寫（Override）
概念：在繼承關系當中，方法的名稱一樣，參數列表也一樣。

重寫（Override）：方法的名稱一樣，參數列表也一樣。覆蓋、覆寫【覆蓋重寫】
重載（Overload）：方法的名稱一樣，參數列表不一樣

方法的覆蓋重寫特點：創建的是子類對象，則優先用子類方法。

7、繼承中方法的覆蓋重寫注意事項

方法覆蓋重寫的注意事項：

1、必須保證父子類之間方法的名稱相同，參數列表也相同。
@Override：寫在方法前面，用來檢測是不是有效的正確覆蓋重寫。
這個注解就算不寫，只要滿足要求，也是正確的方法覆蓋重寫。

2、子類方法的返回值必須小于等于父類方法的返回值范圍。
小拓展提示：java.lang.Object類是所有類的公共最高父類（祖宗類：塔尖人物），java.lang.String就是Object的子類。

3、子類方法的權限必須大于等于父類方法的權限修飾符。
小拓展提示：public > protected > (default) > private
注意：(default)不是關鍵字default，而是什么都不寫，留空。

8、繼承中方法的覆蓋重寫應用場景

// 本來的老款手機
public class Phone {public void call() {System.out.println("打電話");}public void send() {System.out.println("發短信");}public void show() {System.out.println("顯示號碼");}
}

// 定義一個新手機，使用老手機作為父類
public class NewPhone extends Phone {@Overridepublic void show() {super.show();   // 把父類的show方法拿過來重復利用// 自己子類再來添加更多內容System.out.println("顯示姓名");System.out.println("顯示頭像");}
}

public class Demo01Phone {public static void main(String[] args) {Phone phone = new Phone();phone.call();phone.send();phone.show();System.out.println("============");NewPhone newPhone = new NewPhone();newPhone.call();newPhone.send();newPhone.show();}
}

9、繼承中構造方法的訪問特點

繼承關系中，父子類構造方法的訪問特點：

1、子類構造方法當中有一個默認隱含的"super()"調用，所以一定是先調用的父類構造，后執行的子類構造。
2、子類構造可以通過super關鍵字來調用父類重載構造。
3、super的父類構造調用，必須是子類構造方法的第一個語句。不能一個子類構造調用多次super構造。
總結：
子類必須調用父類構造方法，不寫則贈送super()；寫了則用寫的指定的super調用，super只能有一個，還必須是第一個。

public class Fu {public Fu() {System.out.println("父類無參構造");}public Fu(int num) {System.out.println("父類有參構造！");}
}

public class Zi extends Fu {public Zi() {super();    // 在調用父類無參構造方法
//        super(10);  // 在調用父類重載的構造方法System.out.println("子類構造方法！");}public void method() {
//        super();    // 錯誤寫法！只有子類構造方法，才能調用父類構造方法。}
}

public class Demo01Constructor {public static void main(String[] args) {Zi zi = new Zi();}
}

10、super關鍵字的三種用法

super關鍵字的用法有三種：
1、在子類的成員方法中，訪問父類的成員變量。
2、在子類的成員方法中，訪問父類的成員方法。
3、在子類的構造方法中，訪問父類的構造方法。

public class Fu {int num = 10;public void method() {System.out.println("父類方法！");}
}

public class Zi extends Fu {int num = 20;public Zi() {       // 用法三：訪問父類的構造方法super();    // 默認就有，不寫也可以}public void methodZi() {    // 用法一：訪問父類的成員變量System.out.println(super.num);  // 父類中的num變量}public void method() {      // 用法二：訪問父類的成員方法super.method(); // 訪問父類中的method方法System.out.println("子類方法！");}
}

11、this關鍵字的三種用法

super關鍵字用來訪問父類內容，而this關鍵字用來訪問本類內容。用法也有三種：

1、在本類的成員方法中，訪問本類的成員變量。
2、在本類的成員方法中，訪問本類的另一個成員方法。
3、在本類的構造方法中，訪問本類的另一個構造方法。
在第三種用法當中要注意：
A. this(…)調用也必須是構造方法的第一個語句，唯一一個。
B. super和this兩種構造調用，不能同時使用。

public class Fu {int num = 30;
}

public class Zi extends Fu {int num = 20;public Zi() {
//        super();    // 這一行不再贈送this(123);  // 本類的無參構造，調用本類的有參構造
//        this(1,2)   // 錯誤寫法！}public Zi(int n ) {this(1,2);}public Zi(int n, int m) {}public void showNum() {int num = 10;System.out.println(num);    // 局部變量System.out.println(this.num);   // 本類中的成員變量System.out.println(super.num);  // 父類中的成員變量}public void methodA() {System.out.println("AAA");}public void methodB() {this.methodA();System.out.println("BBB");}
}

12、super與this關鍵字圖解

13、Java繼承的三個特點

14、抽象的概念

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-l6jOMfJp-1590994988934)(http://ww1.sinaimg.cn/large/dcaa95eely1fxguzslyrfj20p50aqmz7.jpg)]

15、抽象方法和抽象類的格式

抽象方法：就是加上abstract關鍵字，然后去掉大括號，直接分好結束。
抽象類：抽象方法所在的類，必須是抽象類才行。在class之前寫上abstract即可。

public abstract class Animal {// 這是一個抽象方法，代表吃東西，但是具體吃什么（大括號的內容）不確定。public abstract void eat();// 這是普通的成員方法public void mormalMethod() {}
}

16、抽象方法和抽象類的使用

如何使用抽象類和抽象方法：
1、不能直接創建new抽象類對象。
2、必須用一個子類來繼承抽象父類。
3、子類必須覆蓋重寫抽象父類當中所有的抽象方法。
覆蓋重寫（實現）：子類去掉抽象方法的abstract關鍵字，然后補上方法體大括號。
4、創建子類對象進行使用。

public abstract class Animal {// 這是一個抽象方法，代表吃東西，但是具體吃什么（大括號的內容）不確定。public abstract void eat();// 這是普通的成員方法public void mormalMethod() {}
}

public class Cat extends Animal {@Overridepublic void eat() {System.out.println("貓吃魚");}
}

public class DemoMain {public static void main(String[] args) {
//        Animal animal = new Animal();   // 錯誤寫法！不能直接創建抽象類對象Cat cat = new Cat();cat.eat();}
}

17、抽象方法和抽象類的注意事項

關于抽象類的使用，以下為語法上要注意的細節，雖然條目較多，但若理解了抽象的本質，無需死記硬背。

1、抽象類不能創建對象，如果創建，編譯無法通過而報錯。只能創建其非抽象子類的對象。

理解：假設創建了抽象類的對象，調用抽象的方法，而抽象方法沒有具體的方法體，沒有意義。

2、抽象類中，可以有構造方法，是供子類創建對象時，初始化父類成員使用的。

理解：子類的構造方法中，有默認的super()，需要訪問父類構造方法。

public abstract class Fu {public Fu() {System.out.println("抽象父類構造方法執行！");}public abstract void eat();
}

public class Zi extends Fu {public Zi() {// super();System.out.println("子類構造方法執行");}@Overridepublic void eat() {System.out.println("吃飯");}
}

public class DemoMain {public static void main(String[] args) {Zi zi = new Zi();zi.eat();}
}

3、抽象類中，不一定包含抽象方法，但是有抽象方法的類必定是抽象類。
理解：未包含抽象方法的抽象類，目的就是不想讓調用者創建該類對象，通常用于某些特殊的類結構設
計。

/*
一個抽象類不一定含有抽象方法，
只要保證抽象方法所在的類是抽象類，即可。這樣沒有抽象方法的抽象類，也不能直接創建對象，在一些特殊場景下有用途。*/
public abstract class MyAbstract {}

4、抽象類的子類，必須重寫抽象父類中所有的抽象方法，否則，編譯無法通過而報錯。除非該子類也是抽象
類。
理解：假設不重寫所有抽象方法，則類中可能包含抽象方法。那么創建對象后，調用抽象的方法，沒有
意義。

// 最高的抽象父類
public abstract class Animal {public abstract void eat();public abstract void sleep();
}

// 子類也是一個抽象類
public abstract class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃骨頭");}
}

public class DogGolden extends Dog {@Overridepublic void sleep() {System.out.println("呼呼呼...");}
}

public class Dog2Ha extends Dog {@Overridepublic void sleep() {System.out.println("嘿嘿嘿...");}
}

public class DemoMain {public static void main(String[] args) {
//        Animal animal = new Animal();   // 錯誤！抽象類不能創建對象//        Dog dog = new Dog();    // 錯誤，這也是抽象類Dog2Ha ha = new Dog2Ha();   // 這是普通類，可以直接new對象ha.eat();ha.sleep();System.out.println("==================");DogGolden golden = new DogGolden();golden.eat();golden.sleep();}
}

18、發紅包案例

分析

實現

public class User {private String name;    // 姓名private int money;      // 余額，也就是當前用戶擁有的錢數public User() {}public User(String name, int money) {this.name = name;this.money = money;}// 展示一下當前用戶有多少錢public void show() {System.out.println("我叫：" + name + "，當前余額：" + money);}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getMoney() {return money;}public void setMoney(int money) {this.money = money;}
}

// 群主的類
public class Manager extends User {public Manager() {}public Manager(String name, int money) {super(name, money);}public ArrayList<Integer> send(int totalMoney, int count) {// 首先需要一個集合，用來存儲若干個紅包的金額ArrayList<Integer> redList = new ArrayList<>();// 首先看一下群主自己有多少錢int leftMoney = super.getMoney();   // 群主當前余額if (totalMoney > leftMoney) {System.out.println("余額不足");return redList; // 返回空集合}// 扣錢，其實就是重新設置余額super.setMoney(leftMoney - totalMoney);// 發紅包需要平均拆分成為count份int avg = totalMoney / count;int mod = totalMoney % count;   // 余數，也就是除不開的零頭// 除不開的零頭，包在最后一個紅包當中// 下面把紅包一個一個放到集合當中for (int i = 0; i < count - 1; i++) {redList.add(avg);}// 最后一個紅包int last = avg + mod;redList.add(last);return redList;}
}

// 普通成員
public class Member extends User {public Member() {}public Member(String name, int money) {super(name, money);}public void receive(ArrayList<Integer> list) {// 從多個紅包當中隨便抽取一個，給我自己。// 隨機獲取一個集合當中的索引編號int index = new Random().nextInt(list.size());// 根據索引，從集合當中刪除，并且得到被刪除的紅包，給我自己int dalta = list.remove(index);// 當前成員自己本來有多少錢int money = super.getMoney();// 加法，并重新設置回去super.setMoney(money + dalta);}
}

public class MainRedPacket {public static void main(String[] args) {Manager manager = new Manager("群主",100);Member one = new Member("成員A", 0);Member two = new Member("成員B", 0);Member three = new Member("成員C", 0);manager.show(); // 100one.show();     // 0two.show();     // 0three.show();   // 0System.out.println("==============");// 群主總共發20塊錢，分成3個紅包ArrayList<Integer> redList = manager.send(20,3);// 三個普通成員收紅包one.receive(redList);two.receive(redList);three.receive(redList);manager.show(); // 100-20=80// 6、6、8，隨機分給三個人one.show();two.show();three.show();}
}

DAY10

1、接口概述與生活舉例

2、接口的定義基本格式

接口就是多個類的公共規范。
接口是一種引用數據類型，最重要的內容就是其中的：抽象方法。

如何定義一個接口的格式：
public interface 接擴名稱 {
// 接口內容
}

注意：
換成了關鍵字interface之后，編譯生成的字節碼文件仍然是：
.java --> .class

如果是Java 7，那么接口中可以包含的內容有：
1、常量
2、抽象方法

如果是Java 8，還可以額外包含有：
3、默認方法
4、靜態方法

如果是Java 9，還可以額外包含有：
5、私有方法

3、接口的抽象方法定義

在任何版本的Java中，接口都能定義抽象方法。
格式：
public abstract 返回值類型方法名稱(參數列表);

注意事項：
1、接口當中的抽象方法，修飾符必須是兩個固定的關鍵字：public abstract
2、這兩個關鍵字修飾符，可以選擇性地省略。（熟悉后可以省略）
3、方法的三要素，可以隨意定義。

public interface MyInterfaceAbstract {// 這是一個抽象方法public abstract void methodAbs();// 這也是抽象方法abstract void methodAbs2();// 這也是抽象方法public void methodAbs3();// 這還是抽象方法void methodAbs4();
}

4、接口的抽象方法使用

接口使用步驟：
1、接口不能直接使用，必須有一個“實現類”來“實現”該接口。
格式：
public class 類名稱 implements 接口名稱 {
// …
}
2、接口的實現類必須覆蓋重寫(實現)接口中所有的抽象方法。
實現：去掉abstract關鍵字，加上方法體大括號。（覆蓋重寫）
3、創建實現類的對象，進行使用。

注意事項：
如果實現類并沒有覆蓋重寫接口中所有的抽象方法，那么這個實現類自己必須是抽象類。

public class MyInterfaceAbstractlmpl implements MyInterfaceAbstract {@Overridepublic void methodAbs() {System.out.println("這是第一個方法！");}@Overridepublic void methodAbs2() {System.out.println("這是第二個方法！");}@Overridepublic void methodAbs3() {System.out.println("這是第三個方法！");}@Overridepublic void methodAbs4() {System.out.println("這是第四個方法！");}
}

public class Demo01Interface {public static void main(String[] args) {// 錯誤寫法！不能直接new接口對象使用。
//        MyInterfaceAbstract inter = new MyInterfaceAbstract();// 創建實現類的對象使用MyInterfaceAbstractlmpl impl = new MyInterfaceAbstractlmpl();impl.methodAbs();impl.methodAbs2();}
}

5、接口的默認方法定義

從Java 8開始，接口里允許定義默認方法。
格式：
public default 返回值類型方法名稱(參數列表) {
方法體
}

注意：接口當中的默認方法，可以解決接口升級的問題。

public interface MyInterfaceDefault {// 抽象方法public abstract void methodAbs();
}

public class MyInterfaceDefaultA implements MyInterfaceDefault {@Overridepublic void methodAbs() {System.out.println("實現了抽象方法，AAA");}
}

public class MyInterfaceDefaultB implements MyInterfaceDefault {@Overridepublic void methodAbs() {System.out.println("實現了抽象方法，BBB");}
}

6、接口的默認方法使用

1、接口的默認方法，可以通過接口實現類對象，直接調用。
2、接口的默認方法，也可以被接口實現類進行覆蓋重寫。

public interface MyInterfaceDefault {// 抽象方法public abstract void methodAbs();// 新添加了一個抽象方法
//    public abstract void methodAbs2();// 新添加的方法，改成默認方法public default void methodDefault() {System.out.println("這是新添加的默認方法");}
}

public class Demo02Interface {public static void main(String[] args) {// 創建了實現類對象MyInterfaceDefaultA  a = new MyInterfaceDefaultA();a.methodAbs();  // 調用抽象方法，實際運行的是右側實現類// 調用默認方法，如果實現類當中沒有，會向上找接口a.methodDefault();  // 這是新添加的默認方法System.out.println("===================");MyInterfaceDefaultB  b = new MyInterfaceDefaultB();b.methodAbs();b.methodDefault();  // 實現類B覆蓋重寫了接口的默認方法}
}

7、接口的靜態方法定義

從Java 8開始，接口當中允許定義靜態方法。
格式：
public static 返回值類型方法名稱(參數列表) {
方法體
}
提示：就是將abstract或者default換成static即可，帶上方法體。

8、接口的靜態方法使用

注意事項：不能通過接口實現類的對象來調用接口當中的靜態方法。
正確用法：通過接口名稱，直接調用其中的靜態方法，
格式：
接口名稱.靜態方法名(參數);

public interface MyInterfaceStatic {public static void methodStatic() {System.out.println("這是接口的靜態方法！");}
}

public class MyInterfaceStaticImpl implements MyInterfaceStatic {
}

public class Demo03Interface {public static void main(String[] args) {// 創建實現類對象  由于跟對象沒有關系，沒有必要創建對象
//        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();// 錯誤寫法！
//        impl.methodStatic();// 直接通過接口名稱調用靜態方法MyInterfaceStatic.methodStatic();}
}

9、接口的私有方法定義

問題描述：
我們需要抽取一個公共方法，用來解決兩個默認方法之間重復代碼的問題。
但是這個共有方法不應該讓實現類使用，應該是私有化的。

解決方案：
從Java 9開始，接口當中允許定義私有方法。
1、普通私有方法，解決多個默認方法之間重復代碼問題
格式：
private 返回值類型方法名稱(參數列表) {
方法體
}

2、靜態私有方法，解決多個靜態方法之間重復代碼問題
private static 返回值類型方法名稱(參數列表) {
方法體
}

public interface MyInterfacefacePrivateA {public default void MethodDefault1() {System.out.println("默認方法1");methodCommon();}public default void MethodDefault2() {System.out.println("默認方法2");methodCommon();}public default void methodCommon() {	// 這樣的方法不可取System.out.println("AAA");System.out.println("BBB");System.out.println("CCC");}
}

10、接口的私有方法使用

public interface MyInterfacePrivateA {public default void MethodDefault1() {System.out.println("默認方法1");methodCommon();}public default void MethodDefault2() {System.out.println("默認方法2");methodCommon();}private void methodCommon() {System.out.println("AAA");System.out.println("BBB");System.out.println("CCC");}
}

public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {public void methodAnother() {// 直接訪問到了接口中的默認方法，這樣是錯誤的！
//        methodCommon();}
}

同樣接口中的靜態方法也是如此

public interface MyInterfacePrivateB {public static void methodStatic1() {System.out.println("靜態方法1");methodStaticCommon();}public static void methodStatic2() {System.out.println("靜態方法2");methodStaticCommon();}private static void methodStaticCommon() {System.out.println("AAA");System.out.println("BBB");System.out.println("CCC");}
}

public class Demo04Interface {public static void main(String[] args) {MyInterfacePrivateB.methodStatic1();MyInterfacePrivateB.methodStatic2();// 錯誤寫法！
//        MyInterfacePrivateB.methodStaticCommon();}
}

11、接口的常量定義和使用

接口當中也可以定義“成員變量”，但是必須使用public static final三個關鍵字進行修飾。
從效果上看，這其實就是接口的常量。
格式：
public static final 數據類型常量名稱 = 數據值;
注意：
一旦使用final關鍵字進行修飾，說明不可改變。

注意事項：
1、接口當中的常量，可以省略public static final，注意：不寫也一樣是這樣
2、接口當中的常量，必須進行賦值；不能不賦值。
3、接口當中常量的名稱，使用完全大寫的字母，用下劃線進行分隔。(推薦命名規則)

public interface MyInterfaceConst {// 這其實就是一個常量，一旦賦值，不可以修改public static final int NUM_OF_MY_CLASS = 10;}

public class Demo05Interface {public static void main(String[] args) {// 訪問接口當中的常量System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);}
}

12、接口的內容小結

在Java 9+版本中，接口的內容可以有：1、成員變量其實是常量，格式：
[public] [static] [final] 數據類型 常量名稱 = 數據值；
注意：常量必須要進行賦值，而且一旦賦值不能改變。常量名稱全完大寫，用下劃線進行分隔。2、接口中最重要的就是抽象方法，格式：
[public] [abstract] 返回值類型 方法名稱(參數列表);
注意：實現類必須覆蓋重寫接口所有的抽象方法，除非實現類是抽象類。3、從Java 8開始，接口里允許定義默認方法，格式：
[public] default 返回值類型 方法名稱(參數列表) { 方法體 }
注意：默認方法也可以被覆蓋重寫4、從Java 8開始，接口里允許定義靜態方法，格式：
[public] static 返回值類型 方法名稱(參數列表) { 方法體 }
注意：應該通過接口名稱進行調用，不能通過實現類對象調用接口靜態方法5、從Java 9開始，接口里允許定義私有方法，格式：
普通私有方法：private 返回值類型 方法名稱(參數列表) { 方法體 }
靜態私有方法：private static 返回值類型 方法名稱(參數列表) { 方法體 }
注意：private的方法只有接口自己才能調用，不能被實現類或別人使用。

13、繼承父類并實現多個接口

使用接口的時候，需要注意：

1、接口是沒有靜態代碼塊或者構造方法的。

public interface MyInterface {// 錯誤寫法！接口不能有靜態代碼塊
//    static {
//
//    }// 錯誤寫法！接口不能有構造方法
//    public MyInterfaceA() {
//
//    }
}

2、一個類的直接父類是唯一的，但是一個類可以同時實現多個接口。

格式：
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB {
// 覆蓋重寫所有抽象方法
}

public interface MyInterfaceA {public abstract void mehtodA();}

public interface MyInterfaceB {public abstract void mehtodB();}

public class MyInterfaceImpl /*extends Object*/ implements MyInterfaceA, MyInterfaceB {@Overridepublic void mehtodA() {System.out.println("覆蓋重寫了A方法");}@Overridepublic void mehtodB() {System.out.println("覆蓋重寫了B方法");}
}

3、如果實現類所實現的多個接口當中，存在重復的抽象方法，那么只需要覆蓋重寫一次即可.

public interface MyInterfaceA {public abstract void methodAbs();}

public interface MyInterfaceB {public abstract void methodAbs();}

public class MyInterfaceImpl /*extends Object*/ implements MyInterfaceA, MyInterfaceB {@Overridepublic void methodAbs() {System.out.println("覆蓋重寫了AB接口都有的抽象方法");}
}

4、如果實現類沒有覆蓋重寫所有接口當中的所有抽方法，那么實現類就必須是一個抽象類。

public interface MyInterfaceA {public abstract void mehtodA();public abstract void methodAbs();
}

public interface MyInterfaceB {public abstract void mehtodB();public abstract void methodAbs();
}

public abstract/*必須加上abstract讓其成為抽象類*/ class MyInterfaceAbstract implements MyInterfaceA, MyInterfaceB {@Overridepublic void mehtodA() {}@Overridepublic void methodAbs() {}
}

5、如果實現類所實現的多個接口當中，存在重復的默認方法，那么實現類一定要對沖突的默認方法進行覆蓋重寫。

public interface MyInterfaceA {public default void methdDefault() {System.out.println("默認方法AAA");}
}

public interface MyInterfaceB {public default void methdDefault() {System.out.println("默認方法BBB");}
}

public class MyInterfaceImpl /*extends Object*/ implements MyInterfaceA, MyInterfaceB {@Overridepublic void methdDefault() {System.out.println("對多個接口當中突然的默認方法進行了覆蓋重寫");}
}

public abstract/*必須加上abstract讓其成為抽象類*/ class MyInterfaceAbstract implements MyInterfaceA, MyInterfaceB {@Overridepublic void methdDefault() {}
}

6、一個類如果直接父類當中的方法，和接口當中的默認方法產生了沖突，優先用父類當中的方法

public class Fu {public void method() {System.out.println("父類方法");}
}

public class Zi extends Fu implements MyInterface {
}

public interface MyInterface {public default void method() {System.out.println("接口的默認方法");}
}

public class Demo01Interface {public static void main(String[] args) {Zi zi = new Zi();zi.method();}
}

14、接口之間的多繼承

1、類與類之間是單繼承的。直接父類只有一個。
2、類與接口之間是多實現的。一個類可以實現多個接口。
3、接口與接口之間是多繼承的。

public interface MyInterfaceA {public abstract void methodA();public abstract void methodCommon();
}

public interface MyInterfaceB {public abstract void methodB();public abstract void methodCommon();
}

/*
這個子接口當中有幾個方法？   4個方法
methodA 來源于接口A
methodB 來源于接口B
methodCommon 同時來源于接口A和B
method 來源于自己*/
public interface MyInterface extends MyInterfaceA, MyInterfaceB {public abstract void method();
}

public class MyInterfaceImpl implements MyInterface {@Overridepublic void method() {}@Overridepublic void methodA() {}@Overridepublic void methodB() {}@Overridepublic void methodCommon() {}
}

注意事項：
1、多個父接口當中的抽象方法如果重復，沒關系。
2、多個父接口當中的默認方法如果重復，那么子接口必須進行默認方法的覆蓋重寫，而且帶著default關鍵字。

public interface MyInterfaceA {public default void methodDefault() {System.out.println("AAA");}
}

public interface MyInterfaceB {public default void methodDefault() {System.out.println("BBB");}
}

public interface MyInterface extends MyInterfaceA, MyInterfaceB {@Overridedefault void methodDefault() {}
}

15、多態的概述

面向對象三大特征：封裝性、繼承性、多態性。

extends繼承或者implements實現，是多態性的前提。

16、多態的格式與使用

代碼當中體現多態性，其實就是一句話：父類引用指向子類對象。

格式：
父類名稱對象名 = new 子類名稱();
或者：
接口名稱對象名 = new 實現類名稱();

public class Demo01Multi {public static void main(String[] args) {// 使用多態的寫法// 左側父類的引用，指向了右側子類的對象Fu obj = new Zi();obj.method();obj.methodFu();}
}

public class Fu {public void method() {System.out.println("父類方法");}public void methodFu() {System.out.println("父類特有方法");}
}

public class Zi extends Fu {@Overridepublic void method() {System.out.println("子類方法");}
}

17、多態中成員變量的使用特點

訪問成員變量的兩種方式：

1、直接通過對象名稱訪問成員變量：看等號左邊是誰，優先用誰，沒有則向上找
2、間接通過成員方法訪問成員變量：看該方法屬于誰，優先用誰，沒有則向上找

public class Fu {int num = 10;public void showNum() {System.out.println(num);}
}

public class Zi extends Fu {int num = 20;int age = 30;@Overridepublic void showNum() {System.out.println(num);}
}

public class Demo01MultiFueld {public static void main(String[] args) {// 使用多態的寫法，父類引用指向子類對象Fu obj = new Zi();System.out.println(obj.num);    // 父：10
//        System.out.println((obj.age);   // 錯誤寫法！System.out.println("=============");// 子類沒有覆蓋重寫，就是父：10// 子類如果覆蓋重寫，就是子：20obj.showNum();}
}

18、多態中成員方法的使用特點

在多態的代碼當中，成員方法的訪問規則是：
看new的是誰，就優先用誰，沒有則向上找

口訣：編譯看左邊，運行看右邊。

對比：
成員變量：編譯看左邊，運行還看左邊。
成員方法：編譯看左邊，運行看右邊。

public class Fu {public void method() {System.out.println("父類方法");}public void methodFu() {System.out.println("父類特有方法");}
}

public class Zi extends Fu {@Overridepublic void method() {System.out.println("子類方法");}public void methodZi() {System.out.println("子類特有方法");}
}

public class Demo02MultiMethod {public static void main(String[] args) {Fu obj = new Zi();  // 多態obj.method();   // 父子都有，優先用子obj.methodFu(); // 子類沒有，父類有，向上找到父類// 編譯看左邊，左邊是Fu，Fu當中沒有methodZi方法，所有編譯報錯
//        obj.methodZi();  // 錯誤寫法！}
}

19、使用多態的好處

20、對象的向上轉型與向下轉型

向上轉型

向上轉型一定是安全的。

public abstract class Animal {public abstract void eat();
}

ublic class Cat extends Animal {@Overridepublic void eat() {System.out.println("貓吃魚");}
}

public class Demo01Main {public static void main(String[] args) {// 對象的向上轉型，就是：父類引用指向子類對象Animal animal = new Cat();animal.eat();   // 貓吃魚//        animal.catchMouse();    // 錯誤寫法！
}

向下轉型

向上轉型一定是安全的。但是也有一個弊端：

對象一旦向上轉型為父類，那么就無法調用子類原本特有的內容。

解決方案：用對象的向下轉型【還原】

public abstract class Animal {public abstract void eat();
}

public class Cat extends Animal {@Overridepublic void eat() {System.out.println("貓吃魚");}// 子類特有方法public void catchMouse() {System.out.println("貓抓老鼠");}
}

public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃SHIT");}public void watchHouse() {System.out.println("狗看家");}
}

public class Demo01Main {public static void main(String[] args) {// 向下轉型，進行【還原】動作Cat cat = (Cat) animal;cat.catchMouse();   // 貓抓老鼠// 下面是錯誤的向下轉型// 本來new的時候是一只貓，現在非要當做狗// 錯誤寫法！編譯不會報錯，但是運行會出現異常：// java.lang.ClassCastException，類轉換異常
//        Dog dog = (Dog) animal;}
}

21、用instanceof關鍵字進行類型判斷

如何才能知道一個父類引用的對象，本來是什么子類？
格式：
對象 instanceof 類名稱
這將會得到一個boolean值結果，也就是判斷前面的對象能不能當做后面類型的實例。

public class Demo02Instanceof {public static void main(String[] args) {Animal animal = new Dog();  // 本來是只貓animal.eat();   // 狗吃SHIT// 如果希望調用子類特有方法，需要向下轉型// 判斷一下父類引用animal本來是不是Dogif (animal instanceof Dog) {Dog dog = (Dog) animal;dog.watchHouse();}// 判斷一下animal本來是不是Catif (animal instanceof Cat) {Cat cat = (Cat) animal;cat.catchMouse();}giveMeAPet(new Dog());}public static void giveMeAPet(Animal animal) {if (animal instanceof Dog) {Dog dog = (Dog) animal;dog.watchHouse();}if (animal instanceof Cat) {Cat cat = (Cat) animal;cat.catchMouse();}}
}

22、筆記本USB接口案例

分析

實現

public interface USB {public abstract void open();    // 打開設備public abstract void close();   // 關閉設備
}

public class Computer {public void powerOn() {System.out.println("筆記本電腦開機");}public void powerOff() {System.out.println("筆記本電腦關機");}// 使用USB設備的方法，使用接口作為方法的參數public void usbDevice(USB usb) {usb.open(); // 打開設置if (usb instanceof Mouse) {     // 一定要先判斷Mouse mouse = (Mouse) usb;  // 向下轉型mouse.click();} else if (usb instanceof Keyboard) {   // 先判斷Keyboard keyboard = (Keyboard) usb; // 向下轉型keyboard.type();}usb.close();    // 關閉設備}
}

// 鼠標就是一個USB設備
public class Mouse implements USB {@Overridepublic void open() {System.out.println("打開鼠標");}@Overridepublic void close() {System.out.println("關閉鼠標");}public void click() {System.out.println("點擊鼠標");}
}

// 鍵盤就是一個USB設備
public class Keyboard implements USB {@Overridepublic void open() {System.out.println("打開鍵盤");}@Overridepublic void close() {System.out.println("關閉鍵盤");}public void type() {System.out.println("鍵盤輸入");}
}

public class DemoMain {public static void main(String[] args) {// 首先創建一個筆記本電腦Computer computer = new Computer();computer.powerOn();// 準備一個鼠標，供電腦使用
//        Mouse mouse = new Mouse();// 首先進行向上轉型USB usbMouse = new Mouse(); // 多態寫法// 參數是USB類型，正好傳遞進去的就是USB鼠標computer.usbDevice(usbMouse);// 創建一二USB鍵盤Keyboard keyboard = new Keyboard(); // 沒有使用多態寫法// 方法參數是USB類型，傳遞進去的是實現類對象computer.usbDevice(keyboard);   // 正確寫法，也發生了向上轉型// 使用子類對象，匿名對象，也可以
//        computer.usbDevice(new Keyboard()); // 也是正確寫法computer.powerOff();System.out.println("=================");method(10.0);   // 正確寫法，double --> doublemethod(20);     // 正確寫法，int --> doubleint a = 30;method(a);      // 正確寫法，int --> double}public static void method(double num) {System.out.println(num);}
}

DAY11

1、final關鍵字

final關鍵字代表最終、不可改變的

常見四種用法：

1、可以用來修飾一個類

/*
當final關鍵字用來修飾一個類的時候，格式：
public final class 類名稱 {// ...
}含義：當前這個類不能有任何的子類
注意：一個類如果是final的，那么其中所有的成員方法都無法進行覆蓋重寫（因為沒有辦法繼承）*/
public final class MyClass /*extends Object*/ {public void method() {System.out.println("方法執行！");}
}

// 不能使用一個final類來作為父類
public class MySubClass /*extends MyClass*/ {
}

2、可以用來修飾一個方法

/*
當final關鍵字用來修飾一個方法的時候，這個方法就是最終方法，也就是不能被覆蓋重寫
格式：
修飾符 final 返回值類型 方法名稱(參數列表) {// 方法體
}注意事項：
對于類、方法來說，abstract關鍵字和final關鍵字不能同時使用，因為抽象類必須要重寫，矛盾*/
public class Fu {public final void method() {System.out.println("父類方法執行！");}
}

public class Zi extends Fu {// 錯誤寫法！不能覆蓋重寫父類當中final的方法
//    @Override
//    public void method() {
//        System.out.println("子類覆蓋重寫父類的方法！");
//    }
}

3、可以用來修飾一個局部變量

public class Demo01Final {public static void main(String[] args) {int num1 = 10;System.out.println(num1);   // 10num1 = 20;System.out.println(num1);   // 20// 一旦使用final用來修飾局部變量，那么這個變量就不能更改。// "一次賦值，終生不變"final int num2 = 200;System.out.println(num2);   // 200//        num2 = 250; // 錯誤寫法！不能改變
//        num2 = 200; // 錯誤寫法！// 正確寫法！只要保證有唯一一次賦值即可final int num3;num3 = 30;// 對于基本類型來說，不可變說的是變量當中的數據不可改變// 對于引用類型來說，不可變說的是變量單重的地址值不可改變Student stu1 = new Student("小明");System.out.println(stu1);System.out.println(stu1.getName());     // 小明stu1 = new Student("小紅");System.out.println(stu1);System.out.println(stu1.getName());     // 小紅System.out.println("=================");final Student stu2 = new Student("小明");// 錯誤寫法！final的引用類型變量，其中的地址不可改變
//        stu2 = new Student("小紅");System.out.println(stu2.getName()); // 小明stu2.setName("小紅");System.out.println(stu2.getName()); // 小紅}
}

4、可以用來修飾一個成員變量

/*
對于成員變量來說，如果使用final關鍵字修飾，那么這個變量也照樣是不可變1、由于成員變量具有默認值，所以用了final之后必須手動賦值，不會再給默認值了。
2、對于final的成員變量，要么使用直接賦值，要么通過構造方法賦值。二者選其一。
3、必須保證類當中所有重載的構造方法，都最終會對final的成員變量進行賦值。*/
public class Person {private final String name /*= "小明"*/;public Person() {name = "小紅";}public Person(String name) {this.name = name;}public String getName() {return name;}//    public void setName(String name) {
//        this.name = name;
//    }
}

2、四種權限修飾符

Java中有四種權限修飾符：public  >   protected   >   (default)   >   private
同一個類(我自己)        YES         YES             YES             YES
同一個包(我鄰居)        YES         YES             YES              NO
不同包子類(我兒子)       YES         YES             NO              NO
不同包非子類(陌生人)     YES         NO              NO              NO注意事項：
(default)并不是關鍵字“default”，而是根本不寫。

public class MyClass {public int num = 10;
}

同一個類

public class MyClass {public int num = 10;public void method() {System.out.println(num);}
}

同一個包

public class MyAnother {public void anotherMethod() {System.out.println(new MyClass().num);}
}

不同包子類

public class MySon extends MyClass {public void methodSon() {System.out.println(super.num);}
}

不同包非子類

public class Stranger {public void methodStrange() {System.out.println(new MyClass().num);}
}

3、內部類的概念與分類

如果一個事物的內部包含另一個事物，那么這就是一個類內部包含另一個類。
例如：身體和心臟的關系、汽車和發動機的關系。

分類：
1、成員內部類
2、局部內部類（包含匿名內部類）

4、成員內部類的定義

成員內部類的定義格式：
修飾符 class 外部類名稱 {
修飾符 class 內部類名稱 {
// …
}
// …
}

注意：
內部類用外部類，隨意訪問；
外部類用內部類，需要借助內部類對象。

public class Body {     // 外部類public class Hrart {    // 成員內部類// 內部類的方法public void beat() {System.out.println("心臟跳動");System.out.println("我叫：" + name);   // 正確寫法}}// 外部類的成員變量private String name;// 外部類的方法public void methodBody() {System.out.println("外部類的方法");}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

5、成員內部類的使用

如何使用成員內部類？有兩種方法：

1、間接方式：

在外部類的方法當中，使用內部類；然后main只是調用外部類的方法。

先在外部類方法中添加內部類的匿名對象

public class Body {     // 外部類public class Heart {    // 成員內部類// 內部類的方法public void beat() {System.out.println("心臟跳動");System.out.println("我叫：" + name);   // 正確寫法}}// 外部類的成員變量private String name;// 外部類的方法public void methodBody() {System.out.println("外部類的方法");new Heart().beat();     // 匿名對象}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

public class Demo01InnerClass {public static void main(String[] args) {Body body = new Body(); // 外部類的對象// 通過外部類的對象，調用外部類的方法，里面間接在使用內部類Heartbody.methodBody();}
}

2、直接方式：

公式：
類名稱對象名 = new 類名稱();
外部類名稱.內部類名稱對象名 = new 外部類名稱().new 內部類名稱();

public class Demo01InnerClass {public static void main(String[] args) {// 按照公式寫：Body.Heart heart = new Body().new Heart();heart.beat();}
}

6、內部類的同名變量訪問

如果出現了重名現象，那么格式是：外部類名稱.this.外部類成員變量名

public class Outer {int num = 10;   // 外部類的成員變量public class Inner {int num = 20;   // 內部類的成員變量public void methodInner() {int num = 30;   // 內部類方法的局部變量System.out.println(num);    // 局部變量，就近原則System.out.println(this.num);   // 內部類的成員變量System.out.println(Outer.this.num); // 外部類的成員變量}}
}

public class Demo02InnerClass {public static void main(String[] args) {// 外部類名稱.內部類名稱 對象名 = new 外部類名稱().new 內部類名稱();Outer.Inner inner = new Outer().new Inner();inner.methodInner();}
}

7、局部內部類定義

如果一個類是定義在一個方法內部的，那么這就是一個局部內部類。
“局部”：只有當前所屬的方法才能使用它，出了這個方法外面就不能用了，

定義格式：
修飾符 class 外部類名稱 {
修飾符但繪制類型外部類方法名稱(參數列表) {
class 局部內部類名稱 {
// …
}
}
}

小結：權限修飾符
public > protected > (default) > private
定義一個類的時候，權限修飾符規則：
1、外部類：public / (default)
2、成員內部類：public / protected / (default) / private
3、局部內部類：什么都不能寫（效果和default不一樣）

public class Outer {public void methodOuter() {class Inner {   // 局部內部類int num = 10;public void methodInner() {System.out.println(num);    // 10}}Inner inner = new Inner();inner.methodInner();}
}

public class DemoMain {public static void main(String[] args) {Outer outer = new Outer();outer.methodOuter();}
}

8、局部內部類的final問題

局部內部類，如果希望訪問所在方法的局部變量，那么這個局部變量必須是【有效final的】。

注意：
從Java 8+開始，只要局部變量真的不變，那么final關鍵字可以省略。

原因：
1、new出來的對象在堆內存當中。
2、局部變量是跟著方法走的，在棧內存當中。
3、方法運行結束之后，立刻出棧，局部變量就會立刻消失。
4、但是new出來的對象會在堆當中持續存在，直到垃圾回收消失。

public class MyOuter {public void methodOuter() {int num = 10;   // 所在方法的局部變量class MyInner {public void methodInner() {System.out.println(num);}}}
}

9、匿名內部類的定義格式與注意事項

如果接口的實現類(或者是父類的子類)只需要使用唯一的一次。
那么這種情況下就可以省略掉該類的定義，而改為使用【匿名內部類】。

匿名內部類的定義格式：
接口名稱對象名 = new 接口名稱() {
// 覆蓋重寫所有抽象方法
};

對格式“new 接口名稱() {…}”進行解析：
1、new代表創建對象的動作
2、接口名稱就是匿名內部類需要實現哪個接口
3、{…}這才是匿名內部類的內容

注意事項：
1、匿名內部類，在【創建對象】的時候，只能使用唯一一次。
如果希望多次創建對象，而且類的內容一樣的話，那么就必須使用單獨定義的實現類了。
2、匿名對象，在【調用方法】的時候，只能調用唯一一次。
如果希望同一個對象，調用多次方法，那么必須給對象起一個名字。
3、匿名內部類是省略了【實現類/子類名稱】，但是匿名對象是省略了【對象名稱】
強調：匿名內部類和匿名對象不是一回事！

public interface MyInterface {void method1();  // 抽象方法void method2();
}

public class MyInterfaceImpl implements MyInterface {@Overridepublic void method1() {System.out.println("實現類覆蓋重寫了方法！111");}@Overridepublic void method2() {System.out.println("實現類覆蓋重寫了方法！222");}
}

public class DemoMain {public static void main(String[] args) {
//        MyInterface obj = new MyInterfaceImpl();
//        obj.method();//        MyInterface some = new MyInterface();   // 錯誤寫法// 使用匿名內部類，但不是匿名對象，對象名稱就叫objAMyInterface objA = new MyInterface() {@Overridepublic void method1() {System.out.println("匿名內部類實現了方法！111");}@Overridepublic void method2() {System.out.println("匿名內部類實現了方法！222");}};objA.method1();objA.method2();System.out.println("========================");// 使用了匿名內部類，而且省略了對象名稱，也是匿名對象new MyInterface() {@Overridepublic void method1() {System.out.println("匿名內部類實現了方法！111");}@Overridepublic void method2() {System.out.println("匿名內部類實現了方法！222");}}.method1();// 因為匿名對象無法調用第二次方法，所以需要再創建一個匿名內部類的匿名對象new MyInterface() {@Overridepublic void method1() {System.out.println("匿名內部類實現了方法！111");}@Overridepublic void method2() {System.out.println("匿名內部類實現了方法！222");}}.method2();}
}

10、類作為成員變量類型

public class Weapon {private String code;    // 武器的代號public Weapon() {}public Weapon(String code) {this.code = code;}public String getCode() {return code;}public void setCode(String code) {this.code = code;}
}

// 游戲當中的英雄角色類
public class Hero {private String name;    // 英雄名稱private int age;        // 英雄的年齡private Weapon weapon;  // 武器public Hero() {}public Hero(String name, int age, Weapon weapon) {this.name = name;this.age = age;this.weapon = weapon;}public void attack() {System.out.println("年齡為" + age + "的" + name + "用" + weapon.getCode() + "攻擊敵方");}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;}public Weapon getWeapon() {return weapon;}public void setWeapon(Weapon weapon) {this.weapon = weapon;}
}

public class DemoMain {public static void main(String[] args) {// 創建一個英雄角色Hero hero = new Hero();// 為英雄起一個名稱，并且設置年齡hero.setName("蓋倫");hero.setAge(20);// 創建一個武器對象Weapon weapon = new Weapon("多蘭劍");// 為英雄配備武器hero.setWeapon(weapon);// 年齡為20的蓋倫用多蘭劍攻擊敵方hero.attack();}
}

11、接口作為成員變量類型

public class Hero {private String name;    // 英雄的名稱private Skill skill;    // 英雄的技能public Hero() {}public Hero(String name, Skill skill) {this.name = name;this.skill = skill;}public void attack() {System.out.println("我叫" + name + "，開始釋放技能");skill.use();    // 調用接口中的抽象方法System.out.println("釋放技能完成");}public String getName() {return name;}public void setName(String name) {this.name = name;}public Skill getSkill() {return skill;}public void setSkill(Skill skill) {this.skill = skill;}
}

public interface Skill {void use(); // 釋放技能的抽象方法
}

public class SkillImpl implements Skill {@Overridepublic void use() {System.out.println("Biu~biu~biu~");}
}

public class DemoGame {public static void main(String[] args) {Hero hero = new Hero();hero.setName("艾希");     // 設置英雄的名稱// 設置英雄技能
//        hero.setSkill(new SkillImpl());     // 使用單獨定義的實現類// 還可以改成使用匿名內部類
//        Skill skill = new Skill() {
//            @Override
//            public void use() {
//                System.out.println("Biu~biu~biu~");
//            }
//        };
//        hero.setSkill(skill);// 進一步簡化，同時使用匿名內部類和匿名對象hero.setSkill(new Skill() {@Overridepublic void use() {System.out.println("Biu~biu~biu~");}});hero.attack();}
}

12、接口作為方法的參數和或返回值

import java.util.ArrayList;
import java.util.List;/*
java.util.List正是ArrayList所實現的接口。*/
public class DemoInterface {public static void main(String[] args) {// 左邊是接口名稱，右邊是實現類名稱，這就是多態寫法List<String> list = new ArrayList<>();List<String> result = addNames(list);for (int i = 0; i < result.size(); i++) {System.out.println(result.get(i));}}public static List<String> addNames(List<String> list) {list.add("小明");list.add("小紅");return list;}
}

13、紅包案例

場景說明：
紅包發出去之后，所有人都有紅包，大家搶完了之后，最后一個紅包給群主自己。

我們自己要做的事情有：
1、設置一下程序的標題，通過構造方法的字符串參數
2、設置群主名稱
3、設置分開策略：平均or隨機

紅包分發的策略：
1、普通紅包（平均）：totalMoney / totalCount，余數放在最后一個紅包當中。
2、手氣紅包（隨機）：最少1分錢，最多不超過平均數的2倍。

public interface OpenMode {/*** 請將totalMoney分成count份，保存到ArrayList<Integer>中，返回即可** @param totalMoney            總金額為方便計算，已經轉換為整數，單位為分* @param totaCount             紅包個數* @return ArrayList<Integer>   元素為各個紅包的金額值，所有元素的值累和等于總金額。*/ArrayList<Integer> divide(int totalMoney, int totaCount);
}

public class MyRed extends RedPacketFrame {/*** 構造方法：生成紅包界面。** @param title 界面的標題*/public MyRed(String title) {super(title);}
}

public class NormalMode implements OpenMode {@Overridepublic ArrayList<Integer> divide(final int totalMoney, final int totaCount) {ArrayList<Integer> list = new ArrayList<>();int avg = totalMoney / totaCount;   // 平均值int mod = totalMoney % totaCount;   // 余數，零頭// 注意totalCount - 1代表，最后一個先留著for (int i = 0; i < totaCount - 1; i++) {list.add(avg);}// 有零頭，需要放在最后一個紅包當中list.add(avg + mod);return list;}
}

public class RandomMode implements OpenMode {@Overridepublic ArrayList<Integer> divide(int totalMoney, int totaCount) {ArrayList<Integer> list = new ArrayList<>();// 隨機分配，有可能多，有可能少// 最少1分錢，最多不超過“剩下金額平均數的2倍”// 第一次發紅包，隨機范圍是0.01~6.66元// 第一次發完之后，剩下的至少是3.34元// 此時還需要再發2個紅包// 此時的再發范圍應該是0.01元～3.34元（取不到右邊，剩下的0.01）// 總結一下，范圍的公式是：1 + random.nextInt(leftMoey / leftcount * 2);Random r = new Random();    // 首先創建一個隨機數生成器// totalMoney是總金額，totalCount是總份數，不變// 額外定義兩個變量，分別代表剩下多少錢，剩下多少份int leftMoney = totalMoney;int leftCount = totaCount;// 隨機發前n-1個，最后一個不需要隨機for (int i = 0; i < totaCount - 1; i++) {// 按照公式生成隨機金額int money = r.nextInt(leftMoney / leftCount * 2) + 1;list.add(money);    // 講一個隨機紅包放入集合leftMoney -= money; // 剩下的金額越發越少leftCount--;        // 剩下還應該再發的紅包個數，遞減}// 最后一個紅包不需要隨機，直接賦值即可list.add(leftMoney);return list;}
}

public class Bootstrap {public static void main(String[] args) {MyRed red = new MyRed("發紅包");// 設置群主名稱red.setOwnerName("tom");// 普通紅包
//        OpenMode normal = new NormalMode();
//        red.setOpenWay(normal);// 手氣紅包OpenMode random = new RandomMode();red.setOpenWay(random);}
}

紅包頁面

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.HashMap;/*** 紅包的框架 RedPacketFrame** AWT / Swing / JavaFX** @author 不是我*/
public abstract class RedPacketFrame extends JFrame {private static final long serialVersionUID = 1L;private static final String DIR = ".\\pic";private ArrayList<Integer> moneyList = null;private static int initMoney = 0;private static int totalMoney = 0; // 單位為“分”private static int count = 0;private static HashMap<JPanel, JLabel> panelLable = new HashMap<>();// 設置字體private static Font fontYaHei = new Font("微軟雅黑", Font.BOLD, 20);private static Font msgFont = new Font("微軟雅黑", Font.BOLD, 20);private static Font totalShowFont = new Font("微軟雅黑", Font.BOLD, 40);private static Font nameFont = new Font("微軟雅黑", Font.BOLD, 40);private static Font showNameFont = new Font("微軟雅黑", Font.BOLD, 20);private static Font showMoneyFont = new Font("微軟雅黑", Font.BOLD, 50);private static Font showResultFont = new Font("微軟雅黑", Font.BOLD, 15);/*** 窗體大小 WIDTH:400 HEIGHT:600*/private static final int FRAME_WIDTH = 416; // 靜態全局窗口大小private static final int FRAME_HEIGHT = 650;private static JLayeredPane layeredPane = null;/// private static JPanel contentPane = null;/*** page1:輸入頁面 - InputPanel . 組件和初始化!*/private static JPanel inputPanel = new JPanel();// private static JTextField input_total = new JTextField("200"); // 測試用// private static JTextField input_count = new JTextField("3"); // 測試用private static JTextField input_total = new JTextField();private static JTextField input_count = new JTextField();private static JTextField input_people = new JTextField("30");private static JTextField input_msg = new JTextField("恭喜發財  ,  大吉大利");private static JTextField input_total_show = new JTextField("$ " + input_total.getText().trim());private static JLabel input_inMoney = new JLabel(); // 不可見private static JLabel input_bg_label = new JLabel(new ImageIcon(DIR + "\\01_input.jpg"));static {// 設置位置input_total.setBounds(200, 90, 150, 50);input_count.setBounds(200, 215, 150, 50);input_people.setBounds(90, 275, 25, 30);input_msg.setBounds(180, 340, 200, 50);input_total_show.setBounds(130, 430, 200, 80);input_inMoney.setBounds(10, 535, 380, 65);input_bg_label.setBounds(0, 0, 400, 600); // 背景// 設置字體input_total.setFont(fontYaHei);input_count.setFont(fontYaHei);input_people.setFont(fontYaHei);input_msg.setFont(msgFont);input_msg.setForeground(new Color(255, 233, 38)); // 字體顏色 為金色input_total_show.setFont(totalShowFont);input_inMoney.setFont(fontYaHei);// 透明input_people.setOpaque(false);input_total_show.setOpaque(false);// 編 輯 -- 不可編輯input_people.setEditable(false);input_total_show.setEditable(false);// 邊界 -- 無input_total.setBorder(null);input_count.setBorder(null);input_people.setBorder(null);input_msg.setBorder(null);input_total_show.setBorder(null);}/*** page2:打開頁面 - openPanel . 組件和初始化!*/private static JPanel openPanel = new JPanel();private static JTextField open_ownerName = new JTextField("誰誰誰");private static JLabel open_label = new JLabel(new ImageIcon(DIR + "\\02_open_2.gif"));private static JLabel open_bg_label = new JLabel(new ImageIcon(DIR + "\\02_open_1.jpg"));static {// 設置 位置.open_ownerName.setBounds(0, 110, 400, 50);open_bg_label.setBounds(0, 0, 400, 620);open_label.setBounds(102, 280, 200, 200);open_ownerName.setHorizontalAlignment(JTextField.CENTER);// 設置字體open_ownerName.setFont(nameFont);open_ownerName.setForeground(new Color(255, 200, 163)); // 字體顏色 為金色// 背景色// open_name.setOpaque(false);open_ownerName.setBackground(new Color(219, 90, 68));// 不可編輯open_ownerName.setEditable(false);// 邊框open_ownerName.setBorder(null);}/*** page3:展示頁面 - showPanel . 組件和初始化!*/private static JPanel showPanel = new JPanel();private static JPanel showPanel2 = new JPanel();private static JScrollPane show_jsp = new JScrollPane(showPanel2);private static JLabel show_bg_label = new JLabel(new ImageIcon(DIR + "\\03_money_1.jpg"));private static JTextField show_name = new JTextField("用戶名稱");private static JTextField show_msg = new JTextField("祝福信息");private static JTextField show_money = new JTextField("99.99");private static JTextField show_result = new JTextField(count + "個紅包共" + (totalMoney / 100.0) + "元,被搶光了");static {// 分別設置水平和垂直滾動條自動出現// jsp.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);// jsp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);/** 兩部分 頁面 . 1.本人獲得的紅包-- showPanel 2.別人獲得的紅包-- show_jsp*/show_name.setBounds(125, 180, 100, 30);show_name.setOpaque(false);show_name.setBorder(null);show_name.setFont(showNameFont);show_msg.setBounds(0, 220, 400, 30);show_msg.setOpaque(false);show_msg.setBorder(null);show_msg.setFont(msgFont);show_msg.setHorizontalAlignment(JTextField.CENTER);show_money.setBounds(0, 270, 250, 40);show_money.setOpaque(false);show_money.setBorder(null);show_money.setFont(showMoneyFont);show_money.setForeground(new Color(255, 233, 38)); // 字體顏色 為金色show_money.setHorizontalAlignment(SwingConstants.RIGHT);show_result.setBounds(10, 460, 400, 20);show_result.setOpaque(false);show_result.setBorder(null);show_result.setFont(showResultFont);show_result.setForeground(new Color(170, 170, 170)); // 字體顏色 為灰色// 設置 圖片.show_bg_label.setBounds(0, 0, 400, 500);}static {// 頁面和 背景的對應關系.panelLable.put(inputPanel, input_bg_label);panelLable.put(openPanel, open_bg_label);panelLable.put(showPanel, show_bg_label);}private void init() {// 層次面板-- 用于設置背景layeredPane = this.getLayeredPane();
//        System.out.println("層次面板||" + layeredPane);// System.out.println(layeredPane);// 初始化框架 -- logo 和基本設置initFrame();// 初始化 三個頁面 -- 準備頁面initPanel();// 2.添加 頁面 --第一個頁面, 輸入 panel 設置到 頁面上.setPanel(inputPanel);// 3.添加 監聽addListener();}/*** 初始化框架 -- logo 和基本設置*/private void initFrame() {// logothis.setIconImage(Toolkit.getDefaultToolkit().getImage(DIR + "\\logo.gif"));
//        System.out.println("LOGO初始化...");// 窗口設置this.setSize(FRAME_WIDTH, FRAME_HEIGHT); // 設置界面大小this.setLocation(280, 30); // 設置界面出現的位置this.setDefaultCloseOperation(EXIT_ON_CLOSE);this.setLayout(null);// 測試期 注釋 拖 拽 , 運行放開// this.setResizable(false);this.setVisible(true);}/*** 初始化頁面-- 準備三個頁面*/private void initPanel() {
//        System.out.println("頁面初始化...");initInputPanel();initOpenPanel();initShowPanel();}private void initInputPanel() {inputPanel.setLayout(null);inputPanel.setBounds(0, -5, 400, 600);// this.add(bg_label);inputPanel.add(input_total);inputPanel.add(input_count);inputPanel.add(input_people);inputPanel.add(input_msg);inputPanel.add(input_total_show);inputPanel.add(input_inMoney);//        System.out.println("輸入頁面||" + inputPanel);}private void initOpenPanel() {openPanel.setLayout(null);openPanel.setBounds(0, 0, 400, 600);// this.add(bg_label);openPanel.add(open_ownerName);openPanel.add(open_label);
//        System.out.println("打開頁面||" + openPanel);}private void initShowPanel() {showPanel.setLayout(null);showPanel.setBounds(10, 10, 300, 600);// ==============showPanel.add(show_name);showPanel.add(show_msg);showPanel.add(show_money);showPanel.add(show_result);
//        System.out.println("展示頁面||" + showPanel);// ====================================// showPanel2.setLayout(null);// showPanel2.setBounds(0, 500, 401, 300);showPanel2.setPreferredSize(new Dimension(300, 1000));showPanel2.setBackground(Color.white);show_jsp.setBounds(0, 500, 400, 110);}/*** 每次打開頁面, 設置 panel的方法*/private void setPanel(JPanel panel) {// 移除當前頁面layeredPane.removeAll();//        System.out.println("重新設置:新頁面");// 背景lable添加到layeredPane的默認層layeredPane.add(panelLable.get(panel), JLayeredPane.DEFAULT_LAYER);// 面板panel設置為透明panel.setOpaque(false);// 面板panel 添加到 layeredPane的modal層layeredPane.add(panel, JLayeredPane.MODAL_LAYER);}// private void setShowPanel(JPanel show) {// setPanel(show);// layeredPane.add(show_jsp, JLayeredPane.MODAL_LAYER);//// }/*** 設置組件的監聽器*/private void addListener() {input_total.addKeyListener(new KeyAdapter() {@Overridepublic void keyReleased(KeyEvent e) {// System.out.println(e);String input_total_money = input_total.getText();input_total_show.setText("$ " + input_total_money);}});input_count.addKeyListener(new KeyAdapter() {@Overridepublic void keyReleased(KeyEvent e) {// System.out.println(e);
//                System.out.println("個數:" + input_count.getText());}});input_msg.addKeyListener(new KeyAdapter() {@Overridepublic void keyReleased(KeyEvent e) {// System.out.println(e);
//                System.out.println("留言:" + input_msg.getText());}});input_inMoney.addMouseListener(new MouseAdapter() {@Overridepublic void mouseClicked(MouseEvent e) {try {// 獲取頁面的值.totalMoney = (int) (Double.parseDouble(input_total.getText()) * 100); // 轉換成"分"count = Integer.parseInt(input_count.getText());if (count > 30) {JOptionPane.showMessageDialog(null, "紅包個數不得超過30個", "紅包個數有誤", JOptionPane.INFORMATION_MESSAGE);return;}initMoney = totalMoney;System.out.println("總金額：[" + totalMoney + "]分");System.out.println("紅包個數：[" + count + "]個");input_inMoney.removeMouseListener(this);//                    System.out.println("跳轉-->打開新頁面");// 設置群主名稱open_ownerName.setText(ownerName);// 設置打開頁面setPanel(openPanel);} catch (Exception e2) {JOptionPane.showMessageDialog(null, "請輸入正確【總金額】或【紅包個數】", "輸入信息有誤", JOptionPane.ERROR_MESSAGE);}}});// open_ownerName ,點擊 [名稱],觸發的方法 , 提示如何設置群主名稱.open_ownerName.addMouseListener(new MouseAdapter() {@Overridepublic void mouseClicked(MouseEvent arg0) {JOptionPane.showMessageDialog(null, "請通過【setOwnerName】方法設置群主名稱", "群主名稱未設置",JOptionPane.QUESTION_MESSAGE);}});// open label , 點擊 [開],觸發的方法,提示如何設置打開方式.open_label.addMouseListener(new MouseAdapter() {@Overridepublic void mouseClicked(MouseEvent e) {if (openWay == null) {JOptionPane.showMessageDialog(null, "請通過【setOpenWay】方法設置打開方式", "打開方式未設置",JOptionPane.QUESTION_MESSAGE);return;}//                System.out.println("跳轉-->展示頁面");moneyList = openWay.divide(totalMoney, count);//                System.out.println(moneyList);/** showPanel 添加數據**/show_name.setText(ownerName);show_msg.setText(input_msg.getText());if (moneyList.size() > 0) {show_money.setText(moneyList.get(moneyList.size() - 1) / 100.0 + "");}show_result.setText(count + "個紅包共" + (initMoney / 100.0) + "元,被搶光了");open_label.removeMouseListener(this);setPanel(showPanel);// 添加數據for (int i = 0; i < moneyList.size(); i++) {JTextField tf = new JTextField();tf.setBorder(null);tf.setFont(showNameFont);tf.setHorizontalAlignment(JTextField.LEFT);if (i == moneyList.size() - 1) {tf.setText(ownerName + "：\t" + moneyList.get(i) / 100.0 + "元");} else {tf.setText("群成員-" + i + "：\t" + moneyList.get(i) / 100.0 + "元");}showPanel2.add(tf);}layeredPane.add(show_jsp, JLayeredPane.MODAL_LAYER);}});}/* ======================================================================* *********************************************************************** * 以上代碼均為頁面部分處理,包括布局/互動/跳轉/顯示等,大家                   ** *                                                   ** *                                                   ** *********************************************************************** ======================================================================*//*** ownerName : 群主名稱*/private String ownerName = "誰誰誰"; // 群主名稱/*** openWay : 紅包的類型 [普通紅包/手氣紅包]*/private OpenMode openWay = null;/*** 構造方法：生成紅包界面。** @param title 界面的標題*/public RedPacketFrame(String title) {super(title);// 頁面相關的初始化init();}public void setOwnerName(String ownerName) {this.ownerName = ownerName;}public void setOpenWay(OpenMode openWay) {this.openWay = openWay;}}

總結

以上是生活随笔為你收集整理的Java 基础学习记录的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

JAVA
基础

上一篇： 001.网络TCP/IP工程知识点
下一篇： MySQL 高可用架构在业务层面细化分析

Java 基础学习记录

Java 基礎

DAY1

1、關于進制的運算

2、關于存儲單元

3、關于CMD的基本命令

4、JRE與JDK

5、Java環境變量

6、程序開發步驟

7、HelloWorld

8、標識符

9、常量

10、數據類型

數據類型分類

基本數據類型

注意事項：

11、變量

DAY2

1、數據類型轉換

自動類型轉換（隱式）

強制類型轉換（顯式）

2、ASCII編碼表

3、算術運算符

四則運算當中的加號“+”有常見的三種用法：

4、自增自減運算符

5、賦值運算符

6、比較運算符

7、邏輯運算符

8、三元運算符

9、方法定義與調用

10、編譯器的兩點優化

1、自動添加隱含類型

2、常量優化

DAY3

1、ifelse語句

2、ifelseifelse語句

3、ifelse練習

4、使用if語句替換三元運算符

5、switch

6、循環結構

7、 求出1-100之間的偶數和

8、三種循環的區別

9、break

10、continue

11、死循環

12、嵌套循環

DAY4

1、IDEA

psvm

sout

常用設置

代碼模板

2、項目結構

3、IDEA常用快捷鍵

4、復習一下嵌套循環

5、方法的定義與調用

6、有參與無參

7、練習題1

8、練習題2

9、練習題3

10、練習題4

11、使用方法的注意事項

12、方法的重載

13、重載練習一

14、重載練習二

15、重載練習三

DAY5

1、數組的概念

2、動態初始化與靜態初始化

3、靜態初始化（省略格式）

4、訪問數組元素（獲取）

5、訪問數組元素（賦值）

6、內存的劃分

7、一個數組的內存圖

8、兩個數組的內存圖

9、兩個數組指向同一個地址值的內存圖

10、數組索引越界異常

11、空指針異常

12、獲取數組的長度

13、數組遍歷輸出

7、求出1-100之間的偶數和

2、Scanner類鍵盤輸入

3、Scanner練習一鍵盤輸入兩個數字求和

4、Scanner練習二鍵盤輸入三個數字求最大值

9、Random練習一生成1-n之間的隨機數

10、Random練習二猜數字小游戲

11、Random練習二猜數字小游戲（題目變形）

17、ArrayList練習一存儲隨機數字

18、ArrayList練習二存儲自定義對象

19、ArrayList練習三按指定格式遍歷集合字符串

20、ArrayList練習四篩選集合中的隨機數