函數
函數（方法）：有特定功能的一小段代碼程序。
函數的格式：
修飾符 返回值類型 函數名（參數類型 形式參數，參數類型 形式參數2，……）
{
執行語句；
return返回值；
}
註解：
返回值類型：函數運行後的結果數據類型。
參數類型：是形式參數的數據類型。
形式參數：是一個變量，用於存儲調用函數時傳遞給函數的實際參數。
實際參數：傳遞給形式參數的具體數值。
return:用於結束函數。
返回值：該值會返回給調用者。
函數的作用：
《1》 當要獲取不同不同數值的運算結果，代碼會出現重複
《2》 爲了提高代碼的複用性，對代碼進行抽取，將這部分定義成獨立的功能，方便日後調用。
《3》 java中對代碼的定義是通過函數的形式實現的。
靜態函數只能調用靜態方法，主函數爲靜態（static）函數。
當函數運算後沒有具體的返回值時，這時的返回值類型用“void”代替，這時return可以不寫。
例如：
publicstatic void main(String args[]){
intx=getResult(4);
inty=getResult(6);
System.out.println(x+y);
}
public staticint getResult(int num){
return num*3+5;
}最小的函數單元是函數，那如何定義一個函數呢？
既然函數是一個獨立的功能，那麼該函數的運算結果是什麼要先明確。
《1》 明確返回值。
在明確該功能的過程中是否需要未知的內容參與運算？
《2》 明確形式參數及形參類型。
注意：功能參數只做功能，而輸出等是調用者來完成的。
例子：
public classFunctionTest{
public static void main(String[] args){
draw(5,6);
printHr();
draw(7,8);
printHr();
print99();
}
public static void print99(){
for(int x=1;x<=9;x++){
for(int y=1;y<=x;y++){
System.out.print(y+"*"+x+"="+y*x+"\t ");
}
System.out.println();
}
}
public static void draw(int row,int col){
for(int x=0;x<row;x++){
for(int y=0;y<col;y++){
System.out.print("*");
}
System.out.println();
}
}
public static void printHr(){
System.out.println("----------------------------");
}
}函數的重載
重載的概念：在同一個類中允許存在一個以上同名函數，只要他們的參數個數或參數類型不同即可；
特點：與返回值類型無關，只看參數列表（參數是有順序的）；
什麼時候用到重載：當定義的功能相同但參與運算的未知內容不同，那麼這時就定義一個函數名稱以表示其功能，方便閱讀，而通過參數列表的不同來區分多個同名函數。
數組
數組屬於引用行數據類型。
數組概念：同一種數據類型的集合。（其實數組是一個容器）。
格式：元素類型[] 數組名=new 元素類型[元素個數]；
例如：int[] arr=newint[3];
特點：（1）數組是固定的不能擴展
• （2）可以存儲基本數據類型或對象
• （3）通過數組名和下標可以訪問各元素，下標從0開始
棧內存和堆內存：
棧：棧內存中的數據使用完畢，會自動釋放。（局部變量都是放在棧內存中的）。
實體包括數組和對象。
堆：實體不放在棧內存中而是放在堆內存中。
實體：通過new創建出來的叫實體。
例如：在int[] arr=new int[3];其中arr放在 棧內存中，new出來的實體放在堆內存中，arr中放的是實體在堆內存中的地址值。arr就指向這個堆內存中的實體。
當arr=null；時（arr不再指向堆內存中的實體），堆中這些數組值就被視爲垃圾，就會被系統回收。
注意：堆內存裏的變量都有默認值。
1、整數類型（byte、short、int、long）的基本類型變量的默認值爲0。
2、單精度浮點型（float）的基本類型變量的默認值爲0.0f。
3、雙精度浮點型（double）的基本類型變量的默認值爲0.0。
4、字符型（char）的基本類型變量的默認爲 “/u0000”。
5、布爾性的基本類型變量的默認值爲 false。
6、引用類型的變量是默認值爲 null。
舉例：
（1） int[] x=newint[3];
int[] y=x; //x和y引用了同一個堆空間
y[1]=89; //其中y爲其更改，x中的也變了
（2） int[] x=newint[3];
int[] y=new int[3]; //與（1）不同，y有了一個新的地址
y[1]=89; //x[1]不會隨其改變值
數組定義：
<1>int[] arr=new int[3];
或int arr[]=newint[3];
<2>int[] arr=new int[]{3,1,6,5,4};
或int[]arr={3,1,6,5,4};//數組中的數據明確時常用
當數組中的數據不明確時：
int[] arr=newint[2];
arr[0]=90;
arr[1]=80;
注意：編譯直檢查語法錯誤，運行會才創建數組。
arr.length可以獲取數組arr的長度。
當輸出：System.out.println(arr);（arr爲數組）輸出的是arr的在堆存中的地址如：“[I@de6ced”“[”代表數組；“I”代表int型；“de6ced”代表堆內存中的地址值。
排序：
（1） 選擇排序
特點：最小值先在前面出現
public class Test1 {
public static void main(String[] args) {
int[] a={4,8,1,3,9,5,7,2};
/*調用選擇排序方法給數組元素排序*/
selectSort(a);
/*調用打印方法，打印排序後的數組*/
ptintSort(a);
}
/*創建冒泡排序方法*/
public static void selectSort(int[] arry){
for(int x=0;x<arry.length-1;x++){
for(int y=x+1;y<arry.length;y++){
if(arry[x]>arry[y]){
int temp=arry[y];
arry[y]=arry[x];
arry[x]=temp;
}
}
}
}
/*創建打印方法，並打印*/
public static void ptintSort(int[] arry){
System.out.print("排序後的數組 a={");
for(int x=0;x<arry.length;x++){
if(x<arry.length-1)
System.out.print(arry[x]+",");
else
System.out.println(arry[x]+"};");
}
}
（2） }冒泡排序
特點：大值先在後面產生
public class Test1 {
public static void main(String[] args) {
int[] a={4,8,1,3,9,5,7,2};
/*調用冒泡排序方法給數組元素排序*/
bubbleSort(a);
/*調用打印方法，打印排序後的數組*/
ptintSort(a);
}
/*創建冒泡排序方法*/
public static void bubbleSort(int[] arry){
for(int x=0;x<arry.length-1;x++){
for(int y=0;y<arry.length-x-1;y++){
if(arry[y]>arry[y+1]){
int temp=arry[y];
arry[y]=arry[y+1];
arry[y+1]=temp;
}
}
}
}
/*創建打印方法，並打印*/
public static void ptintSort(int[] arry){
System.out.print("排序後的數組 a={");
for(int x=0;x<arry.length;x++){
if(x<arry.length-1)
System.out.print(arry[x]+",");
else
System.out.println(arry[x]+"};");
}
}
}在java中的java。util包下有關於排序的算法：Arrays.sort(arr);//升序排序。
折半查找
在查找中的元素中沒有要查找的數時通常返回負數以表示數組中無此元素
如果有兩個查找的相同的元素，則返回前面那個元素的角標。
折半查找可以提高效率，但是數組需要是有序。
public class Zheban {
public static void main(String[] args) {
int arr[]={1,4,6,8,14,19};
System.out.print(halfSearch1( arr,5));
System.out.print(halfSearch2( arr,6));
}
public static int halfSearch1(int[] arr,int key){
int min,max,mid;
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 int halfSearch2(int[] arr,int key){
int min,max,mid;
min=0;
max=arr.length-1;
while(arr[min]<arr[max]){
mid=(max-min)>>1;
if(key>arr[mid])
min=mid+1;
else if(key<arr[mid])
max=mid-1;
else
return mid;
}
return -1;
}
}數組（進制轉換）
class ArrayTest7
{
public static void main(String[] args)
{
//toBin(-6);
//toHex(-60);
//toBa(60);
// System.out.println(Integer.toBinaryString(6));
// System.out.println(Integer.toHexString(6));
}
/*
十進制-->二進制
*/
public static void toBin(int num)
{
trans(num,1,1);
}
/*
十進制-->八進制
*/
public static void toBa(int num)
{
trans(num,7,3);
}
/*
十進制-->十六進制
*/
public static void toHex(int num)
{
trans(num,15,4);
}
public static void trans(int num,int base,int offset)
{
if(num==0)
{
System.out.println(0);
return ;
}
char[] chs = {'0','1','2','3'
,'4','5','6','7'
,'8','9','A','B'
,'C','D','E','F'};
char[] arr = new char[32];
int pos = arr.length;
while(num!=0)
{
int temp = num & base;
arr[--pos] = chs[temp];
num = num >>> offset;
}
for(int x=pos; x<arr.length; x++)
{
System.out.print(arr[x]);
}
return ;
}
}二維數組
int[][] arr=new int[3][4]
定義一個二維數組，二維數組中有3個一位數組，每個一位數組中有4個元素；3是二維數組的長度，4爲每個二維數組一位數組的長度。
如果做：System.out.println(arr);則輸出的是二維數組的地址值，如：[[I@3x4d6.
如果做：System.out.println（arr[0]）;則輸出的是二維數組中第一個一維數組的地址，如：[I@3de4。
如果做：System.out.println（arr.length）;則輸出的是二維數組的長度。
如果做：System.out.println（arr[0].length）;則輸出的是二維數組中第一個一維數組的長度。
在定義二維數組是必須定義二維數組的長度：
int[][] arr1=new int[3][];
如果做：System.out.println(arr1[0]);則輸出的結果爲null；爲什麼與上面不一樣呢，因爲它只定義的了二維數組爲三個一維數組而沒有定義其中的一維數組什麼樣子，所以在堆中默認數組爲null。
對二維數組中小數組初始化：arr1[0]=new int[3];
arr1[1]=newint[1];
arr1[2]=newint[2];
第二種定義數組方式：int[][] arr={{3,5,1},{2},{5,1}};
總結三種二維數組的定義方式：
《1》 int[][] y;
《2》 int y[][];
《3》 int[] y[];
《4》其中int[] x,y[];這種定義方式x爲一維，y爲二維；同時定義了兩個數組。
------- android培訓、java培訓、期待與您交流！ ----------詳細請查看：http://edu.csdn.net