函数（方法）与数组

来源：互联网发布：linux eth0配置ip 编辑：程序博客网时间：2024/04/28 02:38

《函数（方法）与数组》

1. 函数

1.1 函数介绍

在程序设计中，常将一些常用的功能模块编写成函数，放在函数库中供公共选用。利用函数，以减少重复编写程序段的工作量。许多程序设计语言中，可以将一段经常需要使用的代码封装起来，在需要使用时可以直接调用，所以，函数也可以说是许多代码的集合，这就是程序中的函数。

1.2 函数定义

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

格式：修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，…){

//执行语句

return 返回值;

}

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

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

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

实际参数：调用函数时，传递给形式参数的具体数值。

return：1.用于结束函数 2.把结果给调用者。

如果返回值类型是void(空),那么return可以省略，不是void,return不可省略。

返回值：该函数运算的结果，结果的数据类型必须与返回值类型一致。该结果会返回给调用者。

例：

public static void main(String[] args) {        int sun = add(3,7);        System.out.println("求两个数据的和："+sun); //10}public static int add(int a,int b){    int c = a+b;    return c;}

1.3 函数(方法)的特点

a. 定义函数可以将功能代码进行封装，便于对该功能进行复用。

b. 函数只有被调用才会被执行。

c. 函数的出现提高了代码的复用性。

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

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

return:

结束返回
返回方法执行的结果。
如果是void可以省略不写。
如果写可以写一个，也可以写多个。
后面不能直接跟语句，永远都执行不到。

void: 说明该函数执行完成后没有返回结果。

public static void main(String[] args) {        print();        String scoreLevel = scoreLevel(95);        System.out.println("your score level is :"+scoreLevel);}public static void print(){    System.out.println("没有返回值的函数"); }    public static String scoreLevel(int score){    if(score > 90){         return "good";    }else if(score > 60){         return "not bed";    }else{        return "fail";    }}

1.4 函数的应用

1.4.1 函数应用无返回值

public static void main(String[] args) {        print(3,5);    }        //方法的定义，定义时写执行代码，形式参数，可传可不传，可以有多个    public static void print(int row, int col){//()形参是有用的，但又是未知的        for (int i = 0; i < row; i++) {            for (int j = 0; j < col; j++) {                System.out.print("* ");            }            System.out.println(); //换行        }    }

1.4.2 函数应用之求两个数中的最大数

public static void main(String[] args) {        double i = 2.3;        double j = 6.3;        double max = getMax(i, j);        System.out.println(max); //6.3    }        public static double getMax(double i,double j){        return i>j?i:j;    }

1.4.3函数应用之有返回但不接受使用

public static void main(String[] args) {        int i = 5;        test(i);//函数有返回值，但我们并没有接受，i还是main方法的值        System.out.println(i); //5    }        public static int test(int i){        i = i+10; //此时i是test函数中的一个局部变量，并不是main中的i，只是名称一样而已        System.out.println("haha"+i); //haha15        return i;    }

1.5 函数(方法)的重载（overload）

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法

具体规范：

一.在同一个类中，方法名一定要相同。

二.方法的参数表必须不同，包括参数的类型或个数，以此区分不同的方法体。

1.如果参数个数不同，就不管它的参数类型了！

2.如果参数个数相同，那么参数的类型必须不同。

三.方法的返回类型、修饰符可以相同，也可不同（不做限制）。

1.6 函数重载的应用

给出两个数，求出最小值。给出三个数，求出最小值。给出4个数，求出最小值。

1. 比较麻烦的实现

public static void main(String[] args) {        System.out.println(getMin(3,5));//3        System.out.println(getMin(3,5,1));//1        System.out.println(getMin(3,5,1,9));//1    }        /*     * 给出2个数，求出最小值。     * 给出3个数，求出最小值。     * 给出4个数，求出最小值。     * 比较麻烦的实现     */    public static int getMin(int i,int j){        return i<j?i:j;    }        public static int getMin(int i,int j,int k){        int min = i<j?i:j;        return min<k?min:k;    }        public static int getMin(int i,int j,int k,int l){        int min = i<j?i:j;        int min2 = min<k?min:k;        return min2<l?min2:l;    }

2. 优化方案

public static void main(String[] args) {        System.out.println(getMin(3,5));//3        System.out.println(getMin(3,5,1));//1        System.out.println(getMin(3,5,1,9));//1    }        /*     * 给出2个数，求出最小值。     * 给出3个数，求出最小值。     * 给出4个数，求出最小值。     * 优化方案的实现     */    public static int getMin(int i,int j){        return i<j?i:j;    }        public static int getMin(int i,int j,int k){        /*int min = getMin(i, j);        return getMin(min, k);*/                return getMin(getMin(i, j), k);    }        public static int getMin(int i,int j,int k,int l){        /*int min = getMin(i, j);        int min2 = getMin(min, k);        return getMin(min2, l);*/                return getMin(getMin(i, j, k), l);    }

2. 数组

所谓数组，就是相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名，然后用编号区分他们的变量的集合，这个名字称为数组名，编号称为下标。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。数组是在程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来的一种形式。这些按序排列的同类数据元素的集合称为数组。

2.1 数组的定义

1）同一种类型数据的集合。其实数组就是一个容器。

2）变量能存数据，但是变量太多，用起来不方便，我们就要使用数组来存储多个同种类型的数据。

3）数组是连续的有标号的一片内存空间。

4）标号从0开始，到leng-1结束

5）数组是有长度的

2.2 创建数组的两种格式

格式一：

元素类型[] 数组名 = new 元素类型[元素个数即数据长度];

示例：int[] arr = new int[10];

说明：

数组长度不能是负数
数组使用以前不能是null
数组使用时不要下标越界

格式二：

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

可简写为：元素类型[] 数组名 = {元素，元素，……};

示例： int[] arr = new int[]{1,3,5,};

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

public static void main(String[] args) {        /*         * 数组定义格式一         *          */        int[] array = new int[5];                /*         * 数组定义格式二         *          */        int[] array2 = new int[]{1,2,3};        int[] array3 = {1,2,3};                /*         * 数组不能为null，使用时会报java.lang.NullPointerException         * int[] array4 = null;         * System.out.println(array4.length); //java.lang.NullPointerException         */                /*         * 数组长度不能为负数，运行程序时会报java.lang.NegativeArraySizeException         * int[] array5 = new int[-1]; //java.lang.NegativeArraySizeException         *          */                //给数组赋值        array[0] = 0;        array[1] = 1;        array[2] = 2;        array[3] = 3;        array[4] = 4;                /*         * 数组下标越界，运行时报错 java.lang.ArrayIndexOutOfBoundsException         * array[5] = 5; //java.lang.ArrayIndexOutOfBoundsException         */                  /*         * 数组取值          */        System.out.println(array[0]);        System.out.println(array[1]);        System.out.println(array[2]);        System.out.println(array[3]);        System.out.println(array[4]);    }

2.3 数组默认初始值

1）数组定义时，如果没有指定初始值，那么系统就会提供默认值。值与数据类型有关。

byte,short,int,long: 0

float,double : 0.0

char: ‘ ‘

Boolean: false

2.4 数组内存分配

2.4.1 数组运行时会进入到堆内存中

2.4.2基本数据类型运行不会进入堆内存

3. 二维数组

1）二维数组本质上是以数组作为数组元素的数组，即“数组的数组”。

2）Java中的二维数组是不规则矩形。

3）二维数组中装的是一维数组。

4）一维数组中装的是元素。

二维数组的格式

3.1.1 格式一：定义不初始化值

元素类型[][] 数组名 = new 元素类型[常量表达式1][常量表达式2];

元素类型数组名[][] = new 元素类型[常量表达式1][常量表达式2];

只是形式上的差别，大家可以根据自己的习惯来选择。

示例：

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

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

说明：将常量表达式1称为二维数组的一维，常量表达式2称为二维数组的二维。普通数组称为一维数组。

赋值：

public static void main(String[] args) {              /*         * 二维数据定义格式一         */        int array[][] = new int[3][2];        int [][]array2 = new int[3][2];                array[0][0] = 0;        array[0][1] = 1;        array[1][0] = 2;        array[1][1] = 3;        array[2][0] = 4;        array[2][1] = 5;                for (int i = 0; i < array.length; i++) {            //获取每一个一维数组            for (int j = 0; j < array[i].length; j++) {                //每一个一维数组中的元素                System.out.println("array["+i+"]["+j+"]="+array[i][j]);            }        }    }

3.1.2 格式一：扩展定义

元素类型[][] 数组名 = new 元素类型[常量表达式1][];

二维数组定义不初始化值时，一维必须存在，二维可以没有，但是在使用这个数组之前必须将二维数组的二维赋值。

Case1: 先定义二维数组，二维的值为null,再为每一个二维赋值一个一维数组，最后为每一个一维数组赋值。Java中的二维数组是不规则矩形，二维所对应的一维数组长度可以不一样。

public static void main(String[] args) {              /*         * 二维数据定义格式一扩展写法一         */        double array[][] = new double[2][];        array[0] = new double[2];        array[1] = new double[3];        array[0][0] = 1;        array[0][1] = 2;        array[1][0] = 3;        array[1][1] = 4;        array[1][2] = 5;                for (int i = 0; i < array.length; i++) {            //获取每一个一维数组            for (int j = 0; j < array[i].length; j++) {                //每一个一维数组中的元素                System.out.println("array["+i+"]["+j+"]="+array[i][j]);            }        }            }

Case2: 先定义二维数组，二维的值为null,再给二维赋值一维数组的同时给元素赋值。Java中的二维数组是不规则矩形，二维所对应的一维数组长度可以不一样。

public static void main(String[] args) {              /*         * 二维数据定义格式一扩展写法二         */        int array[][] = new int[2][];        array[0] = new int[]{1,2};        array[1] = new int[]{4,5,6};                for (int i = 0; i < array.length; i++) {            //获取每一个一维数组            for (int j = 0; j < array[i].length; j++) {                //每一个一维数组中的元素                System.out.println("array["+i+"]["+j+"]="+array[i][j]);            }        }            }

3.1.3 格式二：定义的同时初始化值

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

可简写为：元素类型[] 数组名 = { {元素，元素，…},{元素，元素，…}…};

示例：int array[][]=new int[][]{{1,2},{2,3},{3,4,5}};

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

public static void main(String[] args) {        /*         * 二维数据定义格式二，定义时同时初始化值         */        int array[][]=new int[][]{{1,2},{2,3},{3,4,5}};        for (int i = 0; i < array.length; i++) {            //获取每一个一维数组            for (int j = 0; j < array[i].length; j++) {                //每一个一维数组中的元素                System.out.println("array["+i+"]["+j+"]="+array[i][j]);            }        }    }

3.1.4 二维数组默认值

当使用格式一定义二维数组时，只给其中一部分元素赋值，未赋值的元素的默认值与数组的类型有关（见数组默认初始值）。

public static void main(String[] args) {        /*         * 二维数据定义格式二，定义时同时初始化值         */        double array[][]=new double[2][3];        array[0][0]= 1;        array[1][0]= 4;        array[1][1]= 5;                for (int i = 0; i < array.length; i++) {            //获取每一个一维数组            for (int j = 0; j < array[i].length; j++) {                //每一个一维数组中的元素                System.out.println("array["+i+"]["+j+"]="+array[i][j]);                //array[0][0]=1.0                //array[0][1]=0.0                //array[0][2]=0.0                //array[1][0]=4.0                //array[1][1]=5.0                //array[1][2]=0.0            }        }            }

0 0