方法

方法

方法的概念

​ 将一个功能抽取出来，放在类中的大括号中， 形成一个独立的功能 ， 当需要使用该功能时，则调用它， 这样可以增强代码的复用性（重复利用） ，并解决代码的冗余现象。

方法的语法：

​ [访问修饰符] 返回值类型 方法名( [参数类型 参数名1 , 参数类型 参数名2 ...] ){

​ 方法体

​ }

​ 详解：

​ 访问修饰符： 用于修饰这个方法的调用范文 目前默认 public static

​ 返回值类型： 无返回值就写void 或者 方法执行后返回的结果的数据类型 ，方法执行完之后会将结果返回

​ 方法名 ： 给方法取名， 准寻标识符的规则

​ 参数类型 、参数名： 它们是同时定义 ，方法在执行时未知的数据，需要在调用方法时进行传递值。 参数类型表示 这个参数的数据类型 ，参数名就是一个参数名称 这个参数名可以在方法体中使用。

​ 方法体： 这个方法具有的功能（代码块）

    定义一个方法
    public static int add（int num1 ， int num2）{
    	  
    	  return num1+num2;
    
    } 

​ 根据方法的参数 不同，返回值不同，可以将方法分为四类：

1、无参无返回值方法

语法：

   public  static  void 方法名(){
       方法体 
   }

2、无参有返回值方法

​ 语法：

 public static 返回值类型  方法名 (){
     方法体
 }

结果在n中

3、有参无返回值方法

​ 语法：

public  static void 方法名(参数列表 ){
    方法体
}

情况一、 当参数中是基本数据类型 ，将实参的值赋值给 形参

public  static void add(int num){
    num++;	
    System.out.println("方法中 num 的值："+num);

}

调用方法： num的改变不会改变n 的值 ，因为是两个独立的内存

int n =10;
System.out.println(n);
add(n);
System.out.println("方法外面 实参的值："+n);

结果输出：

​ 方法中 num 的值： 11

​ 方法外面 实参的值：10

情况二： 当参数的数据类型是引用数据类型

例如 数组 、类

​

 // 方法的比对   参数是数组
    public static  void add(int [] arr){
        arr[0]++;
        System.out.println("方法中 arr[0]="+arr[0]);
    }

调用：

       int [] array ={10,20};
        add(array);// 会调用 参数是数组的add方法
        System.out.println("方法外面的 arr[0]="+ array[0]);

结果：

​ 方法中 arr[0]=11
​ 方法外面的 arr[0]=11

类的调用：

  public static void addAge(Student student){
        // 将学生的年龄 获取 自加
       int age =  student.age;
       age++;
       //  在重新赋值
       student.age=age;

    }
    

调用

 Student student = new Student(); // age默认为 18
        System.out.println("方法调用之前： "+student.age); // 18
         addAge(student); // 传的地址
        System.out.println("方法外面 学生的年龄："+student.age);

结果输出： 方法调用之前： 18

​ 方法外面 学生的年龄：19

  /**
         *   以上方法调用 的结论： 对于参数为引用数据类型，方法外面和方法内部公用同一块内存，
         *       也就是说  参数再传递时，将引用类型的地址赋值给 方法的形参
         *                      对于基本数据类型 ，方法的参数将 值的副本赋值给形参，这样形参的改变
         *                      不会影响实参的值
         *       原因： 引用数据类型在参数传递时 是地址  （JVM对于堆内存的大小不可控）
         *             基本数据类型在参数传递时 是值
         *
         */

情况三、 当参数是String类型时 ，String是引用数据类型 ，但是在参数传递时，是与基本类型一样

 public static void main(String[] args) {
    // 参数是字符串
        String uname ="朱正康";
        sayHello(uname);
        System.out.println("我最后对"+uname+"sayHello");
    }
    public static void sayHello(String name){
        name="王丽杨";
        System.out.println("我对"+name+"sayHello");
    }

结果：

我对王丽杨sayHello
我最后对朱正康sayHello

4、有参有返回值方法

语法：

  public  static 返回值类型 方法名(参数列表){
      方法体
  }

​

例如 ：

    public static String sayHello(String name){
        name="王丽杨";
        System.out.println("我对"+name+"sayHello");
        return name ;
    }

调用

 public static void main(String[] args) {		
		// 参数是字符串
        String uname ="朱正康";
        // 将返回值接收  ，这是 uname 才被改变 ，如果不接受，则不改变
        uname = sayHello(uname);
        System.out.println("我最后对"+uname+"sayHello");
 }

结果：

我对王丽杨sayHello
我最后对王丽杨sayHello

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

​ 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); //
    }

​