java基礎--------方法與一維數組

一、方法：

也就是c語言中的函數。指能夠完成特定功能的代碼塊。但是在java面嚮對象語言中，方法只是類中的一個成員，而類纔是面嚮對象語言的基本單位，就像組成社會的最基本單位是家庭一樣，類就像是家庭，而方法在java中只是家庭中的一個成員。但是在面向結構語言當中，函數則是基本的單位。

方法的格式爲：修飾符 返回值類型 方法名（參數類型 參數名1,參數類型 參數名2...）{

方法體；

return 返回值;

   }

像我們第一天在HelloWorld程序中的主方法，就是方法的一個典型代表。public static void main（String [] args){}這裏面的public就是權限修飾符，static是靜態修飾符，表示java虛擬機不用創建對象，就可以用類名直接調用該方法，void是返回值類型，表示沒有的意思，因此return可以省略不寫。main是該方法的名字，String [] args則是參數列表。因爲在Scanner之前，鍵盤錄入，都是通過String [] args來完成的。


1、在有主函數的類中，建立方法，必須是靜態的。因爲主函數是靜態的，爲了能夠讓靜態方法訪問靜態方法，因此其他函數也必須是靜態的。但是在別的類中，則沒有這樣的要求。比如

class Demo{
	public static void main(String [] args){
		String s="我實在是太喜歡黑馬了";
		show(s);
	}
	public static void show(String s){
		System.out.println(s);
	}
}

這是最典型的在主函數中調用方法了。如果show()中沒有static的話，編譯期間就會報錯。方法調用一般有三種：上面的例子就是其中的一種：單獨調用。因爲show（）是個沒有返回值的方法。所以要採用這種調用。再比如：

class Demo{
	public static void main(String [] args){
		int d=sum(2,3);//賦值調用
		System.out.println(d);
		System.out.println(sum(2,3));//輸出調用
	}
	public static int sum(int a,int b){
		int c=a+b;
		return c;
	}
}

如果方法時有返回值的，那麼單獨調用就不適合了，而需要賦值調用，或者輸出調用。

方法的注意事項：
A:方法不調用不執行
B:方法之間是平級關係，不能嵌套定義
C:方法定義的時候，參數是用，隔開的
D:方法在調用的時候，不用在傳遞數據類型
E:如果方法有明確的返回值類型，就必須有return語句返回。


方法重載：方法重載是指在同一個類中，方法名相同，參數列表不同。與返回值無關。參數列表是指參數的個數，以及參數對應的數據類型不同。

class Demo{
	public static void main(String [] args){
		String s="我要考黑馬";	
		int a=5;
//方法重載
		show(a,s);
		int b=5;
//方法重載
		show(a,b);
	}
	public static void show( int n,String s){
		for(int x=0;x<5;x++){
			for(int y=0;y<n;y++){
				System.out.print(s+" ");
			}
		System.out.println();
		}
	}


	public static void show(int a,int b){
		System.out.println(a+","+b);
	}
}

上面的這個例子就是方法重載，其中在Demo類中有兩個show()方法，但是這兩個show方法的參數類型不同，因此show(a,s)調用show方法時就會主動匹配show（int n,String s)。而當show(a,b)就可以主動匹配show(int a,int b).


二、數組：
數組是存儲同一種數據的多個元素的容器。數組既可以存儲基本數據類型，也可以存儲引用數據類型。但是數組的長度是固定的，就是當你在堆內存中new一個對象的時候，數組的長度就已經是固定的了。但是後面學到的集合長度就是可變的。但是集合只能存儲引用數據類型。


數組的特點是每個元素都有一個index索引，我們可以通過索引快速追蹤裏面的每個元素，其中規定第一個元素索引是0.最大的索引是arr.length-1；我們在定義數組時有兩種格式：
數據類型[] 數組名;

數據類型 數組名[];

數組的初始化也有兩種：
A：靜態初始化：int [] arr=new int []{1,2,3,4,5};
String [] s=new String []{"我","愛","黑","馬"};
String [] s1={"我","真","的","愛","黑","馬"};
B:動態初始化：int [] arr=new int [3];


一般情況下我們都會選擇靜態初始化的第三種。其實數組在new的時候，是建立在堆內存中的，如果數組類型不同，每個元素的默認值就不同：
byte,short,int,long 默認值爲0
float,double 默認值爲0.0
char默認值爲 '\u0000'
boolean 默認值爲false

引用類型默認值爲 null

下面就是數組的一些常見操作：

A:遍歷：這裏用簡單的for循環，其實後來還有for增強也可以用。
方式1：

public static void printArray(int[] arr) {
	for(int x=0; x<arr.length; x++) {
		System.out.println(arr[x]);
	}
}

方式2：

public static void printArray(int[] arr) {
	System.out.print("[");
	for(int x=0; x<arr.length; x++) {
	<span style="white-space:pre">	</span>if(x == arr.length-1) {
		<span style="white-space:pre">	</span>System.out.println(arr[x]+"]");
	<span style="white-space:pre">	</span>}else {
		<span style="white-space:pre">	</span>System.out.println(arr[x]+", ");
	<span style="white-space:pre">	</span>}<span style="white-space:pre">	</span>
	}
}

B:最值：如果學了Arrays類中的API之後，就可以通過sort()方法，給數組排序，然後最後一個元素就是最大的。第一個就是最小的。
最大值：

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;
}
				

最小值：

public static int getMin(int[] arr) {
	int min = arr[0];					
	for(int x=1; x<arr.length; x++) {
	<span style="white-space:pre">	</span>if(arr[x] < min) {
		<span style="white-space:pre">	</span>min = arr[x];
	<span style="white-space:pre">	</span>}
	}
					
	return min;
}

 C:逆序
方式1：

public static int reverse(int[] arr) {
	for(int x=0; x<arr.length/2; x++) {//這裏不存在偶數，奇數問題。
		int temp = arr[x];
		arr[x] = arr[arr.length-1-x];
		arr[arr.length-1-x] = temp;
	}
}
				

方式2：

public static int reverse(int[] arr) {
	for(int start=0,end=arr.length-1; start<=end; start++,end--) {
		int temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
	}
}

D:查表

public static String getString(String[] strArray,int index) {
	return strArray[index];
}

E:基本查找
方式1：

public static int getIndex(int[] arr,int value) {
	for(int x=0; x<arr.length; x++) {
		if(arr[x] == value) {
		return x;
		}
	}
	//因爲查找會出現沒有元素的情況，此時就返回一個沒有對應的-1索引。				
	return -1;
}

方式2：

public static int getIndex(int[] arr,int value) {
	int index = -1;
<span style="white-space:pre">	</span>for(int x=0; x<arr.length; x++) {
	<span style="white-space:pre">	</span>if(arr[x] == value) {
	<span style="white-space:pre">		</span>index = x;
	<span style="white-space:pre">		</span>break;
	<span style="white-space:pre">	</span>}
	}
	return index;
}

F：排序：排序的方法比較多，這裏就簡單介紹一個冒泡排序

public staitc void bubbleorder(int [] arr){
	for(int x=0;x<arr.length-1;x++){
		for(int y=0;y<arr.length-1-x;y++){
			if(arr[y]>arr[y+1]){
				int temp=arr[y];
				arr[y]=arr[y+1];
				arr[y+1]=temp;
			}
		}
	}
}