黑马程序员 函数与数组

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

1.  函数

什么是函数？

函数就是定义在类中的具有特定功能的一段独立小程序。

函数也称为方法。

              如何定义一个功能呢？

1)       它应该是一个封闭的区间。就是大括号。

2)       它需要有名称。

3)       需要有参与运算的数据。

4)       需要有定义该功能的结果类型

函数的格式：

修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)

       {

                     执行语句;

                     return返回值;

       }

       返回值类型：函数运行后的结果的数据类型。

       参数类型：是形式参数的数据类型。

       形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

       实际参数：传递给形式参数的具体数值。

       return：用于结束函数。

       返回值：该函数运算后的结果，该结果会返回给调用者。

函数的特点：

•   定义函数可以将功能代码进行封装

•   便于对该功能进行复用

•   函数只有被调用才会被执行

•   函数的出现提高了代码的复用性

•   对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

两个明确：

•    明确要定义的功能最后的结果是什么？

•    明确在定义该功能的过程中，是否需要未知内容参与运算

细节：

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

Ø  定义函数时，函数的结果应该返回给调用者，交由调用者处理。

Eg:

   int  getSum(int x,int y)

{

           return x+y;

}

       什么是方法的重载？

概念：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型或参数顺序不同即可。

存在的原因：

                     屏蔽了一个对象的同一类方法由于参数不同所造成的差异。

特点：

                     与返回值类型无关，只看参数列表。

       规则：两同三不同

         --同一个类，同一个方法名

         --不同：参数列表不同（类型、个数、顺序不同）

         --只有返回值不同不能构成方法的重载

         --只有形参的名称不同，不能构成方法的重载

       什么时候用重载？

   当定义的功能相同，但参与运算的未知内容不同，那么，这时就定义一个函数名称表示该功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

       练习。。 一下哪些函数是重载的哪些不是？ 

       void show(int a ,char b,double c){}

       1. void show(int x, char y, double z){}//没有重载  与原函数一样

       2.int show(int a, double c,char b){}//重载了 参数列表不同

       3.void show (int a, double c,char b){}//重载了参数列表不同 同上 

       4.boolean show (int c, char b)//重载了   参数列表不同

       5.void show（double c）//重载了  参数个数不同

       6.double show(intx, char y,double z)//没有重载 参数一致

       Eg

                   class Chongzai

{

           public static void main(String[] args) {

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

                System.out.println(ret);

            }

           publicstatic int name(int a,int b){

                int c = a+b;

                return c;

            }

            publicstatic int name(int a,int b, int m) {

                int c = a+b+m;

                return c;

            }

}

2.  可变参数

从java5开始出现了可变参数，这是对java方法及数组的拓展！方法中可以接受的参数不再是固定个数的，而是随着具体需求传递的多少来决定。

定义格式： 返回值类型  方法名(参数类型 ... 形式参数){      }

可变参数的特点：

Ø  只能出现在参数列表的最后；

Ø  位于变量类型和变量名之间，前后有无空格都可以;

Ø  调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

3.  数组

概念： 数组就是同一种类型那个数据的集合，是一个容器，是引用类型，存储在堆中。

好处:可以自动给数组中的元素从0开始编号，方便操作这些元素

格式:

1.      元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

int[] arr=new int[5]; 创建一个长度为5 的，变量名为arr,类型为整型的数组。

2.      元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

              int[] arr=new []{5,6,8,3,4}

       int[] arr={5,6,8,3,4}

 数组中常见问题：

       1、数组角标越界 //ArrayIndexOutofBoundsException

        Eg: int[] arr = new int[2];

System.out.println(arr[3]);

       2、空指针异常  //NUllPointerException 当引用没有任何指向，值为空的情况，该引用还在用于操作实体。

        Eg:  int[] arr = null;

System.out.println(arr[0]);

      数组的声明和初始化

                  一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素；

一维数组的声明方式：

                          type varName[]; 或 type[] varName;(推荐)

Eg：int age[]; int []age;

数组的长度一旦确定,就不能改变,也就数组是定长的;

初始化：

Java中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值；

数组初始化的两种方式：

静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；

格式：数组名 = new 数组类型[]{元素1,元素2,元素3...元素n};

简化语法：数组名 = {元素1,元素2,元素3...元素n};

 

动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；

格式：数组名 = new 数组类型[数组长度];

Eg:

public class Demo3 {

            public static void main(String[] args) {

                int []age =new int[10];

                //动态初始化

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

                    age[i] = i;

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

                }

            }

}

数组的操作

1.获取数组中的数据，通常会用到遍历（for循环），arr.length代表数组的长度

代码：

int[] arr=new int[5];

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

{

      arr[x];

}

2.打印数组中的元素，元素间用逗号隔开。

  int[]arr=new int[5];

  for(intx=0;x<arr.length;x++)

  {

        if(x!=arr.length-1)

         System.out.print( arr[x]+",");

         else

          System.out.print( arr[x]);

  }

3.获取最值

      //定义一个方法，返回最大值角标

      public static int  getmax(int[] arr){

        int max=0;//定义一个变量初始化数组的0角标值

        for(int x=0;x<arr.length;x++){//循环遍历数组

           if(arr[max]<arr[x]){//如果临时元素小于遍历到的元素

              max=x;//将遍历到的值的角标付给临时变量角标

            }

        }

        return max;    //返回最大值角标      

     }

4.数组排序-选择排序：内循环结束一次，最值出现在头角标位置上，第一个依次和后面的几个相比较

      public staticvoid  xuanze(int[] arr){

        for(int x=0;x<arr.length-1;x++){//控制比较的圈数

          for(inty=x+1;y<arr.length;y++)//控制每圈比较的次数

          {

              if(arr[x]>arr[y]){

              inttemp=arr[y];

              arr[y]=arr[x];

              arr[x]=temp;    

          }           

        }

       }

5.数组排序-冒泡排序：相邻的两个元素进行比较，第一圈，最值出现在最后。

            public static void  maopao(int[] arr){

               for(intx=0; x<arr.length-1;x++){ //控制比较的圈数

                       //控制每圈比较的次数 

        //-1是避免角标越界，-x是让每一次比较的元素减少

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

                       {

                               if(arr[y]>arr[y+1]){

                               int temp=arr[y+1];

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

                               arr[y]=temp;                                 

                        }

               }

             }

        6.数组置换

                public static void  maopao(int[] arr,int x, int y){

                       int temp=arr[x];

                        arr[x]=arr[y];

                        arr[y]=temp;

                 }

7.数组的一般查找：获取key第一次出现在数组中的位置，如果返回-1，则不存在

    public staticint  select(int[] arr,int key){            

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

                if(arr[x]==key){

                    returnx;

                }

        }

        return -1;

    }

8.数组的折半查找：可以提高查找效率，但是必须是有序数组

第一种方式：

  先找到头角标 和尾角标 

  min =0 //头角标

 max=arr.length-1;//尾角标

  mid=(min+max)/2;//中间角标

  在要找得的值和中间角标不相等的情况下，循环查找。

  如果要找的值比中间角标值大的话，头角标就是中间角标+1；

  如果要找的值比中间角标小的话，尾角标就是中间角标-1；

  中间角标重新赋值 mid =(min+max)/2;//中间角标

  查找之后，如果头角标大于了尾角标的话 ，数组中就没有这个值，

第二种方式：

 如果头角标和尾角标之间有距离，也就是说头角标和尾角标小于等于尾角标的时候，就进行折半。否则不存在 返回 -1

 mid=(min+max)/2;//中间角标

 之后呢  如果要找的值比中间角标值大的话，头角标就是中间角标+1；

 如果要找的值比中间角标小的话，尾角标就是中间角标-1；

如果相等的话 就返回中间角标值。找到了

Eg:

进制转换

            //十进制转二进制

             public static  void tobin(int num)

             {

StringBuffer sb=new StringBuffer();//创建一个StringBuffer容器用于接收对2取模的数

                while(num>0){

                       sb.append(num%2);

                       num=num/2;

                }

                System.out.print(sb.reverse());

              }

             //十进制转十六进制

             publicstatic  void toHex(int num)

             {

                StringBuffersb=new StringBuffer();

                for(intx=0;x<8;x++)

                {

                    inttemp=num & 15;

                    if(temp>9)

                       sb.append((char)(temp-10+'A'));

                    else{

                       sb.append(temp);

                       num=num>>>4;

                    }

                    System.out.println(sb.reverse());

               }

4.  二维数组

二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组),

可以看做是一张表格。

动态初始化

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

定义了一个二维数组，其中有3个一维数组，每一个一维数组中有2个元素

静态初始化

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

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

Eg：

public class Demo3 {

           public static void main(String[] args) {

               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

}

}

        二维数组的遍历

        for(intx=0;x<arr.length;x++){

           for(int y=0;y<arr[x].length;y++)

           {

              sum=sum+arr[x][y];

           }

        }

       练习：

       int[] x,y[];x是一维数组，y是二维数组。相当于int x[]  int y[][];

a)x[0]=y  //错误

b)y[0]=x  //正确 两边都是一维数组

c)y[0][0]=x; //错误

d)x[0][0]=y;//错误

5.  操作数组的工具类-Arrays

static intbinarySearch(type[] a, type key) 使用二分搜索法来搜索key元素在数组中的索引；若a数组不包括key，返回负数。（该方法必须已按升序排列后调用）。

static intbinarySearch(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 booleanequals(type[] a, type[] a2) 如果两个数组长度相等和元素一一相等，则返回 true

static voidfill(type[] a, type val) 将a数组所有元素都赋为val。

static voidfill(type[] a, int fromIndex, int toIndex, type val) 将a数组从formIndex 到tiondex索引之间的元素都赋为val。 

static voidsort(type[] a) //sort(int[] arr)对指定的数组按数字升序进行排序。

static voidsort(type[] a, int fromIndex, int toIndex) 对指定数组的从formIndex 到tiondex索引之间的元素按数字升序进行排序。

static StringtoString(type[] a) 返回指定数组内容的字符串表示形式。多个数组元素之间用英文逗号或空格隔开。

Eg：

//使用Arrays类

public class Demo4 {

    public static void main(String[] args) {

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

    }

}

6.  Java5新特性对数组的支持：增强For循环

格式：for(元素类型 变量名 :Collection集合 & 数组 ) { }

        高级for循环和传统for循环的区别：?

            高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，需要使用迭代器。

Eg:

        public class Demo6 {

           public static void main(String[] args) {

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

               for (int i : age) {

                   System.out.println(i);

               }

           }

}

总结：

a)  函数的返回值类型如果是void时，return语句可以省略不写。

b)  方法的重写：方法名保持一致，子类权限修饰符可以大于等于父类的，子类的返回值类型小于等于父类的类型，子类声明异常类型不能超过父类的类型

c)  可变参数必须定义在参数列表结尾(也就是必须是最后一个参数，否则编译会失败)。

d)  使用Java数组：必须先声明数组，再给该数组分配内存；

e)  使用数组工具类Arrays能更容易的操作数组

f)  数组对应在内存中一段连续空间。

g)  数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须是同一类数据类型。

h)  java语言声明数组的时候不能指定其长度（元素的个数）

i)  增强for循环括号里写两个参数，第一个是声明一个变量，第二个就是需要迭代的容器?

j)  如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

详细请查看：www.itheima.com