初识JAVA06：方法的参数，return，方法的重载，方法的递归，数组，增强for循环

方法

方法的参数

方法的参数分为形参和实参

形参：形式参数，定义方法时的()中的参数

​ 作用域：相当于局部变量，只在当前方法中有效

实参：实际参数，在调用方法时()中的参数

​ 作用域：相当于为局部变量赋值—>>赋值给形参

形参不存在默认值

实参须和形参的数量，位置，类型一一对应

return

return
有返回值类型的方法中: 必须存在!!!必须带出返回值 1)提前结束方法 2)带出返回值
没有返回值类型的方法中: 1)提前结束方法

注意:
不可达语句出现:
1)return后面出现其他语句
2)break后面直接出现的语句
3)continue后面直接出现的语句
4)while–true|死循环后的代码
5)while(false){中的代码

兼容类型:
形参与实参之间 : 实参类型<=形参类型
返回值类型 : 接收方法返回值变量的类型>=方法的返回值类型>=return后面数据的类型

总结一下: break与continue与return之间的区别

break和return都是可以停止一段代码的执行

break作用于循环结构或switch

return作用于方法

continue跳过当前次循环，只作用于循环结构

方法的重载

一个类中的功能实现，不同的实现方式，需要用不同的方法体，那就可以让这些方法构成方法的重载,允许方法名字相同,方便使用。

方法重载：

1.同一个类中的多个方法

2.方法名相同

3.参数列表不同|方法签名不同

​ 参数的个数不同。

​ 参数的数据类型不同。

​ 不同数据类型参数的顺序不同。

方法签名：方法名+参数列表，是方法的唯一标识

如何调用多个重载方法中的其中一个：

​ 通过不同的实参匹配，由实参的数据类型、数量、不同数据类型实参的顺序决定

注意:

​ 方法的重载与方法的修饰符无关

​ 方法的重载与方法的返回值类型无关

​ 方法的重载与方法的参数名字无关

​ 方法的重载只与方法名+参数列表有关

一个类中，方法是封装的一种体现，方法的重载就是多态的一种体现

public class Demo{
    public static void main(String[] args){
        printNum(1,2);
        printNum(1,2,3);
        printNum(1.0,2.0);
        printNum(1,2.0);
        printNum(1.0,2);

    }

    public static void printNum(int x,int y){
        System.out.println("这是两个int的方法");
    }

    public static void printNum(int x,int y,int z){
        System.out.println("这是三个int的方法");
    }

    public static void printNum(double x,double y){
        System.out.println("这是两个double的方法");
    }

    public static void printNum(int x,double y){
        System.out.println("这是一个int一个double的方法");
    }

    public static void printNum(double x,int y){
        System.out.println("这是一个double一个int的方法");
    }

}

方法的递归

自己调用自己

递归远比循环消耗内存，递归次数过多或者内存较小会发生内存溢出

递归头：停止自己调用自己的条件

递归体：自己调用自己

临界条件：达到停止自己调用自己的条件

递归前进段：不停的自己调用自己的过程

递归后退段：当满足停止条件时，将结果返回给上一层的过程

注意：

​ 递归可以简化结构,合理的地方使用可以让程序变得更简单,但是用不好容易造成内存的溢出,使用要慎重

public class Demo{
    public static void main(String[] args){
        System.out.println(recursion(5));
        sum_nn(9);
    }
    //求某一个数的阶乘
    public static int recursion(int num){
        if(num==1){
            return 1;
        }
        return num*recursion(num-1);//调用自己
    }

    //通过递归实现nn乘法表的打印
    public static void sum_nn(int num){
        if(num==0){
            return;
        }
        sum_nn(num-1);
        for(int i=1;i<=num;i++){
            System.out.print(i+"+"+num+"="+i*num+"\t");
        }
        System.out.println();

    }
}

数组

数组的定义

数组是一种存储数据的数据结构

​ 变量：存储单个数据

​ 数组：存储多个数据

​ 相同类型数据的有序集合，在内存中是一段连续的内存空间

特点：

​ 数组是一种引用数据类型

​ 数组是定长的，长度一旦确定不可改变

​ 一个数组中存储相同类型的数据

​ 数组中的数据是有序的，通过索引|下标进行管理

索引|下标

​ 从0开始,每次+1

​ 根据数组的索引操作数组中的数据

​ 第一个索引->0

​ 最后一个数据的索引-> 数组名.length-1

操作数组中的数据

​ 数组名[下标|索引]

数组的长度

​ 数组名.length

public class Demo{
    public static void main(String[] args){
        int[] arr1 = new int[]{1,2,3,4,5,6};
        System.out.println(arr1[0]);
        System.out.println(arr1[1]);
        System.out.println(arr1[5]);
        System.out.println(arr1.length);

    }
}

数组的声明和初始化

声明：

​ 变量的声明：数据类型 变量名;

​ 数组的声明：数据类型[] 数组名;

​ 数据类型：可以为任意的数据类型(基本|引用)，规定所声明的数组中存储数据的类型

初始化：

​ 动态初始化：先创建数组，后赋值

​ 数据类型[] 数组名 = new 数据类型[长度n];

​ 数组创建后没有赋值存在默认值：整数->0；小数->0.0；boolean->false；字符 -> ’ '；引用数据类型 -> null

​ 静态初始化：创建数组的同时赋值

​ 数据类型[] 数组名 = new 数据类型[]{数值1,数值2,数值3…};

​ 数据类型[] 数组名 = {数值1,数值2,数值3…}; //简略写法

public class Demo{
    public static void main(String[] args){
        //动态初始化
        int[] arr1 = new int[10];
        //静态初始化
        int[] arr2 = new int[]{1,2,3,4,5,6};
        int[] arr3 = {2,3,4,5,6};
    }
}

增强for循环

数组

​ 属性:

​ 获取数组的长度 数组名.length

数组的遍历方式:

​ 1.普通for循环,遍历i当做数组的索引

​			for(int i=0;i<=数组名.length-1;i++){

​				System.out.println(数组名[i]);

​			}

​ 2.增强for循环|for…each 从前往后

​            for(数据类型  变量名:数组名|集合名){	//变量名->指代|代表数组中的每一个数据

​                System.out.println(变量名);

​            }

public class Demo{
    public static void main(String[] args){
        //动态初始化
        int[] arr1 = new int[10];
        //静态初始化
        int[] arr2 = new int[]{1,2,3,4,5,6};
        int[] arr3 = {2,3,4,5,6};

        for(int i=0;i<=arr2.length-1;i++){
            System.out.print(arr2[i]+"\t");
        }
        System.out.println("\n------------------------------------------------------------");
        for(int i:arr3){
            System.out.print(i+"\t");
        }
        System.out.println("\n------------------------------------------------------------");
        assAndPrint(arr1);	//调用assAndPrint()方法

    }

    public static void assAndPrint(int[] arr){
        for(int i=0;i<=arr.length-1;i++){
            arr[i] = i;
            System.out.print(arr[i]+"\t");
        }
    }
}