黑馬程式員 二、方法與數組

二、黑馬程式員—方法與數組

第二篇：

1、什麼是方法（method）？

方法是一組為了實作特定功能的代碼塊的集合。方法在文法上的功能主要有以下兩個：

①：結構化代碼

将代碼按照功能進行組織，使代碼的結構比較清晰，容易閱讀和修改，也就是程式的可維護

性強。

②：減少代碼重複

一個固定的功能，可能會在程式中多次使用，在使用時隻需要調用寫好的方法，而不用重複

書寫對應的功能代碼。

方法在書寫時需要注意以下兩點：

①：邏輯嚴謹

方法實作的一個完整的功能，是以在書寫時要考慮到各種可能的情況，并對每種情況做出恰

當的處理。

②：通用性強（可重複利用）

方法實作的是一種功能，在實際實作時，可以根據需要，使方法具備一定的通用性，除非必

要，否則不要寫專用的方法。在 java 語言中，恰當的使用方法，将使程式更加優雅，便于

閱讀和使用。

我的總結：

方法：一段可重複使用的代碼段；

程式中完成獨立功能的一段代碼的集合。

2、java 中方法的格式：

[修飾符] 傳回值類型 方法名([參數類型 形式參數 1，參數類型 形式參數 2，……])

{

執行語句; [return 傳回值;]//需要的話

}

參數清單（參數的類型 ，參數的個數，參數的順序）

我的總結：隻要上述有一個不一樣，那麼這個參數清單就不一樣！對于方法而言，即使同

名也不是同一個方法，也就是下面講的方法簽名。

3、方法裡的屬性

通路控制符：通路控制符限定方法的可見範圍，或者說是方法被調用的範圍。方法的通路控

制符有四種，按可見範圍從大到小依次是：public、protected，無通路控制符,private。其中

無通路控制符不書寫關鍵字即可。具體的範圍在後續有詳細介紹。

形式參數：在方法被調用時用于接收外界輸入的資料。

實參：調用方法時實際傳給方法的資料。

傳回值：方法在執行完畢後返還給調用它的環境的資料。

傳回值類型：事先約定的傳回值的資料類型，如無傳回值，必須給出傳回類型 void。

方法簽名：方法名和方法的參數清單(能差別方法)；//最關鍵的

java 語言中調用方法：對象名.方法名（實參清單）。

實參的數目、資料類型和次序必須和所調用方法聲明的形參清單比對。

return 語句終止方法的運作并指定要傳回的資料。

4、方法特點

它可以實作獨立的功能;

必須定義在類裡面;

它隻有被調用才會執行;

它可以被重複使用;

方法結束後方法裡的對象失去引用;

如何定義一個功能,并通過方法展現出來：

1 明确該功能運算後的結果.明确傳回值類型;

2 明确在實作該功能過程中是否有未知内容參與運算，确定參數清單;

eg：

package reviewdemo;

/**

* player 的值分别是1,2,3或者其他值時，該方法傳回“大明”，“二明”，“小明”，“我沒

有這個孩子”。

*/

public class demo2 {

public static void main(string[] args) {

int player = 5;

system.out.println("傳回的結果是："+show(player));

public static string show(int p){

switch (p) {

case 1:

return "大明";

case 2:

return "二明";

case 3:

return "小明";

default:

return "我沒有這個孩子！";

5、什麼是方法的重載（overload）？

概念：

在同一個類中，允許存在一個以上的同名方法，隻要它們的參數個數或者參數類型或

參數順序不同即可。

存在的原因：

屏蔽了一個對象的同一類方法由于參數不同所造成的差異。

特點：

與傳回值類型無關，隻看參數清單。

以下是方法重載的示例：

public void a(int a){}

public int a(){}

public void a(int a,string s){}

class chongzai

public static void main(string[] args)

int ret = name(3,4,5);

system.out.println(ret);

public static int name(int a, int b)

int c = a+b;

return c;

public static int name(int a, int b, int m)//這就叫做方法的重載，隻

要參數清單不一樣。好處：使用者使用時限制很小；

int c = a+b+m;

我的總結：方法重載，方法名相同，但是參數清單不一緻！（和方法覆寫不一樣，方法覆寫

的方法名和參數清單都必須一樣），注意方法重載和方法覆寫的不同！

6、可變參數

從 java5 開始出現了可變參數，這是對 java 方法及數組的拓展！

方法中可以接受的參數不再是固定個數的，而是随着具體需求傳遞的多少來決定。

定義格式： 傳回值類型 方法名(參數類型 ... 形式參數){ }

可變參數的特點：

隻能出現在參數清單的最後；

... 位于變量類型和變量名之間，前後有無空格都可以;

調用可變參數的方法時，編譯器為該可變參數隐含建立一個數組，在方法體中以數組的形式

通路可變參數。

import java.util.arrays;

public class demo6 {

int []age = {1,2,3,69,36,636,459};

show(age);

public static void show(int...a){//此時這裡寫的就是可變參數，和數組

的作用一樣！

//把數組給列印出來！

system.out.println(arrays.tostring(a));

7、數組簡介：

數組(array)是 java 語言中内置的一種基本資料存儲結構，通俗的了解，就是一組數的集合，

目的是用來一次存儲多個資料。數組是程式中實作很多算法的基礎，可以在一定程度上簡化

代碼的書寫。

備注：

1. 數組的好處：數組裡的每個元素都有編号，編号從 0 開始，并且依次遞增，友善操作這

些元素；

2. 使用 java 數組：必須先聲明數組，再給該數組配置設定記憶體；

3. 數組對應在記憶體中一段連續空間。

4. 數組元素必須是相同資料類型，也可以是引用資料類型，但是同一個數組中的元素必須

是同一類資料類型。

8、一維數組的聲明與初始化：

一維數組：可以了解為一列多行、類型相同的資料，其中每個資料被稱為數組元素；

一維數組的聲明方式：

type varname[]; 或 type[] varname;(推薦)

eg：int age[]; int []age;

數組的長度一旦确定,就不能改變,也就數組是定長的;

我的總結：java 語言聲明數組的時候不能指定其長度（元素的個數）

eg：int a[5]; //非法

初始化：

java 中的數組必先初始化才可以使用，所謂初始化就是為數組的數組元素配置設定記憶體，并為每

個數組元素指派；

數組初始化的兩種方式：

靜态初始化：初始化時由我們自己指定每個數組元素的初始值，由系統決定需要的數組長度；

格式：數組名 = new 數組類型[]{元素 1,元素 2,元素 3...元素 n};

簡化文法：數組名 = {元素 1,元素 2,元素 3...元素 n};

動态初始化：初始化時由我們指定數組的長度，由系統為數組元素配置設定初始值；

格式：數組名 = new 數組類型[數組長度];

不能靜态和動态初始化同時使用：

也就是說不能同時指定數組的長度和元素；

eg:

* 聲明數組及初始化

public class demo3 {

int []age = new int[10];

//動态初始化

for (int i = 0; i < age.length; i++) {

age[i] = i;

system.out.print(age[i]+" ");

輸出：0 1 2 3 4 5 6 7 8 9

9、數組的使用：

java 語言的數組索引是從 0 開始的，也就是說數組裡的第一個元素的索引是 0,第二個元素的

索引是 1，依次可以類推。

常見操作：

給數組元素指派

數組名[索引] = 數組類型的值 ;

通路數組元素

數組類型 變量 = 數組名[索引];

得到數組的長度

int len = 數組名.length; //length 是數組的屬性

周遊數組（備注：length 屬性和循環語句）

數組元素的索引範圍（0，長度—1）

eg：判斷數組是否重複

* 判斷數組是否重複

int []age = {1,2,3,4,5,6,5};

for (int i = 0; i < age.length-1; i++) {//雙層循環，定住一個，

再考慮下一個！

for (int j = i+1; j < age.length; j++) {

if(age[i] == age[j]){

system.out.println("有重複的！"+i+" "+j);

break;

求最大值：

public class demo4 {

int age[] = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };

int max = age[0];

if (max < age[i]) {

max = age[i];

system.out.println(max);

經典用法：冒泡法排序

class bubblesort

public static void main(string args[])

int [] arr={5,1,6,4,2,8,9};

bubble(arr);

printarray(arr);

public static void bubble(int[] arr)

for (int i=0;i<arr.length-1 ;i++ )

for (int y=0;y<arr.length-i-1 ; y++) //讓每一次比較的元素減

少，-1是為了防止數組角标越界；

if(arr[y]>arr[y+1]) //相鄰兩元素相比

int temp = 0;

temp = arr[y];

arr[y] = arr[y+1] ;

arr[y+1] = temp;

public static void printarray(int[] arr)

for (int i=0;i<arr.length ;i++ )

if(i!=arr.length-1)

system.out.print(arr[i]+",");

else

system.out.println(arr[i]);

//選擇排序

int []age = {1,2,36,363,56,95,12,32,1232,3263};

for (int j = i+1; j <= age.length-1; j++) {

if(age[i] > age[j]){

int temp = age[i];

age[i] = age[j];

age[j] = temp;

system.out.println(arrays.tostring(age));

//輸出為：[1, 2, 12, 32, 36, 56, 95, 363, 1232, 3263]

10、配置設定記憶體空間

配置設定記憶體空間

數組名=new 資料類型[數組長度]；

new 關鍵字用來實作為數組或對象配置設定記憶體 （堆記憶體）

數組具有固定的長度。擷取數組的長度： 數組名.length

定義數組+配置設定記憶體空間

資料類型[]數組名=new 資料類型[數組長度];

定義數組時不指定長度，配置設定空間時指定數組長度；如：string cities[] = new string[6];

數組元素：

數組名[下标值];

數組下标從 0 開始 scores[0]=75；

數組的記憶體配置設定 棧記憶體和堆記憶體

如定義一個數組 int[]scores 将在棧記憶體中為 scores 配置設定記憶體空間，其值是一個不确定的值。

當執行語句 scores=new int[5]時，将在堆記憶體配置設定連續 5 個空間，每個空間 4 個位元組，用于

存放整型資料，其初始值為 0，然後将該段空間首位址，也就是第一個元素的位址，比如

0*3000，賦給 scores 變量。該位址相當于一個指針，指向堆記憶體中配置設定的空間。此時堆記憶體

中配置設定的 5 個空間可以分别使用 scores[0],一直到 scores[4]來表示。當執行四個指派語句時，

分别用指定值填充到對應元素位置。如果此時将 null 值賦給 scores 時，scores 變量将不再指

向任何位置，此時堆記憶體中配置設定的空間就變成了垃圾，由垃圾回收器在某一時間進行回收。

在方法中定義的變量，包括基本資料類型變量和引用資料類型變量，都将在棧記憶體中配置設定空

間，當超過變量作用範圍後，自動回收

我的總結：初始化=定義數組+配置設定空間+指派

11、二維數組：

二維數組：(其實是一個一維數組，它的每一個元素又是一個一維數組),

可以看做是一張表格。

動态初始化

int[ ][ ] arr = new int[3][2];

定義了一個二維數組，其中有 3 個一維數組，每一個一維數組中有 2 個元素

靜态初始化

int[ ][ ] arr = new int[][]{{1,2},{3,4},{5,6}};

int[ ][ ] arr = {{1,2},{3,4},{5,6}};

int age[][] = new int[][]{{1,2},{3,4},{5,6,7}};

system.out.println(age[0].length);//2

system.out.println(age[2].length);//3

12、操作數組的工具類-arrays

static int binarysearch(type[] a, type key) 使用二分搜尋法來搜尋 key 元素在數組中的索引；若

a 數組不包括 key，傳回負數。（該方法必須已按升序排列後調用）。

static int binarysearch(type[] a, int fromindex, int toindex, type key) 使用二分搜尋法來搜尋

key 元素在數組中從 fromindex 到 toindex 的索引；若 a 數組不包括 key，傳回負數。（該方

法必須已按升序排列後調用）。

static boolean[] copyof(type[] original, int newlength) 複制指定的數組見下面備注

static byte[] copyofrange(type[] original, int from, int to) 将數組的指定範圍複制到一個新數

組。

static boolean equals(type[] a, type[] a2) 如果兩個數組長度相等和元素一一相等，則傳回 true

static void fill(type[] a, type val) 将 a 數組所有元素都賦為 val。

static void fill(type[] a, int fromindex, int toindex, type val) 将 a 數組從 formindex 到 tiondex 索

引之間的元素都賦為 val。

static void sort(type[] a) //sort(int[] arr)對指定的數組按數字升序進行排序。

static void sort(type[] a, int fromindex, int toindex) 對指定數組的從 formindex 到 tiondex 索引

之間的元素按數字升序進行排序。

static string tostring(type[] a) 傳回指定數組内容的字元串表示形式。多個數組元素之間用英

文逗号或空格隔開。

我的總結：使用數組工具類可以節省時間，提高效率，注意常查閱 api；

//使用arrays類

int[] age = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };

system.out.println(arrays.tostring(age));//直接列印出數組的方

法

int []age2 = {1,2,3,4,5,6,98,65,23};

int i = arrays.binarysearch(age2, 98);

system.out.println(i);

13、java5 新特性對數組的支援：

增強 for 循環 → for-each

for (參數類型 參數名 : 數組名) {

代碼塊

for (int i : age) {

這樣就用 for-each 把數組周遊輸出！

我的總結：for-each 用于數組和 iterable 對象！在以後的集合學習中還會經常用到 for-each

循環。