JAVA方法的定义与调用

JAVA方法的定义与调用

一，方法的定义

方法 : 解决问题的办法
实现功能的代码段

作用:
功能代码的封装
提高代码的复用性与安全性

特点:
1.方法不调用不执行
2.方法定义在类中方法外,方法不能嵌套

方法的定义

修饰符 返回值类型|void 方法名(参数列表){
方法体;
return 返回值;
}

修饰符: 访问权限修饰符–>默认public static
返回值类型 : 方法中代码执行完毕之后,是否需要得到一个结果,定义为一个有返回值的方法->方法值的类型就是结果的数据类型
方法名 : 根据方法名字调用方法
标识符：标识符的命名规则与标识符的命名规范
参数列表：
可以定义参数,可以不定义参数
思考: 方法的定义的时候,执行中,是否存在未知的,不确定的,可能会改变的数据,如果有定义在方法的参数列表上
参数列表: 数据类型 参数名1,数据类型 参数名2…
参数->相当于局部变量的声明
return : 在有返回值类型方法中必须存在return,并且return后面必须存在值
1)提前结束方法

​ 2)带出返回值 ,返回给方法的调用处

//有返回值无参数的方法
public static int demo1(){
    return 0;
}

//有返回值有参数的方法
public static int demo1(int a){
    return a;
}

//无返回值无参数的方法
public static void demo1(){
    System.out.println(1);
}

//无返回值有参数的方法
public static int demo1(int a){
    System.out.println(a);
}

二，方法的参数

形式参数->形参 :

​ 定义方法时()中的参数
​ 相当于局部变量的声明
​ 作用域: 在当前方法中有效

实际参数->实参：

​ 调用方法时()中的参数
​ 相当于为局部变量赋值

形参存不存在默认值,赋值根据实参决定

形参决定实参，形参与实参要求一一对应：
类型对应，顺序对应，个数对应

三，break与continue与return之间的区别

区别

一、作用不同

1、break：执行break操作，跳出所在的当前整个循环，到外层代码继续执行。

2、continue：执行continue操作，跳出本次循环，从下一个迭代继续运行循环，内层循环执行完毕，外层代码继续运行。

3、return：执行return操作，直接返回函数，所有该函数体内的代码（包括循环体）都不会再执行。

二、结束不同

1、break：break不仅可以结束其所在的循环，还可结束其外层循环，但一次只能结束一种循环。

2、continue：continue结束的是本次循环，将接着开始下一次循环。

3、return：return同时结束其所在的循环和其外层循环。

不可达语句

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

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

四，方法的调用

方法的调用:
        执行方法体中的代码
        普通调用 : 方法名(参数列表);  -->没有办法获取返回值
        赋值调用 : 数据类型 变量名 = 方法名(参数列表);
        输出调用 : System.out.println(方法名(参数列表));

public static void main(String[] args) {
    //普通调用，适用于没有返回值的方法
    demo1();

    //赋值调用，适用于有返回值的方法
    int a = demo2(3,4);
    System.out.println(a);

    //输出调用，适用于有返回值的方法
    System.out.println(demo2(3,5));
}

//无返回值的方法
public static void demo1(){
    System.out.println("无返回值没有参数的方法");
}

//有返回值的方法
public static int demo2(int x,int y){
    System.out.println("有返回值有参数的方法");
    return x+y;
}

五，方法的重载

方法的重载
前提 : 如果一个类中的功能的实现,不同的实现方式,需要不同的方法体,可以让这些方法构成方法的重载,就允许方法名字相同,方法使用 一个类中的多个方法,他们方法名相同,参数列表不同

满足的三个条件:
        1.同一个类中的多个方法
        2.方法名相同
        3.参数列表不同 | 方法签名不同
            参数的个数不同
            参数的类型不同
            不同类型的参数顺序不同

方法签名 : 方法名+参数列表,是方法的唯一标识

注意:
方法的重载与方法的修饰符无关
方法的重载与方法的返回值类型无关
方法的重载与方法的参数名字无关
方法的重载只与方法名+参数列表有关

public class DemoTest {
    public static void main(String[] args) {
        getSum(1.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(double x,double y){
        System.out.println("两个double整数"+(x+y));
    }

    public static void getSum(double x,double y,double z){
        System.out.println("三个double整数"+(x+y+z));
    }

    //参数列表顺序不同
    public static void getSum(int x,double y){
        System.out.println("int,double整数"+(x+y));
    }
    public static void getSum(double x,int y){
        System.out.println("double,int整数"+(x+y));
    }
}

六，方法执行时内存的调用

七，方法的递归

方法的递归
自己调用自己

​ 递归头 : 停止自己调用自己的条件
​ 递归体 : 自己调用自己

​ 临界条件 : 递归头 : 停止自己调用自己的条件
​ 递归前进段 : 不停的自己调用自己的过程
​ 递归后退段 : 当满足临界条件之后,把结果返回给上一层的过程

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

public static void main(String[] args) {
    System.out.println(recursion(5));
    mulTable(9);
}

//求某一个数的阶乘  5! 5*4*3*2*1   5*4!
public static int recursion(int i){
    if(i==1){
        return 1;
    }
    return i*recursion(i-1);
}

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

//递归相当于一个for循环