常見的基礎內容：
Java 的命名規范：
Java是大小寫敏感的，這就意味着標識符Hello與hello是不同的
java的變量命名規范：首字母：英文字母、$和下划線。變量名：由$、字母、數字和下划線組成。
類名：單個單詞，首字母大寫，多個單詞，首字母都大寫。
方法名、參數名、變量名：單個單詞，首字母小寫，多個單詞，第一單詞首字母小寫，其他單詞首字母大寫。
包名：全部小寫。
java的修飾符：
非訪問控制修飾符 : final, abstract, static, synchronized
訪問控制修飾符 : default, public , protected, private
java語言的變量類型：【全局變量是有默認值的，int類型默認值為0，string類型默認為null，局部變量必須要進行初始化】
1、類變量：獨立與方法之外的變量，用static進行修飾
2、實例變量：獨立於方法之外的變量，不過沒有static進行修飾
3、局部變量：類的方法中的變量，局部變量必須要進行初始化
public class Variable{
static int allClicks=0; // 類變量 ，全局變量
String str="hello world"; // 實例變量
public void method(){
int i =0; // 局部變量
}
}
java枚舉:【枚舉可以單獨聲明或者聲明在類里面。方法、變量、構造函數也可以在枚舉中定義。使用枚舉可以減少代碼中的 bug。】
class FreshJuice {
enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }
FreshJuiceSize size;
}
public class FreshJuiceTest {
public static void main(String []args){
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
}
}
Java的do，while循環【首先就是會進行do里面的內容的執行，然后在判斷while的內容是不是符合規定，如果里面的條件是符合規定的，再次執行do里面的內容，直到不滿足條件】
public class StringBase {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
do {
System.out.println(a);
a++;
}
while (a<=10);
System.out.println("結束");
}
}
while循環就是判斷是不是滿足while里面的內容，如果滿足的執行while里面的循環體，如果不滿足，就直接跳出
public class StringBase {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int a=sc.nextInt();
while (a<=10){
System.out.println(a);
a++;
}
System.out.println("結束");
}
}
instanceof（實例）【instanceof 嚴格來說是Java中的一個雙目運算符，用來測試一個對象是否為一個類的實例，用法為：】
boolean result = obj instanceof Class
其中 obj 為一個對象，Class 表示一個類或者一個接口，當 obj 為 Class 的對象，或者是其直接或間接子類，或者是其接口的實現類，結果result 都返回 true，否則返回false。
throw和throws的區別
1、throws出現在方法函數頭；而throw出現在函數體。
2、throws表示出現異常的一種可能性，並不一定會發生這些異常；throw則是拋出了異常，執行throw則一定拋出了某種異常。
3、兩者都是消極處理異常的方式（這里的消極並不是說這種方式不好），只是拋出或者可能拋出異常，但是不會由函數去處理異常，真正的處理異常由函數的上層調用處理。
Java虛擬機
java虛擬機實際上只是一層接口，一層Java程序和操作系統通訊的接口。java文件編譯生成class文件，
而java虛擬機就是這些class文件能夠在上面運行的一個平台，你把class文件看成一個軟件，java虛擬機就是這個軟件可以運行的操作系統。
解釋運行字節碼程序（Java程序編譯后產生）、消除平台差異性
使用Java虛擬機是實現這一特點的關鍵 一般的高級語言如果要在不同的平台上運行 至少需要編譯成不同的目標代碼 而引入Java語言虛擬機后 Java語言在不同平台上運行時不需要重新編譯 Java語言使用模式Java虛擬機屏蔽了與具體平台相關的信息 使得Java語言編譯程序只需生成在Java虛擬機上運行的目標代碼（字節碼）就可以在多種平台上不加修改地運行 Java虛擬機在執行字節碼時 把字節碼解釋成具體平台上的機器指令執行
Java應用的特點
1、一個源文件中只能有一個public修飾的類，其他類個數不限。
2、一個源文件有n個類時，編譯結果的class文件就有n個。
3、源文件的名字必須和public修飾的類名相同
4、java語言中單詞拼寫大小寫嚴格區分。
5、main方法入口
6、每一句以分號（;）結束
Java類中方法的調用【在一個源文件中，只能有一個public修飾的類，並且在類中定義的 static方法，可以直接進行方法名的調用】
class test{
public static void test4(){
System.out.println("test4");
}
public void test1(){
test4();//可以直接進行調用的
System.out.println("test1");
}
}
public class StringBase {
public void test2(){
System.out.println("test2");
}
public static void test3(){
System.out.println("test3");
}
public static void main(String[] args) {
test.test4();//靜態方法可以直接用類名.方法名直接調用
test test=new test();
test.test1();//要定義類的對象，對象調用類里面的方法
StringBase sb=new StringBase();
sb.test2();
test3();//可以直接進行調用
}
}
執行結果：
test4
test4
test1
test2
test3
Java的單引號和雙引號的區別：
單引號引的數據 是char類型的——》單引號只能引一個字符（表示單個字符）
雙引號引的數據 是String類型的——》而雙引號可以引0個及其以上（引用字符串）
首先單引號引起來的都是單字符例如：char a='a';這樣是可以使用的，但是如果String a=‘a’ 和String a='aa' 這樣就是會報錯的，超過一位的字符就要使用String
三目運算符：X ? Y : Z
min=(a<b)?a:b;這樣，在a<b的情況下，min=a，否則min=b
程序的流程控制
結構化程序的三種結構：順序、選擇（分支）、循環
switch的選擇分支結構：
switch (a){
case 2:
System.out.println(3);
break;//加上break會跳出本次的switch選擇結構
case 3:
System.out.println(3);
}
遞歸的特征：
函數有返回值類型、函數有參數、函數中有跳出循環的控制語句、自己調用自己
java的靜態（static）
在靜態的情況下：可以使用 類名.方法名 類名.屬性名 這樣的方式直接進行調用對應的屬性或者是方法名.
也可以進行對象的創建，然后用對象進行屬性或者是方法名的調用；
public class StringBase {
static int a;//全局變量，類變量，初始默認值是0
public static void test3(){
String test="test";
System.out.println("test3");
}
public static void main(String[] args) {
System.out.println(StringBase.a);
StringBase.test3();
StringBase sb =new StringBase();
System.out.println(sb.a);
sb.test3();
}
}
在非靜態的情況下，只能使用對象進行相應的調用
java中的this的使用
【在類的構造器中使用，並且this后面調用的全是本類中的資源（變量，方法｛普通函數：this.test1();有參構造this（int n）；無參構造this（）；｝）】
1、在有參構造中的使用，構造函數的默認類型是public
class Person{
private String name;
private int age;
public Person(String name,int age) {
this.name = name; //this.name明確表示調用類中name屬性就近原則，不再使用
this.age = age;
}
public void getpersonInfo(){
System.out.println("姓名:"+name+",年齡："+age);
}
}
public class ThisTest {
public static void main(String[] args){
Person per=new Person("張二",25);
per.getpersonInfo();
}
}
執行結果：姓名:張二,年齡：25
2、可以調用類中的方法
public class ThisTest {
private String name;
private int age;
public ThisTest(String name,int age) {
this.name = name;
this.age = age;//this.age表示本類屬性
this.print("#############");//調用普通方法
}
public void print(String n){
System.out.println(n);
}
public String getpersonInfo(){
return "姓名:"+name+",年齡："+age;
}
public static void main(String[] args){
ThisTest per=new ThisTest("張三",30);
System.out.print (per.getpersonInfo());
}
}
執行結果：
#############
姓名:張三,年齡：30
3、調用類中的構造方法（有參構造方法/無參構造方法）
public class ThisTest {
private String name;
private int age;
public ThisTest() {
System.out.println("***產生一個新的person對象***");
}
public ThisTest(String name) {
this();//調用本類中無參構造
this.name=name;
}
public ThisTest(String name,int age) {
this(name);//調用本類有參構造
this.age=age;
}
public String getpersonInfo(){
return "姓名:"+name+",年齡："+age;
}
public static void main(String[] args){
ThisTest per1=new ThisTest();
System.out.println (per1.getpersonInfo());
ThisTest per2=new ThisTest("張二");
System.out.println (per2.getpersonInfo());
ThisTest per3=new ThisTest("張三",30);
System.out.println (per3.getpersonInfo());
}
}
執行結果：
***產生一個新的person對象***
姓名:null,年齡：0
***產生一個新的person對象***
姓名:張二,年齡：0
***產生一個新的person對象***
姓名:張三,年齡：30
java的super的使用
super是調用父類里面的資源（變量和類，this是調用本類中的資源和方法）
java初始化順序。初始化子類必先初始化父類。子類的構造方法會隱式去調用 父類無參的構造方法（不會在代碼中顯示）。但如果父類沒有無參的構造方法，就必須在子類構造方法第一行顯示調用父類的有參構造方法。否則編譯失敗
1、子類繼承父類的時候，會自動調用父類的無參構造器
class Person{
Person(){//無參構造器
System.out.println("person");
}
}
public class ThisTest extends Person{
ThisTest(){
System.out.println("ThisTest");
}
public static void main(String[] args){
ThisTest tt=new ThisTest();
}
}
執行結果：
person
ThisTest
2、子類調用父類的方法和屬性【子類沒有進行初始化，則父類的初始化也不會有要求，只有在子類進行構造器初始化的時候，才會涉及到父類里面的初始化】
class Country {
String name;
void value() {
System.out.println("china");
name = "China";
}
}
class ThisTest extends Country {
String name;
void value() {
name = "Hefei";
super.value();//不調用此方法時，super.name返回的是父類的成員變量的值null
System.out.println(name);
System.out.println(super.name);
}
public static void main(String[] args) {
ThisTest c=new ThisTest();
c.value();
}
}
執行結果：
china
Hefei
China
3、子類調用父類中的構造方法（在子類中不寫super的情況下，默認會調用父類的無參構造器，如果super中傳入參數的話，會調用父類中對應的有參構造）
class Person {
public static void prt(String s) {
System.out.println(s);
}
Person() {
prt("A Person.");
}
Person(String name) {
prt("A person name is:" + name);
}
}
public class ThisTest extends Person {
ThisTest() {
super(); // 調用父類構造函數（1）
prt("A chinese.");// (4)
}
ThisTest(String name) {
super(name);// 調用父類具有相同形參的構造函數（2）
prt("his name is:" + name);
}
ThisTest(String name, int age) {
this(name);// 調用當前具有相同形參的構造函數（3）
prt("his age is:" + age);
}
public static void main(String[] args) {
ThisTest cn = new ThisTest();
cn = new ThisTest("kevin");
cn = new ThisTest("kevin", 22);
}
}
執行結果：
A Person.
A chinese.
A person name is:kevin
his name is:kevin
A person name is:kevin
his name is:kevin
his age is:22
java的final關鍵字
1、final可以修飾全局變量，並且在進行變量創建的時候，必須要進行初始化；也可以修局部變量，但是也必須要進行初始化賦值
static final int a=0;
2、final修飾方法，對final修飾的方法，用子類繼承父類時候，是不可以進行重寫的
class Animal {
public final void move() {//用final進行修飾方法時候，子類是無法進行重寫父類方法的
System.out.println("動物可以動");
}
}
class Dog extends Animal {
public void move() {
System.out.println("狗可以跑和走");
}
}
public class ThisTest {
public static void main(String[] args) {
Animal a = new Animal(); // Animal 對象
Animal b = new Dog(); // Dog 對象，由父類創建的子類對象
a.move();// 執行 Animal 類的方法
b.move();//執行 Dog 類的方法
}
}
執行結果：報錯：
Error:(9, 17) java: com.zch.springboot_mybatis.Dog中的move()無法覆蓋com.zch.springboot_mybatis.Animal中的move()
被覆蓋的方法為final
3、final修飾類，則此類無法在進行繼承
final class Animal {
public void move() {//用final進行修飾方法時候，子類是無法進行重寫父類方法的
System.out.println("動物可以動");
}
}
class Dog extends Animal {
public void move() {
System.out.println("狗可以跑和走");
}
}
public class ThisTest {
public static void main(String[] args) {
Animal a = new Animal(); // Animal 對象
Animal b = new Dog(); // Dog 對象，由父類創建的子類對象
a.move();// 執行 Animal 類的方法
b.move();//執行 Dog 類的方法
}
}
執行結果：
報錯:Error:(8, 19) java: 無法從最終com.zch.springboot_mybatis.Animal進行繼承
java面向對象的三大特性
1、封裝（可以提高代碼的的安全性）：
將屬性進行私有化，並且提供對外界的接口（get/set方法）
用private進行修飾屬性和方法，並且只能在本類中進行使用
2、繼承（可以提高代碼的復用性，減少重復代碼）
子類可以繼承父類的非私有的屬性和方法，但是不可以繼承父類的構造方法以及私有屬性和方法
子類在繼承父類的元素的時候，也可以進行修改（重寫）
一個子類只能繼承一個父類，必須是單繼承
子類可以通過使用super進行參數的傳遞，進行父類的有參構造器的初始化
3、多態性：
運行時多態性：重寫（子類繼承父類的方法進行重寫，但是子類方法的訪問類型要大於父類的訪問類型）
編譯時多態性：重載（重載就是同名方法的不同參數）
java的抽象類（用abstract進行修飾的類）
1、如果一個類里面有抽象方法，那么這個類必須定義為抽象的；
2、抽象類是不能進行創建對象的，因為抽象類不能進行實例化
3、繼承抽象類，使用的關鍵字是extends
Java的接口（interface）
1、實現接口用implements關鍵字
2、接口中只有全局變量和抽象方法
3、接口在實現的時候，同時去繼承，extends在implements前面
Java排序算法：
1、冒泡排序
public class MaoPao {
public static void main(String []args ){
int a[]={1,3,4,5,2,7,6,10,9,8};
for(int i=0;i<a.length-1;i++){//控制外循環的次數
for(int j=0;j<a.length-1-i;j++){//控制內循環次數，比外循環少一次，與下一個比較
if(a[j]>a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
}
2、選擇排序
public class MaoPao {
public static void main(String []args ){
int a[]={1,3,4,5,2,7,6,10,9,8};
for (int i = 0; i < a.length-1; i++) {
int k=i;
for (int j = i; j < a.length-1; j++) {
if (a[k]>a[j+1]) {
k=j+1;
}
}
if(i!=k){
int temp=a[i];
a[i]=a[k];
a[k]=temp;
}
}
for (int i=0; i<a.length;i++){
System.out.println(a[i]);
}
}
}
Java的StringBuffer用法
String 長度不可變
StringBuffer 長度可變 線程安全 速度慢
StringBuilder 長度可變 線程不安全 速度快
StringBuffer sb=new StringBuffer("a");
System.out.println(sb);
sb.append("b");//追加
System.out.println(sb);
sb.insert(2,"cde");//在指定位置進行插入
System.out.println(sb);
sb.delete(2,3);//在指定位置進行刪除
System.out.println(sb);
sb.reverse();//反向逆轉
System.out.println(sb);
執行結果：
a
ab
abcde
abde
edba
Java的線程與進程
1、多線程，從宏觀的角度看就是同時執行多個進程，在微觀的角度看待就是同一時間只能執行一個線程
2、進程是應用程序，線程就是一條執行路徑
3、在一個進程中，至少有一個線程
4、開啟一個線程，可以繼承Thread的類，重寫run方法，然后創建類對象，然后對象.start();
class ThreadTest extends Thread{
//繼承Thread類，重寫run()方法
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"執行Run中");
System.out.println(Thread.currentThread().getName()+"執行完畢");
}
}
public class ExtendThread{
public static void main(String[] args) {
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
new ThreadTest().start();
}
}
還可以通過實現 Runnable接口，重寫run方法，創建類對象，然后new Thread（類對象）.start 然后通過start來啟動多線程
class ThreadTest implements Runnable{
//實現Runnable接口，實現run()方法
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"執行Run中");
System.out.println(Thread.currentThread().getName()+"執行完畢");
}
}
public class ExtendThread{
public static void main(String[] args) {
ThreadTest runnable = new ThreadTest();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
new Thread(runnable).start();
}
}
首先run是沒有開辟新的棧空間，沒有新線程，都是主程序在執行
start開辟了新的棧空間，在新的棧空間里面啟動run（）方法
tcp和udp
1、tcp：面向連接，數據傳輸是可靠的，傳輸效率 偏低，傳輸數據的大小沒有限制
2、udp：面向無連接，數據安全不可靠，執行效率比較高，數據的大小不超過64kb
【tcp和udp只是傳輸協議，只是設定了規范，真正起到傳輸作用的是數據ip協議】
【ip協議：將數據從源傳遞到目的地，ipv4是32位，ipv6是128位】
Java的反射機制
反射就是將Java類中的信息進行拆分，包括屬性、方法、構造方法，並且可以進行調用
優點：
1、提高了Java程序的靈活性和拓展性，降低了耦合性，提高了自適應的能力
2、允許程序創建和控制任何類的對象，無需提前編碼目標類
get和post的區別：
GET產生一個TCP數據包；POST產生兩個TCP數據包。
GET比POST更不安全，因為參數直接暴露在URL上，所以不能用來傳遞敏感信息。
對參數的數據類型，GET只接受ASCII字符，而POST沒有限制。
GET請求會被瀏覽器主動cache，而POST不會
在類中不能直接進行運算，要寫在方法代碼塊{}或者靜態代碼塊中static{}中
public abstract class MaoPao {
public int constInt = 5;
consInt=constInt+5;
private static void testMethod(){
System.out.println("testMethod");
}
public static void main(String[] args) {
((MaoPao)null).testMethod();
}
}
這樣在里面consInt=constInt+5;是會報錯的
Java在多線程下的sleep和 wait（）
共同點 ：
1. 他們都是在多線程的環境下，都可以在程序的調用處阻塞指定的毫秒數，並返回。
2. wait()和sleep()都可以通過interrupt()方法 打斷線程的暫停狀態 ，從而使線程立刻拋出InterruptedException。
如果線程A希望立即結束線程B，則可以對線程B對應的Thread實例調用interrupt方法。如果此刻線程B正在wait/sleep/join，則線程B會立刻拋出InterruptedException，在catch() {} 中直接return即可安全地結束線程。
需要注意的是，InterruptedException是線程自己從內部拋出的，並不是interrupt()方法拋出的。對某一線程調用 interrupt()時，如果該線程正在執行普通的代碼，那么該線程根本就不會拋出InterruptedException。但是，一旦該線程進入到 wait()/sleep()/join()后，就會立刻拋出InterruptedException 。
不同點 ：
1.每個對象都有一個鎖來控制同步訪問。Synchronized關鍵字可以和對象的鎖交互，來實現線程的同步。
sleep方法沒有釋放鎖，而wait方法釋放了鎖，使得其他線程可以使用同步控制塊或者方法。
2.wait，notify和notifyAll只能在同步控制方法或者同步控制塊里面使用，而sleep可以在任何地方使用
3.sleep必須捕獲異常，而wait，notify和notifyAll不需要捕獲異常
4.sleep是線程類（Thread）的方法，導致此線程暫停執行指定時間，給執行機會給其他線程，但是監控狀態依然保持，到時后會自動恢復。調用sleep不會釋放對象鎖。
5.wait是Object類的方法，對此對象調用wait方法導致本線程放棄對象鎖，進入等待此對象的等待鎖定池，只有針對此對象發出notify方法（或notifyAll）后本線程才進入對象鎖定池准備獲得對象鎖進入運行狀態。