方法的调用以及方法参数传递

一、方法的调用以及方法参数传递

​ 1、方法的定义：

​ 访问修饰符 返回值类型 方法名 （[参数列表]）{

​ 方法体

​ }

​ 如果方法体中需要一些未知的数据作为执行条件，那么这些数据可以作为参数。

​ 如果方法需要返回数据，在定义有返回值的方法，且需要明确返回值类型

​ 方法调用两种方式：

​ 1、 对象名.方法名(参数)

​ 2、直接写方法名调用 ，但必须是static修饰的

​

 // 获取这个字符串的第一个字符 
 public static char method1(String str){
         return str.charAt(0); //获取字符串的第一个字符
  }

//方式一： 调用方法
对象名.method1()
//方式二：  调用静态方法 （static修饰的）
String s ="abc";
char c = method1（s）//  s将赋值给 方法的形参 str   ，那么方法执行时str有值
// c 就是方法调用后的返回值
   

1、方法的参数是基本数据类型 ，它传递的是 值

  // 计算一个数的平方  
  public static int  pow(int a){
      a=a+2;  // 6
      return a*a;  // 6*6 = 36
      
  }

  main:
     int num=4;
    int sum =   pow(num); //num实参    num赋值给a 
    System.out.println(num);  // 4
    System.out.println(sum); // 36

2、方法的参数是引用数据类型，它传递的是地址 （String类型除外）

    //参数 是数组类型
    public static int pow(int [] arr){
        arr[0]=arr[0]+2; //根据地址 改变数组的第一个元素值 arr[0]=4;
        return arr[0]*arr[0];  // 4*4
    }

调用

 // 调用另一个pow
        int [] array = {2,3};
       int sum2 =  pow(array) ; //  array中存放数组的地址  ，将地址赋值给  arr形参
        System.out.println(array[0]);// 4
        System.out.println(sum2 ); // 16

方法的重载：

​ 在一个类中，存在相同方法名的两个及以上的方法，且他们的参数列表不同（参数类型不同 ，参数个数不同，参数顺序不同），不考虑参数名，不考虑返回值类型

​ 一个类中不能存在完全相同的方法，他们是重复的方法 JVM编译不通过

例如：

  public  int  add(int a ,int b){
      return  a+b;
  }
  public int add(long a,long b){
      return  (int)(a+b);
  }
  //与前两个 不重载
  public void add(int c,int d){
      
  }
  // 能与 方法1 ，2 构成重载
  public void  add(int a){
      
  }
   // 能与 方法1 ，2 构成重载
  public void  add(int a ,long b){
      
  }
   // 能与 方法1 ，2 构成重载
  public void add(long a ,int b){
      
  }

把握： 方法名是否相同，同时 参数列表是否不同 （参数个数不同 或者参数类型不同或者参数顺序不同）

在一个方法可以调用其他的方法， 它们的执行流程

  /**
     * 程序入口
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("这里是main方法的开始");
         method1();
        System.out.println("这是main方法的结束");
    }
    // 在一个方法中可以调用另一个方法， 它们的执行顺序是这样的
    public static   void method1(){
        System.out.println("这是method1 的开始语句块 ");
        // 调用method2
        method2();
        System.out.println("这是method1的 结束语句块");
    }
    public static void method2(){
        System.out.println("这是method2 的开始语句块 ");
        //  调用method3
        method3();
        System.out.println("这是method2 的结束语句块");

    }

    public static  void  method3(){
        System.out.println("这是method3的执行语句块");
    }

二、方法的递归调用

1、定义

​ 在一个方法中，运行方法自身调用，这样的调用称为方法的递归调用， 为了避免出现方法调用时出现死循环，递归调用中必须定义 方法结束调用的条件。

方法递归调用执行流程

 public static void m3(int i){
        if(i==5){
            return ;
        }
        System.out.println("这是m3方法开始i :"+ i);
        i++;
        m3(i);
        System.out.println("m3方法的结束 i:"+ i );
  }
   public static void main(String[] args) {
      

        m3(0); //
    }

​ 练习1 ： 使用递归计算一个数的阶乘

​ n =5 = 5! = 5*4的阶乘

​ f(n) = n* f(n-1) =

​ (n-1)*f(n-1-1)

public static int f(int n ){
    if(n==1){
        return 1;
    }
    int s = n*f(n-1);
    System.out.println("结束 --"+s);
    return s;
}
// n =5             n=4                 n=3          n=2           n=1 return 1
 // s = 5*f(4)      s=4* f（3）        s= 3* f(2)    s=2*f(1)
 //  s=5*24          s=4* 6             s=3* 2= 6     s=2
 // s = 120