黑马程序员---Java基础---函数和数组

-------  android培训 、 java培训 、期待与您交流！ ----------

函数和数组

一、函数

1.函数的定义
函数就是定义在类中的，具有特定功能的一段独立的小程序，函数又称为方法。

如果代码出现了重复，为了提高代码的复用性，对代码进行抽取，对这部分代码定义成一个独立的功能，即函数

2.函数定义的格式
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，、、、）
{
执行语句；
    return 返回值;
}
（1）修饰符：包括 private、public、static、final
当函数被private修饰时，表示此函数是私有的即只在被类中被调用，外部类不能调用。
当函数被public修饰时，表示此函数是公有的即除了可以在本类中被调用，外部类也可以直接调用此函数。
当函数被static修饰时，表示此函数为静态函数，则此函数中只能直接调用静态成员。并且静态函数随着
类的加载而加载，随着类的消失而消失。
（2）返回值类型：函数运行结束之后，结果的数据类型。
（3）参数类型：是形式参数的数据类型。
（4）形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
（5）实际参数：传递给形式参数的具体数值。
（6）return ：用于结束函数。当函数无返回值时，此时返回值类型用void关键字表示，并且return可以写，也可以
不写，不写的话系统会自动给加上。return的作用即结束函数、结束功能。
（7）返回值：该值会返回给调用者。

例子：
public static int getMax(int x,int y)
{
return (x>y)?x:y;
}
3.函数的分类
（1）主函数：保证一个类能够独立运行，是一个程序运行的入口，被jvm调用，主要用来调用函数。
（2）构造函数：给类的对象进行初始化。此函数名和类名一样，没有返回值类型及return。
（3）函数（方法）：定义在类中，并且当被别的函数调用时才能执行。注意，函数中不能再定义函数，只能是函
数调用函数。
4.函数的特点
（1）将代码进行封装，提高代码的复用性。
（2）函数只有被调用才会执行。

（3）函数没有具体返回值的时候，返回值类型用关键字void表示，函数的return语句如果在最后一行，可以不写。

注意：

1> 函数中只可以调用函数，不可以在函数内部定义函数。

2> 函数的结果应该返回给调用者，由调用者处理。

5.如何定义一个函数

通过函数定义的格式我们知道，一个函数最重要的两部分是：是否有返回值及返回值类型；是否要用到未知数据。

（1）是否有返回值及返回值类型：明确了函数的返回值类型。

（3）是否要用到未知数据：明确了函数的参数列表。

只要明确了这两个是否，函数就好定义了，下面来看个示例：

<span style="font-size:18px;">//功能：求两个整数的和
//是否有返回值以及返回值类型？ 有   两个整数的和还是整数
//是否需要用到未知数据？     是  因为不确定是哪两个整数
int getSum(int x, int y)
{
	return x+y;
}</span>

6.函数的重载

（1）概念

在一个类中，如果出现了一个或多个同名函数时，只要他们的参数列表（参数个数或者参数类型）不同即为该函数的重载。

（2） 什么时候使用重载呢？

当函数的功能相同，但是参数运算的未知内容不同，那么，这时就定义一个函数名称以表示其功能，方便阅读，
而通过参数列表（参数个数或者参数类型或者参数顺序）的不同，来区分多个同名函数。

注意：

1> 函数的重载和两个函数的返回值类型是否相同无关，只看两个函数的参数列表（参数个数或者参数类型或者参数顺序）的不同。

2> 函数还有个复写的特性，在讲述继承时会将函数的重载和复写进行比较区别。

（3）重载示例

int add(int x, int y){return x+y;}
double add(int x, double y){return x+y;}
double add(double x, int y){return x+y;}
int add(int x, int y, int z){return x+y+z;}

二、数组

1、数组的定义

同一种类型数据的集合，其实数组就是一个容器。一次装进来的数据的类型必须一样。
2、数组的特点

（1）自动给数组中的元素从0开始编号，方便操作这些元素

（2）数组一旦被定义，其数组的长度固定，不可变，所以给数组增加元素的动作要小心。
（3）数组中元素的类型一样。
3、数组的分类

一维数组、二维数组。

4.数组定义格式
（1）一维数组
元素类型[] 数组名=new 元素类型[元素个数或数组长度];
int[] arr=new int[3];
元素类型[] 数组名=new 元素类型[]{元素1，元素2，、、、};
int arr=new int[]{1,3,5};
元素类型[] 数组名={元素1，元素2，、、、};
int[] arr={1,3,5,7};
（2）二维数组
元素类型[][] 数组名=new 元素类型[二维数组长度][二维数组中每一个一维数组的长度];
int[][] arr=new int[3][4];
元素类型[][] 数组名={{1,3,5,2},{4,3,1},{5,9,8,0}};

注意：

“[]”方括号可以放在数组名的后面，如 int arr[] = new int[3];
5.数组操作中常见问题

（1）数组脚标越界异常 ArrayIndexOutOfBoundsException

int arr[] = new int[3];

arr[3] = 3;

访问不存在的数组元素

（2）空指针异常 NullPointerException

int arr[] = null;

arr[3] = 3;

arr引用性变量没有指向任何实体

6.数组的遍历
（1）遍历一维数组
第一种遍历方式:利用普通for循环

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

第二种遍历方式：利用增强for循环

for (int arrs:arr )
{
      System.out.println(arrs);
}

（2）遍历二维数组

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

7.数组的应用
包括：求最大值，最小值，冒泡排序，选择排序，折半查找，进制转换

<span style="font-size:18px;">/** 
对数组的各种操作封装成类，以方便以后方便对数组的操作。 
@author 史世锋
@version V1.0 
*/  
  
class ArrayTool   
{  
    /** 
    获取整型数组中元素的最大值，获取最大值是通过遍历数组比较得到的， 
    所以每次比较之后最大值存起来，所以每次的最大值并不确定，所以 
    最大值用一个变量来存储，将每次比较得到的最大值存放在此变量中。 
    @param arr 接收一个int类型的数组。 
    @return 会返回该数组中的最大值。 
    */  
    public static int getMax(int[] arr)  
    {  
        int max=0;  
        for (int x=1;x<arr.length ;x++)  
        {  
            if (arr[x]>arr[max])  
            {  
                swap(arr,x,max);  
            }  
        }  
        return arr[max];  
    }  
    /** 
    获取整型数组中元素的最小值。 
    @param arr 接收一个int类型的数组。 
    @return 返回此数组中元素的最小值。 
    */  
    public static int getMin(int[] arr)  
    {  
        //定义一个变量，将每次比较的最小值得角标付给min来保存。  
        int min=0;  
        for (int x=1;x<arr.length;x++ )  
        {  
            if (arr[x]<arr[min])  
            {  
                swap(arr,x,min);  
            }  
        }  
        return arr[min];  
    }  
    /** 
    对int类型的数组进行选择排序。每次用数组中的元素以此与此元素 
    后面的元素进行比较，将最值放在此元素处。 
    @param arr 接收一个int类型的数组。 
    */  
    public static void selectSort(int[] arr)  
    {  
        //外循环表示总共比较多少次  
        for (int x=0;x<arr.length-1;x++ )  
        {  
            //内循环表示每次外循环需要进行多少次的比较  
            for (int y=x+1;y<arr.length;y++ )  
            {  
                if (arr[x]>arr[y])  
                {  
                    swap(arr,x,y);  
                }  
            }  
        }  
    }  
    /** 
    对数组进行冒泡排序。此排序原理，将数组中相邻的两个元素进行比较， 
    每比较一圈之后，其最值都会出现在数组的最后的位置。 
    @param arr 接收一个int类型的数组。 
    */  
    public static void bubbleSort(int[] arr)  
    {  
        //外循环表示总共比较多少次  
        for (int x=1; x<=arr.length-1; x++ )  
        {  
            //内循环表示每次外循环需要进行多少次的比较  
            for (int y=0; y<arr.length-x; y++ )  
            {  
                if (arr[y]>arr[y+1])  
                {  
                    swap(arr,y,y+1);  
                }  
            }  
        }  
    }  
    /** 
    对数组中的元素进行位置置换。 
    @param arr 接收一个int类型的数组。 
    @param x 要置换的位置。 
    @param y 要置换的位置。 
    */  
    private static void swap(int[] arr,int x,int y)  
    {  
        int temp=arr[x];  
        arr[x]=arr[y];  
        arr[y]=temp;  
    }  
    /** 
    给定一个元素，查找此数组中是否有此元素，若有的话 
    则给出此元素在数组中的角标，否则的话，返回-1。 
    利用折半查找法进行查找，前提:此数组是有序的。 
    @param arr 接收一个int类型的数组。 
    @param key 要进行查找的元素。 
    */  
    public static int halfSearch(int[] arr,int key)  
    {  
        int min=0,max=arr.length-1,mid;  
        //前提是min角标不能大于max角标  
        while (min<=max)  
        {  
            //每次比较的时候找到中间位置  
            mid=(min+max)/2;  
            //让key和中间位置的元素进行比较  
            if (key>arr[mid])  
            {  
                min=mid+1;  
            }  
            else if (key<arr[mid])  
            {  
                max=mid-1;  
            }  
            else  
                return mid;  
        }  
        return -1;//若此处写成return min;则代表此函数的功能是在数组中插入一个给定的元素，  
                  //插入之后，依然保持此数组是有序的，所以利用折半查找的方法，找出要插入此  
                  //元素的位置。  
    }  
    /** 
    利用查表法对数进行进制转换。 
    @param num 要进行进制转换的数。 
    @param base 在进制转换中要进行&的数 
    @param offset 对num进行无条件右移的位数。 
    */  
    public static void trans(int num,int base,int offset)  
    {  
        //定义一个数组，用来存放在数组转化的过程中出现的各种值。  
        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)  
        {  
            //每次都将右移offset之后的数和base进行与运算，来得到相应的进制值  
            int temp=num&base;  
            arr[--pos]=chs[temp];  
            //将num右移offset位  
            num=num>>>offset;  
        }  
        //打印得到的进制值  
        for (int x=pos;x<arr.length ;x++ )  
        {  
            System.out.println(arr[x]);  
        }  
    }  
}  </span>