記錄個人在網上看視頻寫下來的筆記，視頻一個400多個（平均一個視頻6分鐘），這裡大概是100個多些的視頻所做的筆記，這只是入門筆記的1/4，練習的代碼就不放了，太多了，又零散。
1.關鍵字：全小寫，顏色會顯示不一樣（大概50個）
2.常量概述：
字符串常量：括號括起來的內容（"helloworld"）
整數常量：2，1，3
小數常量：1.111
字符常量：A,B,C
布爾常量：0/1
空常量:不能直接輸出
3.數據類型： - 整數（byte,short,long）
數值型：|- 浮點型（float，double）
| - 字符（char）
(1).基本數類型：
|
非數值型：-布爾（boolean）
|-類（class）
(2).引用數據類型: |-接口（interface）
|-數組（[]）
3.2數類型的佔用內存：
整數：byte（1）[取值範圍：-128~127]，short(2)【-32768~32767】,int(4)【-2的31次方~2的31次方-1】,long(8)
浮點型：float（4），double（8）
字符：char（2）
布爾：boolean（1）
4.變量：在程序運行過程中，值可變的
格式：數類型 變量名=變量值
示例：int a=100;
注意事項：定義long類型的變量，數值後需要加L,如long l=10000000L
定義浮點型：float型，防止不兼容，需加F，如float f=3.14F
5.標識符：給類，方法，變量等起名的符號
定義規則：
由數字，字母，下劃線_和美元符號組成
不能以數字開頭
不能是關鍵字
區分大小寫
命名約定：
針對方法，變量：
標識符是一個單詞時，首字母小寫。標識符是多個單詞組成時，首字母小寫，其他單詞首字母大寫
針對類：
首字母大寫，每個單詞首字母大寫
6.類型轉換：1.自動類型轉換 2.強制類型轉換
自動類型轉換：將一個表示範圍小的數字或變量賦值給另一個大的；如：double d=10--->int a=d或float n=d；
強制類型轉換：講一個表示範圍大的數字或變量賦值給另一個大的：如：int k=(int)3.14
強制類型轉換會有數值丟失，如3.14會變3
7.運算符：對常量或變量進行操作的符號
+（加），-（減），*（成），/（除），%（取餘）等，有運算符的表達式稱算術表達式
數值不能與boolean值運算，整數相除只能得整數，需要浮點數則需要有浮點數相除
7.2 字符參與運算時，會將字符對應的數值參與運算
如 char a='A';int i=10; a+i=75,因為A的數值為65
A-Z是連續的，A=65，B=66
a-z；a=97，b=98
0-9；48.（零到九）
·算術表達式中包含多個基本數據類型的值，整個算術表達式的類型會自動提升
·提升到表達式中最高等級的操作數相同的類型
提升規則：byte,short,char-->int-->long-->flort-->double
8.字符串的+操作
字符串+字符串：將字符串拼接起來 如：「abc」+"hjk"="abchjk"
字符串+數值：將字符串和數值拼接， 如：「bab」+989=bab989
數值+數值+字符串：如:12+1+"ads"=13ads,多個運算符是從左到右運算
9.賦值運算符：
符號 作用：
= 賦值
+= 加後賦值
-= 減後賦值
*= 乘後賦值
/= 除後賦值
%= 取餘後賦值
10.自增自減運算符：
符號： 作用：
++ 自增
-- 自減
可放變量前或後都可以，當非單獨使用時，++放前面則++先參與運算，放後面則後參與運算
11.關係運算符：
符號： 說明：
== 判斷是否相等，否為false
！= 判斷是否不相等
> 判斷是否大於
< 判斷是否小於
>= 判斷是否大於等於
<= 判斷是否小於等於
結果必然是true或false
12.邏輯運算符：用來連接關係表達式的運算符，也可以直接連接boolean和常量或變量
符號： 作用：
& 與
| 或
^ 異或（當連接的兩個判斷結果不一樣，則為ture）
！ 非
如：x>3和x<6 ---> x>3&x<6
異或：如 int i=10；int a=3；int j=23；
i>a^a>i--->為ture
i>a^a<i--->為false
13.短路邏輯運算符：
符號： 作用：
&& 短路與
|| 短路或
·作用於基本的&和|基本相同
·但&，|是無論左邊是真假，右邊都執行
·||，&&一旦左邊為False，則右邊不會執行
14.三元運算符：
格式：關係表達式？表達式1：表達式2;
如：a>b?a:b
計算規則：
首先計算關係表達式的值
如果為ture,表達式1的值就是運算結果
如果為false，表達式2的值為運算結果
15.數據輸入：
Scanner的使用步驟：1.導包 2.創建對象 3.接收數據
導包：import java.util.Scanner;【必須出現在類定義上邊】
創建對象：Scanner sc=new Scanner(System.in);[只有sc是變量名]
接收數據：int i=sc.nextInt();[只有i是變量名，其他不許變]
16.流程控制語句概述：
·順序結構
按代碼的順序運行（從上往下開始）
·分支結構(if,switch)
if格式：
if(關係表達式){
語句主體;
}
if..else格式：
if(關係表達式){
語句主體1;
}else{
語句主體2;
}
if..else if...else格式：
if(關係表達式1){
語句主體1;
}else if(關係表達式2){
語句主體2;
}...（關係表達式N）{
語句主體N;
}else{
語句主體N+1;
}
先計算關係表達式的值
如果為ture則執行語句主體
如果為false則不執行語句主體
switch語句：
格式：
switch(表達式){
case 值1：
語句體1;
break;
case 值2:
語句體2;
break;
default:
語句體n+1;
[break;]
}
1.首先計算表達式的值
2.依次和case後面的值進行比較，如果有對應的值則執行相應語句體，遇到beark會結束
3.如果值與case的值都不匹配，則執行default後面的語句體，然後結束程序
注意：不寫break是會有穿透現象出現（會繼續執行下去）
**·循環結構（for,while,do....while）**
for 循環格式：
for (1.初始化語句;2.條件判斷語句;3.條件控制語句){
循環體語句;
}
流程：
1.執行初始化語句
2.執行條件判斷語句，為false結束循環，為ture繼續執行
3.執行循環體語句
4.執行條件控制語句
5.回到2中繼續循環
while循環格式：
基本格式：
while(條件判斷語句){
循環體語句;
}
完整格式：
初始化語句;
while(條件判斷語句){
循環體語句;
條件控制語句;
}
流程：
1.執行初始化語句
2.執行條件判斷語句，為true繼續，為false循環結束
3.執行循環體語句
4.執行條件控制語句
5.執行步驟2
do...while循環語句格式：
基本格式：
do{
循環體語句;
}while(條件判斷語句);
完整格式：
初始化語句：
do{
循環體語句;
條件控制語句;
}while(條件判斷語句);
流程：
1.執行初始化語句
2.執行循環體語句
3.執行條件控制語句
4.執行條件判斷語句，為true繼續執行，為false結束循環
5.回到2繼續
**三種循環的區別：**
for和while循環先判斷後執行，do....while是先執行後循環
**for與while的區別：**
條件控制語句在for循環的語法結構中，在for循環結束後不能再次被訪問
條件控制語句在while中是屬於自增的變量，while循環結束後能繼續被訪問
死循環：
for(;;){}
while(ture){}
do{}while(ture)
17.跳轉控制語句：
跳轉控制語句概述：
continue:用在循環中，基於條件控制，跳過某次循環體內容執行，繼續下一次的循環
break:用在循環中，基於條件控制，終止循環體內容的執行，意味著結束循環
18.循環嵌套：
任何語句對外都可看成是一句話，一句代碼分支語句中包含分支語句稱為*分支嵌套，就是說if中套if*
*循環中套循環稱循環嵌套*
19.**Random:用於產生一個隨機數**
使用步驟：
1.導包：import java.util.Random;
2.創建對象：Random r=new Random();
3.獲取隨機數：int number=r.nextInt(10);//獲取數的範圍：[0,10),包括0，不包括10
20.IDEA概述和安裝:
地址：https://www.jetbrains.com/idea
快速生成語句：
psvm：生成main語句：
public static void main(String[] args) {
}
sout：生成輸出語句：
System.out.println();
內容輔助鍵：
ctrl+alt+space(內容提示，代碼補全)
快捷鍵：
ctrl+/注釋
ctrl+shift+/取消注釋
格式化：ctrl+Alt+L
21.數組：用於存儲多個同類型的數據的存儲模型
定義格式：
格式一：數據類型[] 變量名
如： int[] arr
定義了一個int類型的數組，名為arr
格式二：數據類型 變量名[]
如： int arr[]
定義了一個int類型的變量，變量名為arr的數組
21.1數組的初始化：動態初始化，靜態初始化
**動態初始化：初始化時只指定數組長度，由系統為數組分配初始值**
格式：數據類型[] 變量名=new 數據類型[數組長度]
如： int[] arr=new int[3]
左邊：
int:數組的元素類型是int類型
[]:說明這是個數組
arr:數組名稱
右邊：
new:為數組申請內存空間
int:數組中的元素類型是int類型
[]:說明是個數組
3:數組裡的元素個數為3
21.2數組的訪問：數組名稱【索引】
21.3內存分配：int[] arr=new int[3];
數組在初始化時，會默認給存儲空間添加默認值
·整數：默認值為0
·浮點數：默認值為0.0
·布爾值：默認值為false
·字符：默認值為空字符
·引用數據類型：默認為Null
||
||
\||/
\/
先運行右邊的那部分，並給上地址名（直接輸出數組名可看到地址），
索引和初始值，然後賦值給左邊的變量名【左邊的稱為：棧內存，右邊稱為：堆內存】
棧內存：存儲局部變量，定義在方法中的變量，如|arr，使用完畢就會消失
堆內存：存儲new出來的內容，每個new出來的東西都有一個地址值，使用完畢會被回收
**如果將一個數組賦值給另一個數組，則兩個數組的指定位置是相同的，其中一個數組將值改變，另一個**數組的值也會改變
**靜態初始化：初始化時指定每個數組元素的初始值，由系統決定長度**
格式：數據類型[] 變量名=new 數據類型[]{數據1，數據2，數據3};
簡化格式：數據類型[] 變量名={數據1，數據2，數據3};
如： int[] arr=new int[]{1,2,3,4,5}/則數組長度為5
如： int[] arr={1,2,3,4,5}
21.4:數組操作的小問題：
1.索引越界：訪問數組中不存在的索引對應的元素，造成索引越界問題
ArrayIndexOutOfBoundsException
2.空指針異常：訪問的數組已經不再指向堆內存的數據，造成空指針異常
NullPointerException【有空值】
3.Null:空值，引用數據類型的默認值，表示不指向任何有效的對象
21.5數組的常見操作：
·遍歷【就是循環數組】
·獲取數組元素數量：格式：數組名.length，如：arr.length
·獲取最值【最大值，最小值】
思路：創建一個變量，存儲數組第一個值，然後遍歷數組進行比較，儲存大的值或小的值，循環結束後便可獲取最值
22.**方法**：
方法：是將具有獨立功能代碼塊組織成為一個整體，使其具有特殊功能代碼集
注意：方法必須先創建才可以使用，該過程稱為定義，創建後的執行稱為調用
格式：public static void 方法名(){
方法體;
}
如：public static void isevennumber(){
int a=10;
if(a%2==0){
System.out.println(true);
}else {
System.out.println(false);
}
}
調用：在public static void main(String[] args)中調用，如：
public static void main(String[] args) {
isevennumber();//方法
}
**帶參數的方法定義和調用：**
格式：public static void 方法名(參數){}
public static void 方法名(數據類型 變量名){}
多個參數格式：public static void 方法名(參數1，參數2，參數3....){}
public static void 方法名(數據類型 變量名1，數據類型 變量名2，數據類型 變量名3....){}
如：public static void 方法名(int a){}
public static void 方法名(int a1,int a2,int a3){}
注意：數據類型和變量名不可缺少，變量之間用(,)隔開
調用：格式：方法名（參數）;
單個參數：方法名（變量名/常量值）;
isEvenNumber(5);
多個參數：方法名（變量名1/常量值1，變量名2/常量值2,...）;
isEvenNumber(5,6....);
*形參和實參*
形參：方法定義中的參數（方法名（int i））
實參：方法調用中的參數(在main中引用是的參數，如：方法名（5）,int i=5;)
*帶返回值的定義和調用*
·帶返回值方法定義：
格式：public static 數據類型 方法名（參數）{
return 數據;
}
如：public static boolean isEvenNumber(int number){
return true;
}
public static int isEvenNumber(int a,int b){
return 100;
}
注意：返回值需要與方法定義上的數據類型匹配
*帶返回值的方法調用：*
格式1：方法名（參數）;
isEvenNumber(5);
格式2：數據類型 變量名=方法名（參數）;
boolean flag=isEvenNumber(5);
#注意，一般用變量接收返回值，否則無意義
#void表示無返回值
#方法與方法不能嵌套使用
*方法通用格式*
格式：
public static 返回值類型 方法名（參數）{
方法體;
return 數據;
}
·public static >修飾符
·返回值類型 >如果寫void則表示無返回值，一般不寫return。
·方法名 ->調用方法時使用的標識
·參數 --->由數據和變量名組成，多個參數逗號隔開
·方法體---->完成功能的代碼塊
·return---->方法操作完畢後，有數據返回，則將數據返回給調用者
*方法重載概述*
概述：同一個類中定義的多個方法之間的關係
1.多個方法在同一個類中
2.多個方法具有相同的方法名
3.多個方法的參數不同，類型不同或者數量不同
#與返回值無關，調用時java虛擬機會通過參數的不同來區分
*方法參數傳遞*
方法參數傳遞（基本類型）
syso（）是輸出的縮寫方式
public static void main(String[] args) {
int number=100;
System.out.println(number);#輸出為100
change(number);
System.out.println(number);#輸出為100
}
public static void change(int number){
number=200;
}#兩個的輸出結果都是100
#注意：對於基本數據類型的參數，形式參數的改變不影響實際參數的值
#即方法中定義的參數不會實際影響不是那個方法中定義的參數
#對於引用類型的參數，形式參數的改變會影響實際參數的改變，如：數組類的 int[] arr定義於方法中，在方法中改變值，實際值會改變
public static void main(String[] args) {
int arr={1,2,3};
System.out.println(arr[1]);#輸出為2
change(number);
System.out.println(arr[1]);#輸出為200
}
public static void change(int[] arr){
arr[1]=200;
System.out.println("內容");/輸出並換行
System.out.print("內容");/不換行輸出
**Debug**
概述：dehug是提供程序調試的工具，用於查看程序的執行流程，也可以用於追蹤程序執行過程來調試程序
debug調試，又稱斷點調試：
1.如何加斷點
在窗口左邊點左鍵
2.如何運行加了斷點的程序：
點擊debug運行
3.看哪裡：
看debug窗口
4.點哪裡
5.如何刪除斷點
在標記地方點左鍵
**類和對象**
面向對象：關注的信息，功能等（面向一個具體的東西工作）
類：具有共同屬性和行為的事物的抽象
類的特點：
·是對象的數據類型
·具有相同屬性和行為的一組對象的集合
對象的屬性：對象具有的各種特徵，每個對象的每個屬性都擁有特定的值，如（品牌【屬性】：小米【值】）
對象的行為：對象能執行的操作
類和對象的關係：
類·對現實生活中一類具有共同屬性和行為的事物的抽象
對象·能夠看得到摸得到的真實存在的實體
*類的定義*
類的組成：屬性，行為
屬性：在類中通過成員變量來體現（類中方法外的變量）
行為：通過成員方法來體現
類的定義步驟：
1.定義類：public class 類名{
2.編寫類的成員變量：數據類型 變量1;
數據類型 變量2;
.
3.編寫類的方法： 方法1;
方法2;
.
}
如：
1.定義類 public class Phone {
2.成員變量 String brand;
int price;
3.成員方法 public void call(){
System.out.println("打電話");
}
public void sendMessage(){
System.out.println("發簡訊");
}
}
*類和對象：*
創建對象：類名 對象名=new 類名();
如：Phone p=new Phone();
使用對象：
1.使用成員變量：
格式：對象名.變量名
如：p.brand
2.使用成員方法
格式：對象名.方法名
如：p.call（）
*對象內存圖*
分別有棧內存和堆內存；
棧內存：用來執行方法之類的，執行完畢就會消失（就是暫時的內存）
堆內存：一直都會在的，就算棧內存的方法執行完了也不會消失
#注意：在調用類時，改變了變量的值並不會影響到類中定義的變量值
#student s1=new student();
#student s2=new student();
#這兩個變量引用的地址是不一樣的，所以s1中改變了變量值不會影響到s2
#student s1=new student();
#student s2=s1;
#這兩引用的地址是一樣的，所以s1改變了變量值會影響到s2
*成員變量，局部變量*
成員變量：類中方法外的，堆內存，有默認初始值
局部變量：方法內或方法聲明上，棧內存，無默認初始值（必須賦值才能使用）
*封裝*
private關鍵字：
·權限修飾符
·可修飾成員（成員變量，成員方法）
·作用：保護成員不被別的類使用，被private修飾的成員只能在本類中才能訪問
#如果需要被其他類使用，則需提供相關操作；
·提供「get變量名（）」方法，用於獲取成員變量的值，方法用public修飾
·提供「set變量名（參數）」方法，用於設置成員變量的值，方法用public修飾
使用了private關鍵詞後：
更改變量值 public int setAge(int ag){
if(ag<0|ag>120){
System.out.println(".");
}else {
age=ag;
}
return age;
}
獲取變量值
public int getAge(){
return age;
}
調用：
student st=new student();
st.setAge(30);
st.setName("卡夫卡");
System.out.println(st.getAge()+"."+st.getName());
st.show();
*this關鍵字*
作用：在方法中調用成員變量（當局部變量和成員變量同名時）
使用方法：this.變量名
*封裝*
概述：
·是面向對象三大特徵之一（封裝，繼承，多態）
·是面向對象程式語言對客觀世界的模擬，客觀世界裡成員變量都是隱藏在對象內部的，外部是無法直接操作
原理：
將類的某些信息隱藏在類的內部，不允許外部程序直接訪問，而是通過該類提供的方法來實現對隱藏信息的操作和訪問
成員變量private，提供對應的getXxx()、setXxx()方法
好處：
·提高代碼安全性
·提高代碼復用性
*構造方法*
作用：創建對象
格式：
public class 類名{
修飾符 類名（參數）{
}
}
功能：主要完成對象數據的初始化
#一般在類中使用：
public student(){};
public student(String name,int age){
this.name=name;
this.age=age;
}
引用時如果是帶參數的構造方法，則需要傳入參數
*標準類製作*
1.成員變量
·使用private修飾
2.構造方法
·提供一個無參構造
·提供一個帶多個參數的構造方法
3.成員方法
·提供每一個成員變量對應的srtXxx()/getXxx()
·提供一個顯示對象信息show()
4.創建對象並為其成員變量賦值的兩種方式
·無參構造方法創建對象後用setXxx()賦值
·使用帶參構造方法直接創建帶有屬性值的對象
*API(Application Programming Interface)概述*
api：應用程式編程接口
java api:指的就是JDK中提供各種功能的java類，這些類將底層的實現封裝起來，在幫助文檔中學習使用
String 構造方法：
public String() 創建一個空白字符串對象，不含任何內容
public String(char[] chs) 根據字符數組的內容，來創建字符串對象
public String(byte[] bys)根據字節數組內容，來創建字符串對象
String s="abc" 直接賦值的方式創建字符串對象，內容就是abc
如：
String s1=new String();
char[] chs={"a","b","c","d"}；
String s2=new String(chs);#則s2被賦值為abcd
byte[] bys={97,98,99,100};
String s3=new String(bys);#因為對應為abcd,所以也是賦值為abcd
String對象的特點：
·用new創建的字符對象，地址是不一樣的
·以""方式給出的字符串，都一樣的
字符串的比較：比較字符串是否相同
equals（）
public boolean equals(obect1,obect2);
使用：object1.equals(object2);
遍歷字符串：.length（）,獲取長度
public char charAt（int index）:返回指定索引處的char值
如：String line=sc.nextline();
line.charAt(索引)/獲得指定索引的字符