Java工程師培訓課（五）
夜光序言：
善畫者不擇筆，善武者不擇器，善心者不擇人，善事者不擇地。
【當初在廁所都看書~~】
正文：
- 函式
數的概述
發現不斷進行加法運算，為了提高程式碼的複用性，就把該功能獨立封裝成一段獨立的小程式，當下次需要執行加法運算的時候，就可以直接呼叫這個段小程式即可，那麼這種封裝形形式的具體表現形式則稱作函式。
練習：把兩個整數相加：
public class FunctionDemo1{
public static void main(String[] args){
/*
int a = 4+5;
System.out.println("a="+a);
int b = 3+9;
System.out.println("b="+b);
*/
add(4,5)
}
public static int add(int a, int b){
return a+b;
}
}
舉例：地鐵自動售票機，接收紙幣或硬幣，返回車票，該售票機具有獨立功能，可以理解為函式。有未知內容參與運算（要投幣，紙幣硬幣，多少錢）。有返回值（返回車票）
舉例2：手機，手機具備打電話功能，有未知內容（電話號碼），鍵盤是（形參），輸入的號碼是實際引數。
函式的格式
修飾符 返回值型別 函式名(引數型別 形式引數1，引數型別 形式引數2，…)
{
執行語句;
return 返回值;
}
返回值型別： 執行這段程式得出的一個運算結果，結果型別，如果函式沒有返回值則用void
來表示該函式沒有返回值。
函式名：僅僅是一個識別符號，可以隨意起名字。
形式引數：是一個變數，用於儲存呼叫函式傳遞進來的實際引數。
實際引數：傳遞給形式引數的具體數值。
返回值:
定義函式：
1：是否有未知內容參與運算
2：是否有運算結果（返回值）
案例：獲取2個整數中的較大的數。
| public static int getMax(int x, int y) { int result; if (x > y) { result= x; } else { result= y; } return result; } |
解析：getMax方法
該方法方法名為：getMax,方法的作用是獲取找出兩個整數中較大的值。該方法有兩個int型引數，：x和y，方法返回兩個數中較大的一個。
public static 是方法的修飾符
int 是方法的返回值型別
getMax 是方法的方法名
（int x,int y）是引數列表，x和y是形式引數。
{} 花括號內的程式碼是方法體
return result; result 是返回值。
方法定義完成之後，如何呼叫一個方法？
函式呼叫：
想要使用方法，必須呼叫它。
| public static void main(String[] args) { int max = getMax(5, 7); System.out.println(max); } |
一：在main方法中呼叫getMax()方法，5和7就是給該方法傳遞的實際引數。如果方法有返回值，可以定義一個變數接收返回值，變數型別和方法返回值型別一致。本例中通過int型別變數max接收了getMax方法的返回值。
完整程式
這裡的getMax(i, j); i和j就是實際引數。
| public class Demo6 { public static void main(String[] args) { int i=5; int j=7; int max = getMax(i, j); System.out.println(i+"和"+j+"的最大值是："+max); }
public static int getMax(int x, int y) { int result; if (x > y) { result= x; } else { result= y; } return result; } } |
二：上述案例中呼叫getMax方法，並將結果賦值給了max變數。也可以直接列印getMax()方法的結果。
| public class Demo6 { public static void main(String[] args) { int i=5; int j=7; //列印方法的結果 System.out.println(getMax(i, j)); }
public static int getMax(int x, int y) { int result; if (x > y) { result= x; } else { result= y; } return result; } } |
注意：main方法是程式的入口由虛擬機器呼叫，方法和方法之間不能巢狀，方法之間通過呼叫來使用。
方法什麼時候執行完畢：
當執行完return語句，或者執行到方法末尾的花括號時方法結束。
該類中包含了兩個方法，main方法和getMax方法。main方法由java虛擬機器呼叫，並且main方法的寫法是固定的。Main方法可以呼叫其他方法。
當呼叫getMax方法時，變數i的值傳遞給方法中的x，j的值傳遞給方法中的y，並開始執行getMax方法中的語句，執行return，並返回運算結果。getMax方法執行完畢。
函式的特點
1、定義函式可以將功能程式碼進行封裝
2、便於對該功能進行復用
3、函式只有被呼叫才會被執行
4、函式的出現提高了程式碼的複用性
5、對於函式沒有具體返回值的情況，返回值型別用關鍵字void表示，那麼該函式中的return語句如果在最後一行可以省略不寫。
注意：
函式中只能呼叫函式，不可以在函式內部定義函式。
定義函式時，函式的結果應該返回給呼叫者，交由呼叫者處理。
函式的返回值void
需求：根據學生考試成績劃分ABCD A90-100 B80-89 C70-79 D60-69 E0-59，建議成績使用double。將該程式使用函式定義。
| public static void main(String[] args) { printGrade(90); printGrade(59.5); }
public static void printGrade(double score) { char grade; if (score >= 90.0) System.out.println("A"); else if (score >= 80.0) System.out.println("B"); else if (score >= 70.0) System.out.println("C"); else if (score >= 60.0) System.out.println("D"); else System.out.println("E");
} |
| public static void main(String[] args) { getResult(5); } public static int getResult(int x){ System.out.println(return x*8); //呼叫該函式會報錯.缺少返回值型別. } /* * 該方法沒有具體的返回值,那麼返回值的型別 是不可以寫int 了 * 但是又和函式的格式不符合了,怎麼解決？ * 當函式運算後, 沒有具體的返回值時,這時返回值型別用一個特殊的關鍵字做標誌. * 該關鍵字就是void void 表示沒有具體的返回值型別. * 當函式的返回值型別是void 時,函式中的return語句可以省略不寫. */ |
注意: 函式中只能呼叫函式，不可以在函式內部定義函式。函式之間是平級的,相互之間是呼叫的關係.
錯誤寫法
| public static void main(String[] args) { public static void getResult(int x) { System.out.println(x * 8); // 主函式，裡邊巢狀函式。錯誤！ } } |
函式的應用
案例一：畫矩形。
/*
為了提高程式碼的複用性
定義一個畫矩形的函式
1、確定函式的運算結果的資料型別，void
2、確定沒有未知引數。
*/
public static void draw(int width , int height){
for(int i = 0 ; i< height ; i++){
for(int j = 0 ; j < width ; j++){
System.out.print("*");
}
System.out.println();
}
}
案例二：兩個數字對比是否相等
/*
1、確定函式的運算結果的資料型別，boolean
2、確定沒有未知引數。a,b
*/
public static boolean equlas(int a , int b){
/**
if(a==b){
return true;
}else{
return false;
}
**/
return a==b?true:false;
}
案例三：比較兩個數的大小
/*
比較兩個整數誰大.
*/
public static int max(int a,int b)
{
/*
if(a>b)
return a;
else
return b;
*/
return a>b?a:b;
}
函式的使用注意事項：
- 函式中只能呼叫函式，不能定義函式，沒有定義函式之前，不能呼叫函式。
- 輸出語句只能對有具體返回結果的函式的進行列印。
- 返回值型別是void的函式，是不可以被輸出語句列印的。
- 函式需要實現功能，那麼函式只實現所需功能即可，不要實現不需要的功能。
函式的過載
- 函式過載的定義：在同一個類中，有一個以上的同名函式，只要函式的引數列表或引數型別不一樣即可，與返回值無關， 這些統稱為方法的過載。
- 函式的過載存在的原因：為了增強方法的閱讀性，優化了程式設計。
案例1：九九乘法表
private static void print99() {
for(int i = 1 ; i<= 9 ; i ++){
for(int j = 1 ; j<=i ; j++){
System.out.print(i+"*"+j+"="+(i*j)+" ");
}
System.out.println();
}
}
private static void print99(int num) {
for(int i = 1 ; i<= num ; i ++){
for(int j = 1 ; j<=i ; j++){
System.out.print(i+"*"+j+"="+(i*j)+" ");
}
System.out.println();
}
}
練習：判斷那個方法是過載
void show(int x, char y, double z){} // false
void show(int a, double c, char b){} // true
int show(int a, double c, char b){} // true
void show(int a, char b){} // true
void show(double c){} // true
double show(int x, char y, double z){} // false
- 陣列
| 概念 |
| 同一種類型資料的集合。其實陣列就是一個容器。 |
| 陣列的好處 |
| 可以自動給陣列中的元素從0開始編號，方便操作這些元素。 |
| 格式1： |
| 元素型別[] 陣列名 = new 元素型別[元素個數或陣列長度]; 示例：int[] arr = new int[5]; |
| 格式2： |
| 元素型別[] 陣列名 = new 元素型別[]{元素，元素，……}; int[] arr = new int[]{3,5,1,7}; int[] arr = {3,5,1,7}; |
如果需要儲存大量的資料，例如如果需要讀取100個數，那麼就需要定義100個變數，顯然重複寫100次程式碼，是沒有太大意義的。如何解決這個問題，Java語言提供了陣列（array）的資料結構，是一個容器可以儲存相同資料型別的元素，可以將100個數儲存到陣列中。
1陣列的概念
同一種類型資料的集合。其實陣列就是一個容器。運算的時候有很多資料參與運算,那麼首先需要做的是什麼.不是如何運算而是如何儲存這些資料以便於後期的運算，那麼陣列就是一種用於儲存資料的方式，能存資料的地方我們稱之為容器，容器裡裝的東西就是陣列的元素, 陣列可以裝任意型別的資料，雖然可以裝任意型別的資料,但是定義好的陣列只能裝一種元素， 也就是陣列一旦定義，那麼裡邊儲存的資料型別也就確定了。
2 陣列的好處
存資料和不存資料有什麼區別嗎？陣列的最大好處就是能都給儲存進來的元素自動進行編號. 注意編號是從0開始。方便操作這些資料。
例如 學生的編號，使用學號就可以找到對應的學生。
3陣列的格式
元素型別[] 陣列名 = new 元素型別[元素個數或陣列長度];
示例：int[] arr = new int[5];
案例：
需求: 想定義一個可以儲存3個整數的容器
實現：
1宣告陣列變數
為了使用陣列必須在程式中宣告陣列，並指定陣列的元素型別
=左半部分：
先寫左邊明確了元素型別 是int ，容器使用陣列，那麼如何來標識陣列？.那麼用一個特殊的符號[]中括號來表示。想要使用陣列是需要給陣列起一個名字的,那麼我們在這裡給這個陣列起名字為x .接著跟上等號。
程式碼體現：
int [] x
注意：int x[] 也是一種建立陣列的格式。推薦使用int [] x 的形式宣告陣列。
2建立陣列
=右半部分：
要使用一個新的關鍵字.叫做new。new 用來在記憶體中產生一個容器實體，資料要儲存是需要有空間的，儲存很多資料的空間用new 操作符來開闢，new int[3]; 這個3是元素的個數。右邊這部分就是在記憶體中定義了一個真實存在的陣列，能儲存3個元素。
new int[3] 做了兩件事情，首先使用new int[3] 建立了一個數組，然後把這個陣列的引用賦值給陣列變數x。
int [] x=new int[3];
x 是什麼型別？
任何一個變數都得有自己的資料型別。注意這個x 不是int 型別的 。int 代表的是容器裡邊元素的型別。那麼x 是陣列型別的。
陣列是一種單獨的資料型別。資料型別分為2大派，分為基本資料型別和引用資料型別。 第二大派是引用資料型別。那麼大家現在已經接觸到了引用資料型別三種當中的一種。就是陣列型別 [] 中括號就代表陣列。
4、int[] arr = new int[5];在記憶體中發生了什麼？
記憶體任何一個程式,執行的時候都需要在記憶體中開闢空間.int[] arr = new int[5]; 這個程式在記憶體中是什麼樣?這就涉及到了java虛擬機器在執行程式時所開闢的空間,那麼java開闢啟動了多少空間呢？繼續學習java的記憶體結構。
-
-
- 陣列的定義
-
| 格式1： |
| 元素型別[] 陣列名 = new 元素型別[元素個數或陣列長度]; 示例：int[] arr = new int[5]; |
| 格式2： |
| 元素型別[] 陣列名 = new 元素型別[]{元素，元素，……}; int[] arr = new int[]{3,5,1,7}; int[] arr = {3,5,1,7}; |
注意：給陣列分配空間時，必須指定陣列能夠儲存的元素個數來確定陣列大小。建立陣列之後不能修改陣列的大小。可以使用length 屬性獲取陣列的大小。
遍歷陣列
-
-
- 陣列初始化
-
陣列的格式
| int[] x = new int[3]; x[0] = 1; x[1] = 2; |
另一種定義：該形式可以直接明確陣列的長度,以及陣列中元素的內容
| int[] x = { 1, 2, 3 }; |
| int[] x=new int[]{1,2,3}; |
| 初始化方式1：不使用運算子new int[] arr = { 1, 2, 3, 4, 5 }; int[] arr2 = new int[] { 1, 2, 3, 4, 5 }; 初始化方式2： int[] arr3=new int[3]; arr3[0]=1; arr3[1]=5; arr3[2]=6;
|
如果陣列初始化中不使用運算子new。需要注意：下列寫法是錯誤的。
| int[] arr; arr={1,2,3,4,5}; |
此時初始化陣列，必須將宣告，建立，初始化都放在一條語句中個，分開會產生語法錯誤。
所以只能如下寫：
| int[] arr={1,2,3,4,5}; |
-
-
- 陣列遍歷
-
| public static void main(String[] args) { int[] x = { 1, 2, 3 }; for (int y = 0; y < 3; y++) { System.out.println(x[y]); // System.out.println("x["+y+"]="+x[y]); 列印效果 x[0]=1; } // 那麼這就是陣列的第一個常見操作.遍歷 } |
陣列中有一個屬性可以獲取到陣列中元素的個數,也就是陣列的長度. 陣列名.length
| public static void main(String[] args) { int[] x = { 1, 2, 3 }; for (int y = 0; y < x.length; y++) { System.out.println(x[y]); // System.out.println("x["+y+"]="+x[y]); 列印效果 x[0]=1; } // 那麼這就是陣列的第一個常見操作.遍歷 } |
-
-
- 陣列的常見異常
-
一陣列角標越界異常:，注意：陣列的角標從0開始。
| public static void main(String[] args) { int[] x = { 1, 2, 3 }; System.out.println(x[3]); //java.lang.ArrayIndexOutOfBoundsException } |
二 空指標異常:
| public static void main(String[] args) { int[] x = { 1, 2, 3 }; x = null; System.out.println(x[1]); // java.lang.NullPointerException } |
陣列:
什麼時候使用陣列:當元素較多時為了方便操作這些陣列,會先進行來臨時儲存，所使用的容器就是陣列。
特點:
陣列長度是固定的。
陣列的記憶體分析
案例分析一：
案例分析二：
陣列的常見操作
6.1案例一個數組取出最大值
/*定義一個獲取最大值的功能:
1、確定結果 ：返回值型別 int
2、未知內容：要獲取哪個陣列的最大值沒有確定，則是陣列沒有確定
思路：
1、定義一個變數，記錄住陣列的比較大的元素。
2、遍歷整個陣列，讓陣列的每一個元素都和該變數進行對比即可。
3、當變數遇到比它大的元素，則讓該變數記錄該元素的值，當迴圈結束時，最大 值產生了
*/
public static int getMax(int[] arr)
{
//定義變數記錄較大的值，初始化為陣列中的任意一個元素。
int max = arr[0];
for(int x=1; x<arr.length; x++)
{
if(arr[x]>max)
max = arr[x];
}
return max;
}
6.2直接排序
案例二：使用直接排序對陣列進行排序：
/*
選擇排序。
以一個角標的元素和其他元素進行比較。
在內迴圈第一次結束，最值出現的頭角標位置上。
*/
public static void selectSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=x+1; y<arr.length; y++)//為什麼y的初始化值是 x+1？ 因為每一次比較，
//都用x角標上的元素和下一個元素進 行比較。
{
if(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
6.3氣泡排序
案例三：氣泡排序
/*
氣泡排序。
比較方式：相鄰兩個元素進行比較。如果滿足條件就進行位置置換。
原理：內迴圈結束一次，最值出現在尾角標位置。
*/
public static void bubbleSort(int[] arr)
{
for(int x=0; x<arr.length-1; x++)
{
for(int y=0; y<arr.length-x-1; y++)//-x:讓每次參與比較的元減。
//-1:避免角標越界。
{
if(arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
6.4折半查詢(二分法)
案例四：
/*
為了提高查詢效率，可使用折半查詢的方式，注意：這種查詢只對有序的陣列有效。
這種方式也成為二分查詢法。
*/
public static int halfSeach(int[] arr,int key)
{
int min,mid,max;
min = 0;
max = arr.length-1;
mid = (max+min)/2;
while(arr[mid]!=key)
{
if(key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
if(min>max)
return -1;
mid = (max+min)/2;
}
return mid;
}
案例五：陣列翻轉
/*
反轉其實就是頭角標和尾角標的元素進行位置的置換，
然後在讓頭角標自增。尾角標自減。
當頭角標<尾角標時，可以進行置換的動作。
*/
public static void reverseArray(int[] arr)
{
for(int start=0,end=arr.length-1; start<end; start++,end--)
{
swap(arr,start,end);
}
}
//對陣列的元素進行位置的置換。
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
- 二維陣列
Arrays的使用
遍歷： toString() 將陣列的元素以字串的形式返回
排序： sort() 將陣列按照升序排列
查詢： binarySearch()在指定陣列中查詢指定元素，返回元素的索引，如果沒有找到返回（-插入點-1） 注意：使用查詢的功能的時候，陣列一定要先排序。
二維陣列:
吸菸：
沒錢 零買 1根 一個變數
稍微有錢 一包 一維陣列 20根變數
很有錢 一條 10包(二維陣列) 二維陣列
二維陣列：實質就是儲存是一維陣列。
陣列定義：
陣列型別[][] 陣列名 = new 陣列型別[一維陣列的個數][每一個一維陣列中元素的個數];
疑問： 為什麼a.length = 3, a[0].length = 4?
陣列的初始化：
靜態初始化:
int [][] a = new int[][]{ {12,34,45,89},{34,56,78,10},{1,3,6,4} };
動態初始化：
二維陣列常見的操作:
- 遍歷二維陣列
- 對二維陣列求和
| class Demo3 { // 定義一個遍歷二維陣列的功能函式 public static void printArr2( int [][] a ){ // 1. 拆開二維陣列 for ( int i = 0 ; i < a.length ; i++ ) { // 2. 拆開一維陣列獲取資料 for ( int j = 0 ; j < a[i].length ; j++ ) { System.out.print( a[i][j]+" ," ); } }
} // 定義一個函式計算二維陣列中的元素的累加和 public static long getSum( int [][] a ){ // 0. 定義一個結果變數 long sum = 0L; // 1. 拆開二維陣列 for |