第二週 2.10-2.16

Day6

循環

概念
- 通過某個條件，重複的執行一段邏輯代碼
執行流程
- 程序開始
  - 循環條件
    - true
      - 循環操作
    - false
      - 循環結束，執行後續代碼
循環的組成

需求：打印100遍“helloworld”

package demo;

public class TestWhile{
public static void main(String[] args){
int i =1;//初始部分；用來判斷的變量
while(i<=100){//循環條件，決定是否繼續循環的依據
System.out.println(“HelloWorld”)；//循環操作；單次執行的邏輯代碼或任務
i++;//迭代部分；控制循環條件改變的增量
}

]

}
While循環
- 語法
  
  while（布爾表達式）{
  
  //邏輯代碼（循環操作）
  
  }
- 執行流程
  - 先對布爾表達式進行判斷，結果爲true，則執行邏輯代碼
  - 本次執行完畢後，再次進行判斷，結果仍然爲true 則，再次執行後續代碼
  - 直至布爾表達式的結果爲false 時，纔會退出循環結構，執行後續代碼
- 注意：循環有四個部分組成
- 特點：首次即有入口條件，先判斷、再執行，適用於循環次數明確的情況
  
  public calss TestWhile{
  public static void main(String[] args){
  
  iint i = 1000;
  while(i<=1000){/首次判斷不滿足，這一次都不會執行，（執行次數：0-n次）
  System.out.println(“helloWorld”）；
  }
  System.out.println("程序結束“）；
  }
  
  }
do while循環
- 語法
  
  do{
  邏輯代碼(循環代操作）
  
  }while(布爾表達式）；
- 執行流程
  - 先執行一次循環操作之後，再進行布爾表達式的判斷
  - 如果結果爲true,則執行循環操作
  - 如果結果爲false，纔會退出循環結構，執行後續代碼
- 特點：首次沒有入口條件，先執行，再判斷
- 應用場景：適用於循環次數不明確的情況
for 循環
- 語法
  
  for(初始部分；循環條件；迭代部分){
  //循環操作
  }
- 執行流程
  - 首次執行初次部分（僅一次）
  - 對布爾表達式進行判斷，結果爲true，則執行邏輯代碼
  - 本次執行完畢後，執行迭代部分，再次判斷，結果仍然爲true，則再次執行邏輯代碼
  - 直至布爾表達式的結果爲false時，纔會退出循環結構
- 特點：首次即有入口條件，先判斷、再執行，適用於循環次數明確的情況
- 子主題 4
流程控制關鍵字
- break:終止、跳出switch 、循環結構
  
  public calss TestBreak{
  public static void main(String[] args){
  
  for (int i =1;i<=10;i++){
  if（i==5）{
  break;
  }
  System.out.println("當前循環次數：“+i);
  }
  System.out.println(“循環結束”);
  }
  }
- continue:結束本次、進入下一次循環。
  
  public class TestContinue{
  public static void main(string args){
  for (int i =1;i<=10;i++){
  if(i==5){
  continue;
  }
  System.out.println("循環結束“)；
  }
  System.out.println(“循環結束”);
  }
  
  }
補充：引用類型不可以在循環體裏定義，基本數據類型可以在循環體裏面定義
嵌套循環
- 概念：在完整的循環結構中，嵌套另一個完整的循環結構
- 例子
  
  public class TestNesFor{
  public static void main(String[] args){
  for(int i = 1;i<=3;i++){//外層控制行數
  for (int j =1;j<=5;j++){//內層控制列數
  System.out.println("*");
  }
  System.out.println();
  }
  }
  }
  
  }

Day7

break和continue的程序訓練

斷點

在程序行左邊打一個點，debug
- 右鍵watch
  - F 8運行到下一個斷點

函數

函數的概念
- 實現特點功能的一段代碼，可反覆使用
函數的定義：語法

public static void 函數名稱（）{//遵循標識符命名規範

//函數主體功能代碼
}
- 定義的位置：函數的定義在類的內部，與main()函數並列
  
  //位置1
  public class TestDefinitionFunction{
  //位置2
  public static void main(String[] args){
  //位置3
  
  }
  //位置4
  }
  //位置5
  
  正確位置：位置2，位置4
- 定義第一個函數
  
  public class TestFunction{
  public static void main(String[] args ){
  System.out.println(“牀前明月光”);
  System.out.println(“疑是地上霜”);
  System.out.println(“舉頭望明月”);
  System.out.println(“低頭思故鄉”);
  
  }
  //定義：打印10個分割符的函數
  public static void printSign(){
  for(int i =1;i<=10;I++){
  System.out.println("-");
  }
  System.out.println();
  }
  
  }
  - 運行結果：
    
    牀前明月光，疑是地上霜，舉頭望明月，低頭思故鄉
  - 注意：函數的定義並沒有改變執行結果
經驗：將需要在多個位置重複使用的一組代碼，定義在函數內
函數的組成
函數的調用
- 在需要執行函數代碼的位置，通過函數名稱進行調用
- 注意：調用函數時，會優先執行函數內部代碼，結束後，返回到函數調用處，繼續向下執行
函數的好處
- 方便函數與調用者之間需要數據的交互；調用者必須提供必要的數據，才能使函數完成相應的功能
- 調用函數時，所傳入的數據被稱爲“參數”

Day8

函數參數

函數的參數
- 形參
  - 定義語法
    
    public static void 函數名稱（形式參數）{
    
    //函數主體
    }
    - 經驗：“形參”等價於局部變量的聲明
- 實參
  - 調用語法
    - 函數名稱（實際參數）;
      - 經驗:"'實參等價於局部變量的賦值
單個參數

public class TestFunction{
public static void main(String[] args ){
System.out.println("牀前明月光’);
printSign();

}
public static void printSign(int count){
for (int i =1;i<count;i++){
```
  			System.out.println("-");
```
}
System.out.println();
}
}

//實際參數：10 調用帶參函數時，必須傳入實際參數，爲形式參數賦值

//形式參數：int count
當函數被執行時，循環count 次
多個參數

public class TestFunction{
public static void main(String[] args){
System.out.println("牀前明月光’);
printSign(10,’#’);
System.out.println(“疑是地上霜”);
System.out.println(“舉頭望明月”)
System.out.println(“低頭思故鄉”
}
//定義;打印
}

//實參： 10 ，#
調用帶參數時，依次傳入實參，類型、個數、順序，必須與形參對應

//形參： int count ,char sign 當函數被執行時，打印 count 次 sign
如何定義參數：根據具體的業務需求，來定函數的參數

返回值和返回值類型

定義語法

public static 返回值類型函數名稱（形式參數列表）{

//函數主體
return value ;// 返回值

}
調用語法

變量 =函數名稱（）；
變量 = 函數名稱（）；
1、規定返回值的具體類型（基本、引用、void） 2、根據需求返回一個結果（值） 3、變量類型與返回值類型一致 4 變量類型與返回值類型一致
例子

public class TestResultValue {
public static void main(String[] args ){
int result =add(5,6);//接收返回值：函數調用的表達式，最終代表了所返回的結果
System.out.println(result);

}
public static int add（int a ,int b ）{//返回值類型：定義時，即約定了返回的結果類型

return a+b;//返回值：與返回值類型匹配的具體結果。在return 關鍵字的後面追加具體值
}
]
return 關鍵字
- 一個函數只能有一個返回值
- 當有返回值得函數存在分支結構時，必須保證每一個分支都具有正確的返回值
- return 的兩種用法：
  - 應用在具有返回值類型的函數中： return value ;//表示結束當前函數，並伴有返回值，返回到函數調用處
  - 應用在沒有返回值類型（void ）的函數中： return ;//表示結束當前函數，直接返回到函數調用處
    
    例子：
    public static void show (){
    
    for (int i =1;i<=100;i++){
    if (i==50){
    return ;// 結束當前函數直接返回
    
    }
    }
    }
- 注意：一個類中可以定義多個函數，函數之間屬於並列關係，不可嵌套
- 經驗：一個函數只做一件事
- 好處：
  - 減少代碼亢餘
  - 提高複用率
  - 提高可讀性
  - 提高維護性
  - 方便分工合作

Day9

多級調用

public class TestNestInvoke{

public static void  main(String[] args){
m1();

}
public static void m1(){
System.out.println(“m1() -start”);
m2();
System.out.println(“m1()-end”);

}
public static void m2(){
System.out.println(“m2() --start”);
System.out.println(“m2() -end”);
}
}

運行結果：

運行結果：
m1() -start
m2() -start
m2() -start
m1() -start
優先執行函數內部代碼，結束後，返回到調用處，繼續向下執行

無窮遞歸

public class TestRecursionInvoke{
public static void main(String[] args ){
m1();
}
public static void m1(){
System.out.println("m1() -start’);
m1();
System.out,println(“m1() -end”);

//當函數自己調用自己時，如果沒有正確的出口條件，則產生無窮遞歸
}

}

注意： exception in thread “main” java.lang.StackOverFlowError 內存溢出

遞歸的概念：實際的開發中，遞歸可以解決具有機油規律的特定問題

遞歸的應用場景： 1 、當需要解決問題可以拆開若干個小問題，大小問題的解決方法相同 2、有固定規律，函數中個，自己調用自己

如何正確使用遞歸：設置有效的出口條件，避免無窮遞歸

循環階乘的例子

計算5的階乘 5！=54321

public class TestFactorial{

public static void main(String[] args){

	System.out.println(factorial(5));

}
public static int factorial(int n){
int sum =1;
for(int i =2;i<=n;i++){
sum*=i;

//循環計算階乘較爲簡單，依次與每個值相乘即可
}
return sum;
}
}

注意：所有能以遞歸解決的問題，循環都可以解決。當解決複雜問題時，遞歸的實現方式更爲簡單

Day10

數組

概念
- 一組連續的存儲空間，存儲多個相同數據類型的值
特點：
- 類型相同
- 長度固定
數組的創建

public class TestCreateArray{

public static void main(String [] args){

int [] a = new int[5];//分配長度爲5的連續而空間

}

}

//可以存儲5個int 類型的值
- 先聲明、再分配空間
  - 數據類型 [] 數組名；
  - 數組名 =new 數據類型[長度]
- 聲明並分配空間：
  - 數組類型 [] 數組名 = new 數據類型
- 聲明並賦值（繁）
  - 數組類型 [] 數組名 = new 數據類型 [] {value 1 ,value 2 ,value3 ,、、、、、、} ；
- 聲明並賦值（簡）
  - 數據類型 [] 數組名 = { value1， value2，value3} //顯示初始化，注意：不可換行
數組的使用

public class TestCreateArray{

public static void main(String[] args){

int [] a = new int [5];//創建數組
a[0]=5;//依次賦值
a[1]=3;
a[2]=4;
a[3]=7;
a[4]=10;
System.out.println(a[0]);//依次取值
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a[3]);
System.out.println(a[4]);

}
}
- 數組中的每個數據被稱爲“數組元素‘
- 對每個元素進行賦值或取值的操作被稱爲”元素的訪問“
- 訪問元素時，需要使用“下標”（從0開始，依次+1，自動生成）
- 訪問的語法：數組名[下標]；// 例如存 a [0]=10 ;取：a [0];
數組的下標
- 有效下標範圍：0-數組長度-1
- 訪問無效下標，會導致數組下標越界
數組的遍歷

public class TestVisitArray{

public static void main(String[] args){
```
int [] a = new int [5];
```
a[0]=5;
a[1]=3;
a[2]=4;
a[3]=7;
a[4]=10;
for( int i = 0 ; i<a.length;i++){
System.out.println(a[i]);
}
}

}
- 遍歷：從頭至尾，逐一對數組的每個元素進行訪問
- 數組名 .length 可動態獲得數組長度
- 使用循環變量 “i” 充當下標，逐一訪問數組中的每個元素
數組的默認值

public class TestDefaultValue{
public static void main(String[] args){

int []a = new int[5];

for(int i =0; i<5;i++){
System.out.println(a[i]);
//在沒有爲數組元素賦值的情況下，依舊可以正確訪問。
}
}

}
- 數組的默認值：整數 0；小數 0.0 字符 \u00000 布爾 false 其他 null;
數組的擴容
- 創建數組時，必須顯示指定長度，並在創建之後不可更改長度
- 擴容的思路：
  - 創建大於原數組的新數組
  - 將原數組中的元素依次複製到新數組中
複製的方式
- 循環將原數組中所有元素逐一賦值給新數組
- System.arraycopy (原數組，原數組起始，新數組，新數組起始，長度)
- java.util.Arrays.copyOf(原數組，新長度)；//返回帶有原值新數組
地址的替換
- 數組作爲引用類型之一，其變量中存儲的是數組的地址
- 完成元素複製後，需將新數組地址，賦值給原變量進行替換
數組類型的參數

public class TestArrayParameter{

public static void main(String[] args ){
int [] nums ={111,222,333,444,555};
printArray(nums);

}
public static void printArray(int [] oneArray){

for(int i= 0;i<oneArray.length;i++){
System.out.println(oneArray[i]);

}

}
}
- 方法調用時，將nums 中的地址賦值給oneArray,此時二者指向同一個數組
可變長參數

public class TestArrayParameter{

public static void main(String[] args ){

}
public static void printArray(int … oneArray){
for (int i =0;i<oneArray.length;i++){

System.out.println(oneArray[i]);
}

}

}
- 概念：可接收多個同類型實參，個數不限，使用方式與數組相同
- 語法：數據類型、、、、、形參名 //必須定義在形參列表的最後，且只能有一個
數組的排序
- 冒泡排序：相鄰的兩個數值比較大小，互換位置
- 選擇排序：固定值與其他值依次比較大小，互換位置
- JDK排序：java.util.Arrays.sort(數組名);// JDK提供（升序）
二維數組
- 概念：一維數組中的一堆數組，數組中的元素，還是數組
- 當查找excle 中的某個單元格時，需要兩個下標配，n代表行，m 代表列二維數組相當於一個多行多列的表格
- 查找X表中的“B3”單元格二維數組的語法爲 x[3][B]行下標在前，列下標在後
二維數組的賦值

public class Test2DArray{

public static void main(String[] args){
```
  int [] [] array = new int [3][5];
  array[0][0] =10;
  array[0][3]=20;
  array[1][1]=30;
  array[1][2]=40;
  array[2][4] =50;
```
}

}
- 使用雙下標訪問二維數組中的元素，第一個下標代表：行號（高維下標）,第二個下標代表：列號（低維下標）
二維數組的內存分配

erwei
- 高維數組中的每一個元素，保存了低維數組的地址。訪問array[0] 等價於在訪問0x0000A111
二維數組的訪問

public class Test2DArray{
public static void main(Sring[] args{
int [] [] array = new int [3][5];
array[0][0]= 10;
array[0][3]=20;
array[1][1]= 30;
array[1][2]=40;
array[2][4] =50;
for(int i = 0; i<array.length;i++){
for(int j =0;j<array[i].length;j++){

System.out.println();

}
System.out.prinltn();
}

}

}
- 訪問低維長度 array[0].length 首個低維數組的長度
- 訪問低維數組元素；array[0][0] 首個低維數組的首個元素

JAVA EE NZ2001 java EE學習總結----第二週《包含思維導圖》

第二週 2.10-2.16

Day6

循環

Day7

break和continue的程序訓練

斷點

函數

Day8

函數參數

返回值和返回值類型

Day9

多級調用

無窮遞歸

注意： exception in thread “main” java.lang.StackOverFlowError 內存溢出

遞歸的概念：實際的開發中，遞歸可以解決具有機油規律的特定問題

遞歸的應用場景： 1 、當需要解決問題可以拆開若干個小問題，大小問題的解決方法相同 2、有固定規律，函數中個，自己調用自己

如何正確使用遞歸：設置有效的出口條件，避免無窮遞歸

循環階乘的例子

注意：所有能以遞歸解決的問題，循環都可以解決。當解決複雜問題時，遞歸的實現方式更爲簡單

Day10

數組

講函數的調用

數組的聲明與賦值

SQL 數據庫字段數據類型說明

Tomcat——web 相關概念回顧

計算機時間有關類的實現

java基礎練習題（珍藏版）

java EE學習總結 ------- 第五週

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

JAVA EE NZ2001 java EE學習總結----第二週 《包含思維導圖》

第二週 2.10-2.16

Day6

循環

Day7

break和continue的程序訓練

斷點

函數

Day8

函數參數

返回值和返回值類型

Day9

多級調用

無窮遞歸

注意： exception in thread “main” java.lang.StackOverFlowError 內存溢出

遞歸的概念：實際的開發中， 遞歸可以解決具有機油規律的特定問題

遞歸的應用場景： 1 、當需要解決問題可以拆開若干個小問題，大小問題的解決方法相同 2、 有固定規律，函數中個，自己調用 自己

如何正確使用遞歸：設置有效的出口條件，避免無窮遞歸

循環階乘的例子

注意：所有能以遞歸解決的問題，循環都可以解決。當解決複雜問題時，遞歸的實現方式更爲簡單

Day10

數組

講函數的調用

數組的聲明與賦值

JAVA EE NZ2001 java EE學習總結----第二週《包含思維導圖》

遞歸的概念：實際的開發中，遞歸可以解決具有機油規律的特定問題

遞歸的應用場景： 1 、當需要解決問題可以拆開若干個小問題，大小問題的解決方法相同 2、有固定規律，函數中個，自己調用自己