JAVA方法的调用重载递归

Java方法

方法: 解决事情的办法

• 实现功能的代码段

• 优点:

• 1)提到代码的复用性

• 2)便于后期维护

• 特点:

• 1)不调用不执行

• 2)方法不能嵌套,定义在类中方法外的位置

• 定义:

• 有返回值类型的方法

• 修饰符 返回值类型 方法名(参数列表){

• 实现功能的代码段;

• return 返回值;

• }

• 修饰符 : 访问权限修饰符,先默认定义为public static

• 返回值类型 : 思考方法体代码执行完毕之后,是否需要得到一个结果|数据值,如果需要就定义为有返回值类型的方法,不需要就定义为没有返回值类型的方法

• 结果的数据类型

• 基本数据类型|引用数据类型

• 方法名 : 根据方法名调用方法

• 标识符: 符合标识符的规则与规范

• (参数列表) : 可以定义参数,可以不定义参数,可以定义多个参数

• 分析: 在方法的定义或者实现过程中,是否存在未知的,不确定的,可能会改变的数据,如果存在定义在方法的参数列表上

• 参数列表: 数据类型 参数名1,数据类型 参数名2.... --> 相当于变量的声明

• 数据类型可以为任意数据类型

• {} : 方法体语句, 实现功能的代码段;

• return : 1)提前结束方法 2)带出返回值 return 返回值;

• 在一个有返回值类型的方法必须 存在return关键字

• 没有返回值类型的

• 方法修饰符 void 方法名(参数列表){

• 方法体语句;

• [return]

• }

• void : 标识没有返回值类型的方法

• return : 1)提前结束方法

• 方法的调用:

• 有返回值类型的方法:

• 1.普通调用

• 2.输出调用

• 3.赋值调用

• 没有返回值类型的方法;

• 1.普通调用

• 方法的参数:

• 1.形式参数(形参) : 定义方法时()中的参数

• 2.实际参数(实参) : 调用方法时()中的参数

• 形参与实参之间需要一一对应

• 个数一致

• 类型一致

• 不同类型的形参顺序一致

• 调用:

• 执行方法中的代码

• 普通调用: 方法名(参数列表);

• 有返回值类型的方法调用时候需要接收返回值:

• 1)赋值调用

• 数据类型 变量名 = 方法名(参数列表);

• 2)输出调用

• System.out.println(方法名(参数列表));

• 没有返回值类型的方法

• 3）普通调用

• 方法名();

• 形参不赋值是否存在默认值

• 方法的形参相当于局部变量的声明

• 不存在默认值,所有形参与实参之间要求一一对应

public class Class001_Method {
    //类中方法外的位置
    public static void main(String[] args) {
        //赋值调用
        double d = getPI();
        System.out.println(d);
        //输出调用
        System.out.println(getPI());
        System.out.println(getSum(3,5));
        //普通调用:无法接受返回值
        getPI();
        print();
    }
​
    //需求 : 定义一个功能: 返回PI的值
    //返回值: 需求 double
    //参数: 不需要
    //方法名: getPI()
    public static double getPI(){
        System.out.println("有返回值的,没有参数的方法");
        return 3.1415926;
    }
    //需求: 求两个整数的和
    //返回值: 需要 int
    //参数: 两个整数 int x,int y
    //方法名: getSum
    public static int getSum( int x,int y){
        System.out.println("有返回值的,有参数的方法");
        return x+y;
    }
       //封装一个99乘法表输出
    //返回值: 不需要
    //参数: 不需要
    public static void print(){
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+"\t");//没有返回值和参数的方法
            }
            System.out.println();
        }
    }
}
​
​

• return 与 兼容类型 :

• return 返回

• 1)提前结束方法

• 2)在有返回值类型的方法中,return带出返回值 return 返回值

• 返回给方法得到调用处

• 在有返回值类型的方法中必须存在return

• 不可达语句: 没有执行时机

• 1)能够执行到return后面的代码

• 2)while--true for(;;){} 死循环后面的代码

• 3)continue后面

• 4)break后面

• 5)while-->false

• 兼容类型:

• 参数: 形参的类型>=实参的类型

• 返回值: 接收返回值的变量类型>=方法的返回值类型>=return后面数据的类型

• 方法的重载:

• 前提: 当一个类中实现某个功能的时候,这个功能却有不同的实现方式|需要接受不同的参数,可以让这些相同功能实现的方法,构成方法的重载,就允许方法名相同

• 要求

• 同一个类中的多个方法 方法名相同 参数列表不同|方法签名不同

• 方法签名 : 方法名+参数列表 区分方法的唯一标识

• 注意:

• 参数列表不同:

• 参数个数不同

• 数的类型不同

• 不同类型的参数顺序不同

• 重载方法如何调用:

• 方法名(实参);

• 有实参决定重载方法的调用

• 注意问题

• 1.方法的重载与方法的修饰符是否有关? 无关

• 2.方法的重载与方法的返回值类型是否有关? 无关

• 3.方法的重载与参数的名字是否有关? 无关

• 总结:

• 方法的重载只与方法签名有关

• 方法就是封装的一种体现

• 方法的重载就是多态的一种体现

public class Class001_Overload {
    public static void main(String[] args) {
        getSum(1,1.1);
    }
    //对数求和
    public static void getSum(int x,int y){
        System.out.println("两个int类型参数的和"+(x+y));
    }
​
    public static void getSum(int x,int y,int z){
        System.out.println("三个int类型参数的和"+(x+y+z));
    }
​
    public static void getSum(int x,double y){
        System.out.println("一个int,一个double类型参数的和"+(x+y));
    }
​
    public static void getSum(double y,int x){
        System.out.println("一个double,一个int类型参数的和"+(x+y));
    }
}

• 方法的递归（了解）

• 定义：是一种直接或者间接调用自身的方法

• 优点：合理的位置使用递归可以简化代码结构

• 缺点：在结构复杂的情况，大量的占用内存，有可能降低效率，可能会遇到内存溢出。

• 临界条件:

• 停止自己调用自己的条件

• 递归前进段: 不停的自己调用自己,知道临界条件之间这个过程

• 递归后退段: 从临界条件开始,将结果返回给调用的上一层的过程

public class Class001_Recursion {
    public static void main(String[] args) {
        System.out.println(recursion(3));;
    }
    //递归 : 求某个数阶乘   5! = 5*4!
    //返回值: 需要 int
    //参数: int i
    public static int recursion(int i){
        //临界条件
        if(i==1){
            return 1;
        }
        return i * recursion(i-1);
    }
}
​