Java基础学习第五天（函数、一维数组、二维数组）

一、函数（方法）

1、函数的作用： 提高功能代码的复用性

2、函数的定义格式

    修饰符  返回值类型  函数名(形参列表){
        需要被封装的功能代码；
        return 结果;
    }

class Demo5.1{
    public static void main(String[] args){
        int sum = add(2,3); //调用了add名字的函数
        System.out.println("结果："+ sum);
    }
    //做加法功能的函数
    public static int add(int a,int b){ // a、b 形式参数: 形式参数的值是交给调用者确定的
        return a+b;
    }
}   

① 修饰符：public static。
② 返回值类型： int 。返回值类型就是指函数运行完毕后返回的结果的数据类型。
注意： 某些函数是没有结果返回给调用者的，那么这时候返回值类型是void。
③ 函数名：add。
函数名的作用：如果需要调用该函数就需要使用的函数名。
函数名的命名规范： 首单词全部小写，其他单词的首字母大写，其他小写。
④ return：把一个结果返回给调用者。
⑤ 形式参数： 如果一个函数在运行的时候，存在着数据是要调用者确定的，那么这时候就应该定义形式参数。

3、函数定义好之后，是需要被调用才会执行的。 main函数是有jvm调用的，不需要我们手动调用。

4、如何定义一个函数：
① 返回值类型。
② 是否存在未知的参数(是否存在要由调用者确定的参数)

class Demo5.2{
    public static void main(String[] args){
        int max = getMax(14,5); //调用了函数 实际参数
        System.out.println("最大值："+ max);
    }
    //定义一个函数比较两个int类型的数据大小，把最大值返回给调用者
    public static int getMax(int a, int b){// 形式参数
        int max = 0; //定义一个变量用于保存最大值的
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        return max; //把结果返回给调用者
    }
}

5、需求1： 定义一个函数判断一个分数的等级，把分数的等级返回给调用者。
① 返回值类型：String
② 未知的参数：分数
需求2： 定义一个函数打印一个乘法表，不需要返回任何数据。
① 返回值类型： void
② 未知的参数：几乘几的乘法表

class Demo5.3 {
    public static void main(String[] args){
        String result = getGrade(96);
        System.out.println(result);

        print(7);
    }
    //需求1： 定义一个函数判断一个分数的等级，把分数的等级返回给调用者。
    public static String getGrade(int score){
        String grade = "";  //定义一个变量存储等级
        if(score>=90&&score<=100){
            grade = "A等级";
        }else if(score>=80&&score<=89){
            grade = "B等级";
        }else if(score>=70&&score<=79){
            grade = "C等级";
        }else if(score>=60&&score<=69){
            grade = "D等级";
        }else if(score>=0&&score<=59){
            grade = "E等级";
        }else{
            grade = "补考";
        }
        return grade;//把等级返回给调用者
    }
    //需求2： 定义一个函数打印一个乘法表，不需要返回任何数据。 
    public static void  print(int row){
        for(int i = 1 ; i<= row ; i++){
            for (int j = 1 ;j<=i  ;j++ ){
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            System.out.println();//换行
        }
    }   
}

6、函数的特点
① 函数的作用就是把一个功能代码给封装起来，以达到提高功能代码的复用性。
② 函数定义好之后是需要被调用才会执行的。
③ 如果一个函数没有返回值返回给调用者，那么返回值类型必须用void表示。

7、注意
① 如果一个函数的返回值类型是具体的数据类型，那么该函数就必须要保证在任意情况下都保证有返回值。（除了返回值类型是void以外）
② 一个函数的返回值类型是void，那么也可以出现return关键字，但是return关键字的后面不能有数据。

8、函数的重载
① 函数的重载：在一个类中出现两个或者两个以上的同名函数，这个称作为函数的重载。
② 函数重载的作用： 同一个函数名可以出现了不同的函数，以应对不同个数或者不同数据类型的参数。
③ 函数重载的要求：函数名一致；形参列表不一致（形式参数的个数或者是对应的数据类型不一致）；与函数的返回值类型是无关的。

class Demo5.4{
    public static void main(String[] args){
        add(1,2);
        add(1,2.0);
    }
    // 这些函数都是在做加法运算
    public static double add(int a,int b){
        System.out.println("两个int参数的总和: "+ (a+b));
        return 3.14;
    }   
    public static int add(double a,double b){
        System.out.println("两个double参数的总和: "+ (a+b));
        return 12;
    }
    public static void add(int a,int b,int c){
        System.out.println("三个int参数的总和: "+ (a+b+c));
    }
    public static void add(int a,int b,int c,int d){
        System.out.println("四个int参数的总和: "+ (a+b+c+d));
    }
}

二、一维数组

1、数组：数组是存储同一种数据类型数据的集合容器。

2、对于 “ int[ ] grade = new int[3]; ” 这句语句而言

从左到右	解释
int[ ] grade	声明了一个int类型的的数组变量，变量名为grade
int	表示该数组容器只能存储int类型的数据
[ ]	这是一个数组类型
grade	变量名
=	赋值运算符，把数组对象内存地址赋值给grade变量
new int[3]	创建了一个长度为3的int类型数组对象
int	表示该数组对象只能存储int类型数据
[ ]	这是一个数组类型
3	该数组最多能存储3个数据，即数组的容量

3、数组的好处： 对分配到数组对象中每一个数据都分配一个编号（索引值、角标、下标），索引值的范围是从0开始，最大是数组长度-1。

class Demo5.5{
    public static void main(String[] args){
        //定义一个数组
        int[] arr = new int[4];
        arr[0] = 10;
        arr[1] = 30;
        arr[2] = 50;
        arr[3] = 90;        
        System.out.println("数组的容量："+ arr.length);//数组的有一个length的属性，可以查看数组的容量    
        //查看数组中的所有数据
        for(int index = 0 ; index<arr.length ; index++){
            System.out.println(arr[index]);
        }
    }
}

4、局部变量与成员变量
◆ 局部变量： 如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。
◆ 成员变量： 成员变量就是定义在方法之外、类之内的
◆ 区别
定义的位置上区别：
◇ 成员变量是定义在方法之外，类之内的。
◇ 局部变量是定义在方法之内。
作用上的区别：
◇ 成员变量的作用是用于描述一类事物的公共属性的。
◇ 局部变量的作用就是提供一个变量给方法内部使用而已。
生命周期区别：
◇ 随着对象的创建而存在，随着对象的消失而消失。
◇ 局部变量在调用了对应的方法时执行到了创建该变量的语句时存在，局部变量一旦出了自己的作用域那么马上从内存中消失。
初始值的区别：
◇ 成员变量是有默认的初始值。
◇ 局部变量是没有默认的初始值的，必须要先初始化才能使用。

5、数组中最常见的问题
① NullPointerException 空指针异常
原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。
② ArrayIndexOutOfBoundsException 索引值越界
原因：访问了不存在的索引值。

class Demo5.6 {
    public static void main(String[] args){
        /*
        int[] arr = new int[2];
        arr = null;//null让该变量不要引用任何的对象，不要记录任何的内存地址
        arr[1] = 10;
        System.out.println(arr[1]);     
        */
        int[] arr = new int[4];
        arr[0] = 10;
        arr[1] = 30;
        arr[2]  =40;
        arr[3] = 50;
        //System.out.println(arr[4]); //访问索引值为4的内存空间存储的值    
        }
    }
}

6、数组的初始化方式
① 动态初始化：数据类型[ ] 变量名 = new 数据类型[长度]
② 静态初始化：数据类型[ ] 变量名 = {元素1,元素2,…..}
注意：如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果
数据一开始还不太明确，这时候就建议使用动态初始化。

class Demo5.7 {
    public static void main(String[] args){ 
        //动态初始化
        int[] arr1 = new int[10];   
        //静态初始化
        int[] arr2 = {10,20,30,40,50};

        int[] arr = new int[10];
        Scanner scanner = new Scanner(System.in);
        for(int i  = 0 ; i< arr.length ; i++){
            arr[i] = scanner.nextInt();
        }
        for(int index = 0 ; index<arr.length ; index++){
             System.out.print(arr[index]+",");
        }
    }
}

7、需求： 定义一个函数接收一个int类型的数组对象，找出数组对象中的最大元素返回给调用者。

class Demo5.8 {
    public static void main(String[] args){
        int[] arr = {-12,-14,-5,-26,-4};
        int max = getMax(arr);
        System.out.println("最大值："+ max); 
    }
    public static int  getMax(int[] arr){
        int max = arr[0]; //用于记录最大值
        for(int i = 1 ; i < arr.length ; i++){
            if(arr[i]>max){ //如果发现有元素比max大，那么max变量就记录该元素
                max = arr[i];
            }
        }
        return max;
    }
}

8、需求： 目前存在数组：int[] arr = {0,0,12,1,0,4,6,0} ，编写一个函数接收该数组，然后把该数组的0清空，然后返回一个不存在0元素的数组。

import java.util.*;
class Demo5.9{
    public static void main(String[] args){
        int[] arr = {0,0,12,1,0,4,6,0};
        arr = clearZero(arr);
        System.out.println("数组的元素："+Arrays.toString(arr));
    }
    public static  int[] clearZero(int[] arr){
        //统计0的个数
        int count = 0;  //定义一个变量记录0的个数
        for(int i = 0 ; i<arr.length ; i++){
            if(arr[i]==0){
                count++;
            }
        }
        //创建一个新的数组
        int[] newArr = new int[arr.length-count];           
        int index = 0 ; //新数组使用的索引值
        //把非的数据存储到新数组中
        for(int i = 0; i<arr.length ; i++){
            if(arr[i]!=0){
                newArr[index] = arr[i];
                index++;
            }
        }
        return newArr;
    }
}

三、二维数组

1、二维数组： 二维数组就是数组中的数组。

2、二维数组的定义格式
数据类型[ ][ ] 变量名 = new 数据类型[长度1][长度2];

3、二维数组 的初始化方式
① 动态初始化：数据类型[ ][ ] 变量名 = new 数据类型[长度1][长度2]
② 静态初始化：数据类型[ ][ ] 变量名 = {{元素1,元素2,…},{元素1,元素2,…},{元素1,元素2,…} ..}

class Demo5.10{
    public static void main(String[] args){ 
        //定义了一个二维数组
        int[][] arr = new int[3][4];
        arr[1][1] = 100;
        System.out.println("二维数组的长度："+ arr.length);  //3
        System.out.println("二维数组的长度："+ arr[1].length); //4
    }
}

class Demo5.11{
    public static void main(String[] args){
        int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};
        //遍历二维数组
        for(int i = 0;  i <arr.length ; i++){
            for(int j = 0 ; j<arr[i].length ; j++){
                System.out.print(arr[i][j]+",");
            }           
            System.out.println();//换行
        }
    }
}

4、数组的特点
① 数组只能存储同一种数据类型的数据
② 数组是会给存储到数组中 的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1
③ 数组一旦初始化，长度固定
④ 数组中的元素与元素之间的内存地址是连续的

class Demo5.12{
    public static void main(String[] args){
        int[] arr = new int[3];
        arr = new int[4]; 
        System.out.println(arr.length);//4
    }
}